Merge pull request #7214 from gadfort/gui-colors

gui: background color support

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

@@ -489,6 +489,7 @@ DisplayControls::DisplayControls(QWidget* parent)
 
   region_color_ = QColor(0x70, 0x70, 0x70, 0x70);  // semi-transparent mid-gray
   region_pattern_ = Qt::SolidPattern;
+  background_color_ = Qt::black;
   makeLeafItem(misc_.scale_bar, "Scale bar", misc, Qt::Checked);
   makeLeafItem(misc_.access_points, "Access points", misc, Qt::Unchecked);
   makeLeafItem(
@@ -499,6 +500,8 @@ DisplayControls::DisplayControls(QWidget* parent)
   makeLeafItem(
       misc_.manufacturing_grid, "Manufacturing grid", misc, Qt::Unchecked);
   makeLeafItem(misc_.gcell_grid, "GCell grid", misc, Qt::Unchecked);
+  makeLeafItem(
+      misc_.background, "Background", misc, {}, false, background_color_);
   toggleParent(misc_group_);
 
   checkLiberty();
@@ -523,6 +526,8 @@ DisplayControls::DisplayControls(QWidget* parent)
           this,
           &DisplayControls::itemContextMenu);
 
+  connect(
+      this, &DisplayControls::colorChanged, this, &DisplayControls::changed);
   // register renderers
   if (gui::Gui::get() != nullptr) {
     for (auto renderer : gui::Gui::get()->renderers()) {
@@ -604,7 +609,9 @@ void DisplayControls::writeSettingsForRow(QSettings* settings,
                           name->child(r, Selectable));
     }
   } else {
-    settings->setValue("visible", asBool(visible));
+    if (visible != nullptr) {
+      settings->setValue("visible", asBool(visible));
+    }
     if (selectable != nullptr) {
       settings->setValue("selectable", asBool(selectable));
     }
@@ -643,7 +650,9 @@ void DisplayControls::readSettingsForRow(QSettings* settings,
                          name->child(r, Selectable));
     }
   } else {
-    visible->setCheckState(getChecked(settings, "visible", visible));
+    if (visible != nullptr) {
+      visible->setCheckState(getChecked(settings, "visible", visible));
+    }
     if (selectable != nullptr) {
       selectable->setCheckState(getChecked(settings, "selectable", selectable));
     }
@@ -680,6 +689,7 @@ void DisplayControls::readSettings(QSettings* settings)
 
   settings->beginGroup("other");
   settings->beginGroup("color");
+  getColor(misc_.background, background_color_, "background");
   getColor(
       blockages_.blockages, placement_blockage_color_, "blockages_placement");
   getColor(rulers_, ruler_color_, "ruler");
@@ -753,6 +763,7 @@ void DisplayControls::writeSettings(QSettings* settings)
 
   settings->beginGroup("other");
   settings->beginGroup("color");
+  settings->setValue("background", background_color_);
   settings->setValue("blockages_placement", placement_blockage_color_);
   settings->setValue("ruler", ruler_color_);
   settings->setValue("instance_name", instance_name_color_);
@@ -876,7 +887,9 @@ void DisplayControls::toggleParent(const QStandardItem* parent,
 
 void DisplayControls::toggleParent(ModelRow& row)
 {
-  toggleParent(row.name, row.visible, Visible);
+  if (row.visible != nullptr) {
+    toggleParent(row.name, row.visible, Visible);
+  }
   if (row.selectable != nullptr) {
     toggleParent(row.name, row.selectable, Selectable);
   }
@@ -982,6 +995,52 @@ 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};
+  }
+  if (item == blockages_.blockages.swatch) {
+    return {&placement_blockage_color_, &placement_blockage_pattern_, false};
+  }
+  if (item == misc_.regions.swatch) {
+    return {&region_color_, &region_pattern_, false};
+  }
+  if (item == instance_shapes_.names.swatch) {
+    return {&instance_name_color_, nullptr, false};
+  }
+  if (item == instance_shapes_.iterm_labels.swatch) {
+    return {&iterm_label_color_, nullptr, false};
+  }
+  if (item == rulers_.swatch) {
+    return {&ruler_color_, nullptr, false};
+  }
+  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) {
@@ -1000,41 +1059,10 @@ void DisplayControls::displayItemDblClicked(const QModelIndex& index)
     Qt::BrushStyle* item_pattern = nullptr;
     bool has_sibling = false;
 
-    // check if placement
-    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;
@@ -1065,7 +1093,7 @@ void DisplayControls::displayItemDblClicked(const QModelIndex& index)
         *item_pattern = display_dialog->getSelectedPattern();
       }
       view_->repaint();
-      emit changed();
+      emit colorChanged();
     }
   }
 }
@@ -1092,6 +1120,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,
@@ -1291,7 +1344,7 @@ QStandardItem* DisplayControls::makeParentItem(ModelRow& row,
 void DisplayControls::makeLeafItem(ModelRow& row,
                                    const QString& text,
                                    QStandardItem* parent,
-                                   Qt::CheckState checked,
+                                   std::optional<Qt::CheckState> checked,
                                    bool add_selectable,
                                    const QColor& color,
                                    const QVariant& user_data)
@@ -1309,16 +1362,18 @@ void DisplayControls::makeLeafItem(ModelRow& row,
     row.swatch->setData(user_data, user_data_item_idx_);
   }
 
-  row.visible = new QStandardItem("");
-  row.visible->setCheckable(true);
-  row.visible->setEditable(false);
-  row.visible->setCheckState(checked);
+  if (checked.has_value()) {
+    row.visible = new QStandardItem("");
+    row.visible->setCheckable(true);
+    row.visible->setEditable(false);
+    row.visible->setCheckState(checked.value());
+  }
 
   if (add_selectable) {
     row.selectable = new QStandardItem("");
     row.selectable->setCheckable(true);
     row.selectable->setEditable(false);
-    row.selectable->setCheckState(checked);
+    row.selectable->setCheckState(checked.value_or(Qt::Unchecked));
   }
 
   parent->appendRow({row.name, row.swatch, row.visible, row.selectable});
@@ -1354,6 +1409,11 @@ QIcon DisplayControls::makeSwatchIcon(const QColor& color)
   return QIcon(swatch);
 }
 
+QColor DisplayControls::background()
+{
+  return background_color_;
+}
+
 QColor DisplayControls::color(const dbTechLayer* layer)
 {
   auto it = layer_color_.find(layer);
@@ -2011,8 +2071,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

@@ -20,8 +20,10 @@
 #include <QVBoxLayout>
 #include <functional>
 #include <map>
+#include <optional>
 #include <set>
 #include <string>
+#include <tuple>
 #include <vector>
 
 #include "db_sta/dbNetwork.hh"
@@ -155,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);
@@ -166,6 +169,7 @@ class DisplayControls : public QDockWidget,
   void restoreTclCommands(std::vector<std::string>& cmds);
 
   // From the Options API
+  QColor background() override;
   QColor color(const odb::dbTechLayer* layer) override;
   Qt::BrushStyle pattern(const odb::dbTechLayer* layer) override;
   QColor placementBlockageColor() override;
@@ -236,6 +240,7 @@ class DisplayControls : public QDockWidget,
  signals:
   // The display options have changed and clients need to update
   void changed();
+  void colorChanged();
 
   // Emit a selected tech layer
   void selected(const Selected& selected);
@@ -368,6 +373,7 @@ class DisplayControls : public QDockWidget,
     ModelRow module;
     ModelRow manufacturing_grid;
     ModelRow gcell_grid;
+    ModelRow background;
   };
 
   struct InstanceShapeModels
@@ -415,7 +421,7 @@ class DisplayControls : public QDockWidget,
   void makeLeafItem(ModelRow& row,
                     const QString& text,
                     QStandardItem* parent,
-                    Qt::CheckState checked,
+                    std::optional<Qt::CheckState> checked,
                     bool add_selectable = false,
                     const QColor& color = Qt::transparent,
                     const QVariant& user_data = QVariant());
@@ -474,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_;
@@ -530,6 +540,8 @@ class DisplayControls : public QDockWidget,
 
   std::map<const odb::dbSite*, QColor> site_color_;
 
+  QColor background_color_;
+
   QColor placement_blockage_color_;
   Qt::BrushStyle placement_blockage_pattern_;
 

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(