gui: extend set display controls to access color information

Signed-off-by: Peter Gadfort <gadfort@zeroasic.com>

Author: gadfort

src/gui/README.md

@@ -739,8 +739,8 @@ gui::set_display_controls
 | Switch Name | Description |
 | ---- | ---- |
 | `name` |  is the name of the control. For example, for the power nets option this would be ``Signals/Power`` or could be ``Layers/*`` to set the option for all the layers. |
-| `display_type` | is either ``visible`` or ``selectable`` |
-| `value` |is either ``true`` or ``false`` |
+| `display_type` | is either ``visible``, ``selectable``, ``color`` |
+| `value` | is either ``true`` or ``false`` for ``visible`` or ``selectable`` or the name of the color |
 
 ### Check Display Controls
 

src/gui/include/gui/gui.h

@@ -635,6 +635,8 @@ class Gui
   // modify display controls
   void setDisplayControlsVisible(const std::string& name, bool value);
   void setDisplayControlsSelectable(const std::string& name, bool value);
+  void setDisplayControlsColor(const std::string& name,
+                               const Painter::Color& color);
   // Get the visibility/selectability for a control in the 'Display Control'
   // panel.
   bool checkDisplayControlsVisible(const std::string& name);

src/gui/src/displayControls.cpp

@@ -995,6 +995,48 @@ void DisplayControls::displayItemSelected(const QItemSelection& selection)
   }
 }
 
+std::tuple<QColor*, Qt::BrushStyle*, bool> DisplayControls::lookupColor(
+    QStandardItem* item,
+    const QModelIndex* index)
+{
+  if (item == misc_.background.swatch) {
+    return {&background_color_, nullptr, false};
+  } else if (item == blockages_.blockages.swatch) {
+    return {&placement_blockage_color_, &placement_blockage_pattern_, false};
+  } else if (item == misc_.regions.swatch) {
+    return {&region_color_, &region_pattern_, false};
+  } else if (item == instance_shapes_.names.swatch) {
+    return {&instance_name_color_, nullptr, false};
+  } else if (item == instance_shapes_.iterm_labels.swatch) {
+    return {&iterm_label_color_, nullptr, false};
+  } else if (item == rulers_.swatch) {
+    return {&ruler_color_, nullptr, false};
+  } else {
+    QVariant tech_layer_data = item->data(user_data_item_idx_);
+    if (!tech_layer_data.isValid()) {
+      return {nullptr, nullptr, false};
+    }
+    auto tech_layer = tech_layer_data.value<dbTechLayer*>();
+    auto site = tech_layer_data.value<odb::dbSite*>();
+    if (tech_layer != nullptr) {
+      QColor* item_color = &layer_color_[tech_layer];
+      Qt::BrushStyle* item_pattern = &layer_pattern_[tech_layer];
+      if (tech_layer->getType() != dbTechLayerType::ROUTING) {
+        if (index && index->row() != 0) {
+          // ensure if a via is the first layer, it can still be modified
+          return {item_color, item_pattern, false};
+        }
+      } else {
+        return {item_color, item_pattern, true};
+      }
+    } else if (site != nullptr) {
+      return {&site_color_[site], nullptr, false};
+    }
+  }
+
+  return {nullptr, nullptr, false};
+}
+
 void DisplayControls::displayItemDblClicked(const QModelIndex& index)
 {
   if (index.column() == 0) {
@@ -1013,43 +1055,10 @@ void DisplayControls::displayItemDblClicked(const QModelIndex& index)
     Qt::BrushStyle* item_pattern = nullptr;
     bool has_sibling = false;
 
-    // check if placement
-    if (color_item == misc_.background.swatch) {
-      item_color = &background_color_;
-    } else if (color_item == blockages_.blockages.swatch) {
-      item_color = &placement_blockage_color_;
-      item_pattern = &placement_blockage_pattern_;
-    } else if (color_item == misc_.regions.swatch) {
-      item_color = &region_color_;
-      item_pattern = &region_pattern_;
-    } else if (color_item == instance_shapes_.names.swatch) {
-      item_color = &instance_name_color_;
-    } else if (color_item == instance_shapes_.iterm_labels.swatch) {
-      item_color = &iterm_label_color_;
-    } else if (color_item == rulers_.swatch) {
-      item_color = &ruler_color_;
-    } else {
-      QVariant tech_layer_data = color_item->data(user_data_item_idx_);
-      if (!tech_layer_data.isValid()) {
-        return;
-      }
-      auto tech_layer = tech_layer_data.value<dbTechLayer*>();
-      auto site = tech_layer_data.value<odb::dbSite*>();
-      if (tech_layer != nullptr) {
-        item_color = &layer_color_[tech_layer];
-        item_pattern = &layer_pattern_[tech_layer];
-        if (tech_layer->getType() != dbTechLayerType::ROUTING) {
-          if (index.row() != 0) {
-            // ensure if a via is the first layer, it can still be modified
-            return;
-          }
-        } else {
-          has_sibling = true;
-        }
-      } else if (site != nullptr) {
-        item_color = &site_color_[site];
-      }
-    }
+    const auto lookup = lookupColor(color_item, &index);
+    item_color = std::get<0>(lookup);
+    item_pattern = std::get<1>(lookup);
+    has_sibling = std::get<2>(lookup);
 
     if (item_color == nullptr) {
       return;
@@ -1107,6 +1116,31 @@ void DisplayControls::setControlByPath(const std::string& path,
   }
 }
 
+// path is separated by "/", so setting Standard Cells, would be
+// Instances/StdCells
+void DisplayControls::setControlByPath(const std::string& path,
+                                       const QColor& color)
+{
+  std::vector<QStandardItem*> items;
+  findControlsInItems(path, Swatch, items);
+
+  if (items.empty()) {
+    logger_->error(utl::GUI, 40, "Unable to find {} display control", path);
+  } else {
+    for (auto* item : items) {
+      const auto& [item_color, item_style, sibling] = lookupColor(item);
+      if (sibling || item_color == nullptr) {
+        continue;
+      }
+      *item_color = color;
+      item->setIcon(makeSwatchIcon(color));
+    }
+  }
+  if (!items.empty()) {
+    emit colorChanged();
+  }
+}
+
 // path is separated by "/", so setting Standard Cells, would be
 // Instances/StdCells
 bool DisplayControls::checkControlByPath(const std::string& path,
@@ -2033,8 +2067,11 @@ void DisplayControls::buildRestoreTclCommands(std::vector<std::string>& cmds,
     if (item->hasChildren()) {
       buildRestoreTclCommands(cmds, item, name + "/");
     } else {
-      bool visible = parent->child(r, Visible)->checkState() == Qt::Checked;
-      cmds.push_back(fmt::format(FMT_RUNTIME(visible_restore), name, visible));
+      auto* visible = parent->child(r, Visible);
+      if (visible) {
+        bool vis = visible->checkState() == Qt::Checked;
+        cmds.push_back(fmt::format(FMT_RUNTIME(visible_restore), name, vis));
+      }
       auto* selectable = parent->child(r, Selectable);
       if (selectable != nullptr) {
         bool select = selectable->checkState() == Qt::Checked;

src/gui/src/displayControls.h

@@ -23,6 +23,7 @@
 #include <optional>
 #include <set>
 #include <string>
+#include <tuple>
 #include <vector>
 
 #include "db_sta/dbNetwork.hh"
@@ -156,6 +157,7 @@ class DisplayControls : public QDockWidget,
   void setControlByPath(const std::string& path,
                         bool is_visible,
                         Qt::CheckState value);
+  void setControlByPath(const std::string& path, const QColor& color);
   bool checkControlByPath(const std::string& path, bool is_visible);
 
   void registerRenderer(Renderer* renderer);
@@ -478,6 +480,10 @@ class DisplayControls : public QDockWidget,
 
   void checkLiberty(bool assume_loaded = false);
 
+  std::tuple<QColor*, Qt::BrushStyle*, bool> lookupColor(
+      QStandardItem* item,
+      const QModelIndex* index = nullptr);
+
   QTreeView* view_;
   DisplayControlModel* model_;
   QMenu* routing_layers_menu_;

src/gui/src/gui.cpp

@@ -583,6 +583,13 @@ void Gui::selectMarkers(odb::dbMarkerCategory* markers)
   main_window->getDRCViewer()->selectCategory(markers);
 }
 
+void Gui::setDisplayControlsColor(const std::string& name,
+                                  const Painter::Color& color)
+{
+  const QColor qcolor(color.r, color.g, color.b, color.a);
+  main_window->getControls()->setControlByPath(name, qcolor);
+}
+
 void Gui::setDisplayControlsVisible(const std::string& name, bool value)
 {
   main_window->getControls()->setControlByPath(

src/gui/src/gui.i

@@ -301,25 +301,111 @@ void clear_highlights(int highlight_group = 0)
   gui->clearHighlights(highlight_group);
 }
 
-void set_display_controls(const char* name, const char* display_type, bool value)
+void set_display_controls(const char* name, const char* display_type, const char* value)
 {
   if (!check_gui("set_display_controls")) {
     return;
   }
   auto gui = gui::Gui::get();
+  auto logger = ord::OpenRoad::openRoad()->getLogger();
 
   std::string disp_type = display_type;
+  std::string str_value = value;
   // make lower case
   std::transform(disp_type.begin(), 
                  disp_type.end(), 
                  disp_type.begin(), 
                  [](char c) { return std::tolower(c); });
   if (disp_type == "visible") {
-    gui->setDisplayControlsVisible(name, value);
+    bool bval = str_value == "true" || str_value == "1";
+    gui->setDisplayControlsVisible(name, bval);
   } else if (disp_type == "selectable") {
-    gui->setDisplayControlsSelectable(name, value);
+    bool bval = str_value == "true" || str_value == "1";
+    gui->setDisplayControlsSelectable(name, bval);
+  } else if (disp_type == "color") {
+    gui::Painter::Color color = gui::Painter::black;
+    if (str_value.empty()) {
+      logger->error(GUI, 41, "Color is required");
+    }
+    if (str_value[0] == '#' && (str_value.size() == 7 || str_value.size() == 9)) {
+      uint hex_color = 0;
+      for (int i = 1; i < str_value.size(); i++) {
+        const char c = std::tolower(str_value[i]);
+        hex_color *= 16;
+        if (c >= '0' && c <= '9') {
+          hex_color += c - '0';
+        } else if (c >= 'a' && c <= 'f') {
+          hex_color += c - 'a' + 10;
+        } else {
+          logger->error(GUI, 43, "Unable to decode color: {}", str_value);
+        }
+      }
+      if (str_value.size() == 7) {
+        hex_color *= 256;
+        hex_color += 255;
+      }
+      color.r = (hex_color & 0xff000000) >> 24;
+      color.g = (hex_color & 0x00ff0000) >> 16;
+      color.b = (hex_color & 0x0000ff00) >> 8;
+      color.a = hex_color & 0x000000ff;
+    } else if (str_value == "black") {
+      color = gui::Painter::black;
+    } else if (str_value == "white") {
+      color = gui::Painter::white;
+    } else if (str_value == "dark_gray") {
+      color = gui::Painter::dark_gray;
+    } else if (str_value == "gray") {
+      color = gui::Painter::gray;
+    } else if (str_value == "light_gray") {
+      color = gui::Painter::light_gray;
+    } else if (str_value == "red") {
+      color = gui::Painter::red;
+    } else if (str_value == "green") {
+      color = gui::Painter::green;
+    } else if (str_value == "blue") {
+      color = gui::Painter::blue;
+    } else if (str_value == "cyan") {
+      color = gui::Painter::cyan;
+    } else if (str_value == "magenta") {
+      color = gui::Painter::magenta;
+    } else if (str_value == "yellow") {
+      color = gui::Painter::yellow;
+    } else if (str_value == "dark_red") {
+      color = gui::Painter::dark_red;
+    } else if (str_value == "dark_green") {
+      color = gui::Painter::dark_green;
+    } else if (str_value == "dark_blue") {
+      color = gui::Painter::dark_blue;
+    } else if (str_value == "dark_cyan") {
+      color = gui::Painter::dark_cyan;
+    } else if (str_value == "dark_magenta") {
+      color = gui::Painter::dark_magenta;
+    } else if (str_value == "dark_yellow") {
+      color = gui::Painter::dark_yellow;
+    } else if (str_value == "orange") {
+      color = gui::Painter::orange;
+    } else if (str_value == "purple") {
+      color = gui::Painter::purple;
+    } else if (str_value == "lime") {
+      color = gui::Painter::lime;
+    } else if (str_value == "teal") {
+      color = gui::Painter::teal;
+    } else if (str_value == "pink") {
+      color = gui::Painter::pink;
+    } else if (str_value == "brown") {
+      color = gui::Painter::brown;
+    } else if (str_value == "indigo") {
+      color = gui::Painter::indigo;
+    } else if (str_value == "turquoise") {
+      color = gui::Painter::turquoise;
+    } else if (str_value == "transparent") {
+      color = gui::Painter::transparent;
+    } else {
+      logger->error(GUI, 42, "Color not recognized: {}", str_value);
+    }
+
+    gui->setDisplayControlsColor(name, color);
   } else {
-    auto logger = ord::OpenRoad::openRoad()->getLogger();
     logger->error(GUI, 7, "Unknown display control type: {}", display_type);
   }
 }