Merge pull request #8083 from LucasYuki/gui_timing_widget_filter_clock

Gui: Add clock filter in the Timing Report

Author: maliberty

src/gui/CMakeLists.txt

@@ -69,6 +69,7 @@ if (Qt5_FOUND AND BUILD_GUI)
     src/bufferTreeDescriptor.cpp
     src/chartsWidget.cpp
     src/GUIProgress.cpp
+    src/dropdownCheckboxes.cpp
     resources/resource.qrc
   )
 

src/gui/src/dropdownCheckboxes.cpp

@@ -0,0 +1,109 @@
+// SPDX-License-Identifier: BSD-3-Clause
+// Copyright (c) 2021-2025, The OpenROAD Authors
+
+#include "dropdownCheckboxes.h"
+
+#include <qnamespace.h>
+
+namespace gui {
+
+DropdownCheckboxes::DropdownCheckboxes(const std::string& name,
+                                       const std::string& all_text,
+                                       QWidget* parent)
+    : QComboBox(parent),
+      name_item_(new QStandardItem(QString::fromStdString(name))),
+      all_item_(new QStandardItem(QString::fromStdString(all_text))),
+      model_(new QStandardItemModel(this)),
+      updating_check_boxes_(false)
+{
+  setup();
+}
+
+DropdownCheckboxes::DropdownCheckboxes(const QString& name,
+                                       const QString& all_text,
+                                       QWidget* parent)
+    : QComboBox(parent),
+      name_item_(new QStandardItem(name)),
+      all_item_(new QStandardItem(all_text)),
+      model_(new QStandardItemModel(this)),
+      updating_check_boxes_(false)
+{
+  setup();
+}
+
+void DropdownCheckboxes::setup()
+{
+  name_item_->setFlags(Qt::NoItemFlags);
+  all_item_->setFlags(Qt::ItemIsUserCheckable | Qt::ItemIsEnabled
+                      | Qt::ItemIsAutoTristate);
+  all_item_->setData(Qt::Checked, Qt::CheckStateRole);
+  model_->appendRow(name_item_);
+  model_->appendRow(all_item_);
+
+  setModel(model_);
+  setCurrentIndex(0);
+
+  connect(model_,
+          &QStandardItemModel::itemChanged,
+          this,
+          &DropdownCheckboxes::itemChanged);
+}
+
+void DropdownCheckboxes::clear()
+{
+  model_->removeRows(2, model_->rowCount() - 2);
+}
+
+void DropdownCheckboxes::itemChanged(QStandardItem* item)
+{
+  if (updating_check_boxes_) {
+    return;
+  }
+
+  updating_check_boxes_ = true;
+  if (item == all_item_) {  // set all check boxes to all_item_ state
+    Qt::CheckState state = all_item_->checkState();
+    if (state == Qt::PartiallyChecked) {
+      return;
+    }
+    for (auto row = 2; row < model_->rowCount(); row++) {
+      QStandardItem* item_iter = model_->item(row);
+      if (item_iter->checkState() != state) {
+        item_iter->setCheckState(state);
+      }
+    }
+  } else {  // updates all_item_ state
+    bool all_checked = true;
+    bool all_unchecked = true;
+    for (auto row = 2; row < model_->rowCount(); row++) {
+      QStandardItem* item_iter = model_->item(row);
+      if (item_iter->checkState() == Qt::Unchecked) {
+        all_checked = false;
+      } else {
+        all_unchecked = false;
+      }
+    }
+    if (all_checked) {
+      all_item_->setCheckState(Qt::Checked);
+    } else if (all_unchecked) {
+      all_item_->setCheckState(Qt::Unchecked);
+    } else {
+      all_item_->setCheckState(Qt::PartiallyChecked);
+    }
+  }
+  updating_check_boxes_ = false;
+}
+
+std::vector<QString> DropdownCheckboxes::selectedItems()
+{
+  std::vector<QString> selected;
+  for (auto row = 2; row < model_->rowCount(); row++) {
+    QStandardItem* item_iter = model_->item(row);
+    if (item_iter->checkState() == Qt::Checked) {
+      selected.push_back(item_iter->text());
+    }
+  }
+  return selected;
+}
+
+}  // namespace gui

src/gui/src/dropdownCheckboxes.h

@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: BSD-3-Clause
+// Copyright (c) 2021-2025, The OpenROAD Authors
+
+#pragma once
+
+#include <qchar.h>
+#include <qobjectdefs.h>
+
+#include <QComboBox>
+#include <QStandardItem>
+#include <QStandardItemModel>
+
+namespace sta {
+class dbSta;
+class Clock;
+}  // namespace sta
+
+namespace gui {
+class DropdownCheckboxes : public QComboBox
+{
+  Q_OBJECT
+ public:
+  DropdownCheckboxes(const std::string& name,
+                     const std::string& all_text = "All",
+                     QWidget* parent = nullptr);
+  DropdownCheckboxes(const QString& name,
+                     const QString& all_text = "All",
+                     QWidget* parent = nullptr);
+  void clear();
+
+  void setName(const std::string& name)
+  {
+    name_item_->setText(QString::fromStdString(name));
+  };
+  void setName(const QString& name) { name_item_->setText(name); };
+  QString getName() { return name_item_->text(); };
+  QStandardItem* getNameItem() { return name_item_; };
+
+  void setAllText(const std::string& text)
+  {
+    all_item_->setText(QString::fromStdString(text));
+  };
+  void setAllText(const QString& text) { all_item_->setText(text); };
+  QString getAllText() { return all_item_->text(); };
+  QStandardItem* getAllItem() { return all_item_; };
+
+  QStandardItemModel* model() { return model_; };
+  std::vector<QString> selectedItems();
+
+ public slots:
+  void itemChanged(QStandardItem* item);
+
+ private:
+  QStandardItem* name_item_;
+  QStandardItem* all_item_;
+  QStandardItemModel* model_;
+  bool updating_check_boxes_;
+
+  void setup();
+  void updateName();
+};
+
+}  // namespace gui

src/gui/src/staGui.cpp

@@ -3,6 +3,9 @@
 
 #include "staGui.h"
 
+#include <qchar.h>
+#include <qglobal.h>
+
 #include <QAbstractItemView>
 #include <QAction>
 #include <QApplication>
@@ -15,7 +18,6 @@
 #include <cstddef>
 #include <fstream>
 #include <functional>
-#include <iostream>
 #include <iterator>
 #include <limits>
 #include <map>
@@ -30,10 +32,12 @@
 #include "dbDescriptors.h"
 #include "db_sta/dbNetwork.hh"
 #include "db_sta/dbSta.hh"
+#include "gui/gui.h"
 #include "odb/db.h"
 #include "odb/dbObject.h"
 #include "odb/dbShape.h"
 #include "odb/geom.h"
+#include "sta/Clock.hh"
 #include "sta/Corner.hh"
 #include "sta/PatternMatch.hh"
 #include "sta/Units.hh"
@@ -266,26 +270,28 @@ void TimingPathsModel::populateModel(
     const std::set<const sta::Pin*>& from,
     const std::vector<std::set<const sta::Pin*>>& thru,
     const std::set<const sta::Pin*>& to,
-    const std::string& path_group_name)
+    const std::string& path_group_name,
+    sta::ClockSet* clks)
 {
   beginResetModel();
   timing_paths_.clear();
-  populatePaths(from, thru, to, path_group_name);
+  populatePaths(from, thru, to, path_group_name, clks);
   endResetModel();
 }
 
 bool TimingPathsModel::populatePaths(
     const std::set<const sta::Pin*>& from,
     const std::vector<std::set<const sta::Pin*>>& thru,
     const std::set<const sta::Pin*>& to,
-    const std::string& path_group_name)
+    const std::string& path_group_name,
+    sta::ClockSet* clks)
 {
   // On lines of DataBaseHandler
   QApplication::setOverrideCursor(Qt::WaitCursor);
 
   const bool sta_max = sta_->isUseMax();
   sta_->setUseMax(is_setup_);
-  timing_paths_ = sta_->getTimingPaths(from, thru, to, path_group_name);
+  timing_paths_ = sta_->getTimingPaths(from, thru, to, path_group_name, clks);
   sta_->setUseMax(sta_max);
 
   QApplication::restoreOverrideCursor();
@@ -1117,6 +1123,9 @@ TimingControlsDialog::TimingControlsDialog(QWidget* parent)
       layout_(new QFormLayout),
       path_count_spin_box_(new QSpinBox(this)),
       corner_box_(new QComboBox(this)),
+      clock_box_(new DropdownCheckboxes(QString("Select Clocks"),
+                                        QString("All Clocks"),
+                                        this)),
       unconstrained_(new QCheckBox(this)),
       one_path_per_endpoint_(new QCheckBox(this)),
       expand_clk_(new QCheckBox(this)),
@@ -1132,6 +1141,7 @@ TimingControlsDialog::TimingControlsDialog(QWidget* parent)
   layout_->addRow("Paths:", path_count_spin_box_);
   layout_->addRow("Expand clock:", expand_clk_);
   layout_->addRow("Corner:", corner_box_);
+  layout_->addRow("Clock filter:", clock_box_);
 
   setupPinRow("From:", from_);
   setThruPin({});
@@ -1250,6 +1260,20 @@ void TimingControlsDialog::populate()
   }
 
   corner_box_->setCurrentIndex(selection);
+
+  for (auto clk : *sta_->getClocks()) {
+    QString clk_name = clk->name();
+
+    if (qstring_to_clk_.count(clk_name) != 1) {
+      qstring_to_clk_[clk_name] = clk;
+      QStandardItem* item = new QStandardItem(clk_name);
+
+      item->setFlags(Qt::ItemIsUserCheckable | Qt::ItemIsEnabled);
+      item->setData(Qt::Checked, Qt::CheckStateRole);
+
+      clock_box_->model()->appendRow(item);
+    }
+  }
 }
 
 void TimingControlsDialog::setPinSelections()
@@ -1332,4 +1356,12 @@ std::vector<std::set<const sta::Pin*>> TimingControlsDialog::getThruPins() const
   }
   return pins;
 }
-}  // namespace gui
+
+void TimingControlsDialog::getClocks(sta::ClockSet* clock_set) const
+{
+  for (const auto& clk_name : clock_box_->selectedItems()) {
+    clock_set->insert(qstring_to_clk_[clk_name]);
+  }
+}
+
+}  // namespace gui

src/gui/src/staGui.h

@@ -3,13 +3,16 @@
 
 #pragma once
 
+#include <qchar.h>
+
 #include <QAbstractTableModel>
 #include <QCheckBox>
 #include <QColor>
 #include <QComboBox>
 #include <QDialog>
 #include <QFormLayout>
 #include <QHBoxLayout>
+#include <QHash>
 #include <QListWidget>
 #include <QSpinBox>
 #include <map>
@@ -19,6 +22,7 @@
 #include <string>
 #include <vector>
 
+#include "dropdownCheckboxes.h"
 #include "gui/gui.h"
 #include "odb/db.h"
 #include "odb/dbBlockCallBackObj.h"
@@ -30,6 +34,7 @@
 namespace sta {
 class dbSta;
 class Pin;
+class Clock;
 }  // namespace sta
 namespace gui {
 class TimingPathsModel;
@@ -92,7 +97,8 @@ class TimingPathsModel : public QAbstractTableModel
   void populateModel(const std::set<const sta::Pin*>& from,
                      const std::vector<std::set<const sta::Pin*>>& thru,
                      const std::set<const sta::Pin*>& to,
-                     const std::string& path_group_name);
+                     const std::string& path_group_name,
+                     sta::ClockSet* clks);
 
  public slots:
   void sort(int col_index, Qt::SortOrder sort_order) override;
@@ -101,7 +107,8 @@ class TimingPathsModel : public QAbstractTableModel
   bool populatePaths(const std::set<const sta::Pin*>& from,
                      const std::vector<std::set<const sta::Pin*>>& thru,
                      const std::set<const sta::Pin*>& to,
-                     const std::string& path_group_name);
+                     const std::string& path_group_name,
+                     sta::ClockSet* clks);
 
   STAGuiInterface* sta_;
   bool is_setup_;
@@ -399,6 +406,7 @@ class TimingControlsDialog : public QDialog
   std::set<const sta::Pin*> getFromPins() const { return from_->getPins(); }
   std::vector<std::set<const sta::Pin*>> getThruPins() const;
   std::set<const sta::Pin*> getToPins() const { return to_->getPins(); }
+  void getClocks(sta::ClockSet* clock_set) const;
 
   const sta::Pin* convertTerm(Gui::Term term) const;
 
@@ -422,6 +430,7 @@ class TimingControlsDialog : public QDialog
 
   QSpinBox* path_count_spin_box_;
   QComboBox* corner_box_;
+  DropdownCheckboxes* clock_box_;
 
   QCheckBox* unconstrained_;
   QCheckBox* one_path_per_endpoint_;
@@ -430,8 +439,9 @@ class TimingControlsDialog : public QDialog
   PinSetWidget* from_;
   std::vector<PinSetWidget*> thru_;
   PinSetWidget* to_;
+  QHash<QString, sta::Clock*> qstring_to_clk_;
 
-  static constexpr int kThruStartRow = 3;
+  static constexpr int kThruStartRow = 4;
 
   void setPinSelections();