Add filter options menu to QuickFilterView and ComboQuickFilterView (#2230)

src/common/Configuration.cpp

@@ -961,6 +961,39 @@ bool Configuration::getShowQuickFilter() const
     return s.value("showQuickFilter", true).toBool();
 }
 
+bool Configuration::getQuickFilterCaseSensitive() const
+{
+    return s.value("quickFilterCaseSensitive", false).toBool();
+}
+
+void Configuration::setQuickFilterCaseSensitive(bool caseSensitive)
+{
+    s.setValue("quickFilterCaseSensitive", caseSensitive);
+    emit quickFilterCaseSensitiveChanged(caseSensitive);
+}
+
+bool Configuration::getQuickFilterWholeWords() const
+{
+    return s.value("quickFilterWholeWords", false).toBool();
+}
+
+void Configuration::setQuickFilterWholeWords(bool wholeWords)
+{
+    s.setValue("quickFilterWholeWords", wholeWords);
+    emit quickFilterWholeWordsChanged(wholeWords);
+}
+
+bool Configuration::getQuickFilterRegex() const
+{
+    return s.value("quickFilterRegex", false).toBool();
+}
+
+void Configuration::setQuickFilterRegex(bool regex)
+{
+    s.setValue("quickFilterRegex", regex);
+    emit quickFilterRegexChanged(regex);
+}
+
 void Configuration::setItemCountVisible(bool visible)
 {
     s.setValue("itemCountVisible", visible);

src/common/Configuration.h

@@ -337,6 +337,15 @@ class CUTTER_EXPORT Configuration : public QObject
      */
     bool getShowQuickFilter() const;
 
+    bool getQuickFilterCaseSensitive() const;
+    void setQuickFilterCaseSensitive(bool caseSensitive);
+
+    bool getQuickFilterWholeWords() const;
+    void setQuickFilterWholeWords(bool wholeWords);
+
+    bool getQuickFilterRegex() const;
+    void setQuickFilterRegex(bool regex);
+
     /**
      * @brief Enable or disable the visibility of the item count label within the Quick Filter
      * @param visible Set to true to show the item count, false to hide it
@@ -411,6 +420,9 @@ public slots:
     void interfaceThemeChanged();
     void itemCountOptionsChanged();
     void quickFilterOptionsChanged();
+    void quickFilterCaseSensitiveChanged(bool caseSensitive);
+    void quickFilterWholeWordsChanged(bool wholeWords);
+    void quickFilterRegexChanged(bool regex);
     void functionsOptionsChanged();
 #ifdef CUTTER_ENABLE_KSYNTAXHIGHLIGHTING
     void kSyntaxHighlightingThemeChanged();

src/common/CutterSearchable.cpp

@@ -5,7 +5,9 @@
 
 #include <QAbstractScrollArea>
 #include <QObject>
+#include <QRegularExpression>
 #include <QScrollBar>
+#include <QSortFilterProxyModel>
 
 void CutterSearchableHelper::setupConnections(QWidget *parent, SearchBarWidget *searchBar)
 {

src/common/CutterSearchable.h

@@ -4,6 +4,7 @@
 #include "CutterCommon.h"
 
 class QString;
+class QSortFilterProxyModel;
 class SearchBarWidget;
 class QWidget;
 
@@ -81,6 +82,7 @@ void setupConnections(QWidget *parent, SearchBarWidget *bar);
  */
 void positionSearchBar(QWidget *parent, SearchBarWidget *searchBar, QWidget *searchArea,
                        int hPadding, int vPadding);
-};
+
+} // namespace CutterSearchableHelper
 
 #endif // CUTTERSEARCHABLE_H

src/common/Helpers.cpp

@@ -1,6 +1,7 @@
 #include "common/Helpers.h"
 
 #include "Configuration.h"
+#include "CutterSearchable.h"
 
 #include <QAbstractButton>
 #include <QAbstractItemView>
@@ -10,6 +11,8 @@
 #include <QFileInfo>
 #include <QMenu>
 #include <QPlainTextEdit>
+#include <QRegularExpression>
+#include <QSortFilterProxyModel>
 #include <QString>
 #include <QTextEdit>
 #include <QTreeWidget>
@@ -296,6 +299,48 @@ bool filterStringContains(const QString &string, const QSortFilterProxyModel *mo
 #endif
 }
 
+void applyFilter(QSortFilterProxyModel *proxyModel, const QString &filterText, int options)
+{
+    if (!proxyModel) {
+        return;
+    }
+
+    if (filterText.isEmpty()) {
+        proxyModel->setFilterFixedString(QString());
+        return;
+    }
+
+    QRegularExpression::PatternOptions patternOptions = QRegularExpression::NoPatternOption;
+    if (!(options & CaseSensitive)) {
+        patternOptions |= QRegularExpression::CaseInsensitiveOption;
+    }
+
+    if (options & RegExp) {
+        const QRegularExpression regExp(filterText, patternOptions);
+        if (regExp.isValid()) {
+#if QT_VERSION >= QT_VERSION_CHECK(5, 12, 0)
+            proxyModel->setFilterRegularExpression(regExp);
+#else
+            proxyModel->setFilterRegExp(regExp.pattern());
+#endif
+        }
+    } else if (options & WholeWords) {
+        const QString pattern = QString("\\b%1\\b").arg(QRegularExpression::escape(filterText));
+        const QRegularExpression regExp(pattern, patternOptions);
+        if (regExp.isValid()) {
+#if QT_VERSION >= QT_VERSION_CHECK(5, 12, 0)
+            proxyModel->setFilterRegularExpression(regExp);
+#else
+            proxyModel->setFilterRegExp(regExp.pattern());
+#endif
+        }
+    } else {
+        proxyModel->setFilterCaseSensitivity((options & CaseSensitive) ? Qt::CaseSensitive
+                                                                       : Qt::CaseInsensitive);
+        proxyModel->setFilterWildcard(filterText);
+    }
+}
+
 QPointF mouseEventPos(QMouseEvent *ev)
 {
 #if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)

src/common/Helpers.h

@@ -118,6 +118,15 @@ CUTTER_EXPORT void emitColumnChanged(QAbstractItemModel *model, int column);
 
 CUTTER_EXPORT bool filterStringContains(const QString &string, const QSortFilterProxyModel *model);
 
+/**
+ * @brief Applies filter options to a proxy model
+ * @param proxyModel The proxy model to filter
+ * @param filterText The text to filter by
+ * @param options Bitwise combination of SearchOption flags (CaseSensitive, WholeWords, RegExp)
+ */
+CUTTER_EXPORT void applyFilter(QSortFilterProxyModel *proxyModel, const QString &filterText,
+                               int options);
+
 #if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
 using ColorFloat = float;
 using KeyComb = QKeyCombination;

src/dialogs/TypesVariablesDialog.cpp

@@ -1,6 +1,7 @@
 #include "TypesVariablesDialog.h"
 
 #include "Cutter.h"
+#include "common/CutterSearchable.h"
 #include "ui_TypesVariablesDialog.h"
 
 QString toString(VariableScope scope)
@@ -168,9 +169,11 @@ TypesVariablesDialog::TypesVariablesDialog(QWidget *parent, const QString &typeN
 
     auto updateCount = [this]() { ui->quickFilterView->setItemCount(proxyModel->rowCount()); };
 
-    connect(ui->quickFilterView, &ComboQuickFilterView::filterTextChanged, proxyModel,
-            &TypesVariablesProxyModel::setFilterFixedString);
-    connect(ui->quickFilterView, &ComboQuickFilterView::filterTextChanged, this, updateCount);
+    connect(ui->quickFilterView, &ComboQuickFilterView::filterChanged, this,
+            [this](const QString &text, int options) {
+                qhelpers::applyFilter(proxyModel, text, options);
+            });
+    connect(ui->quickFilterView, &ComboQuickFilterView::filterChanged, this, updateCount);
 
     connect(scopeCombo, QOverload<int>::of(&QComboBox::currentIndexChanged), this,
             [this, scopeCombo, updateCount](int index) {

src/dialogs/XrefsDialog.cpp

@@ -52,10 +52,14 @@ XrefsDialog::XrefsDialog(MainWindow *parent, bool hideXrefFrom)
             &XrefsDialog::onToTreeWidgetItemSelectionChanged);
     connect(ui->fromTreeWidget->selectionModel(), &QItemSelectionModel::selectionChanged, this,
             &XrefsDialog::onFromTreeWidgetItemSelectionChanged);
-    connect(ui->fromQuickFilter, &QuickFilterView::filterTextChanged, &fromProxyModel,
-            &QSortFilterProxyModel::setFilterWildcard);
-    connect(ui->toQuickFilter, &QuickFilterView::filterTextChanged, &toProxyModel,
-            &QSortFilterProxyModel::setFilterWildcard);
+    connect(ui->fromQuickFilter, &QuickFilterView::filterChanged, this,
+            [this](const QString &text, int options) {
+                qhelpers::applyFilter(&fromProxyModel, text, options);
+            });
+    connect(ui->toQuickFilter, &QuickFilterView::filterChanged, this,
+            [this](const QString &text, int options) {
+                qhelpers::applyFilter(&toProxyModel, text, options);
+            });
 
     // SearchWidget shortcuts
 

src/dialogs/preferences/InterfaceOptionsWidget.cpp

@@ -62,6 +62,17 @@ void InterfaceOptionsWidget::setUpQuickFilter()
     connect(ui->quickFilterCheckBox, &QCheckBox::toggled, Config(),
             &Configuration::setShowQuickFilter);
 
+    ui->caseSensitiveCheckBox->setChecked(Config()->getQuickFilterCaseSensitive());
+    connect(ui->caseSensitiveCheckBox, &QCheckBox::toggled, Config(),
+            &Configuration::setQuickFilterCaseSensitive);
+
+    ui->wholeWordsCheckBox->setChecked(Config()->getQuickFilterWholeWords());
+    connect(ui->wholeWordsCheckBox, &QCheckBox::toggled, Config(),
+            &Configuration::setQuickFilterWholeWords);
+
+    ui->regexCheckBox->setChecked(Config()->getQuickFilterRegex());
+    connect(ui->regexCheckBox, &QCheckBox::toggled, Config(), &Configuration::setQuickFilterRegex);
+
     ui->itemCountCheckBox->setChecked(Config()->getItemCountVisible());
     connect(ui->itemCountCheckBox, &QCheckBox::toggled, this, [this](bool checked) {
         Config()->setItemCountVisible(checked);

src/dialogs/preferences/InterfaceOptionsWidget.ui

@@ -177,6 +177,27 @@
             </property>
            </widget>
           </item>
+          <item>
+           <widget class="QCheckBox" name="caseSensitiveCheckBox">
+            <property name="text">
+             <string>Use case sensitive by default</string>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QCheckBox" name="wholeWordsCheckBox">
+            <property name="text">
+             <string>Match whole words by default</string>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QCheckBox" name="regexCheckBox">
+            <property name="text">
+             <string>Use regex by default</string>
+            </property>
+           </widget>
+          </item>
           <item>
            <widget class="QCheckBox" name="itemCountCheckBox">
             <property name="text">

src/dialogs/preferences/RizinConfigOptionsWidget.cpp

@@ -512,7 +512,7 @@ RizinConfigOptionsWidget::RizinConfigOptionsWidget(PreferencesDialog *parent)
         }
     });
 
-    connect(ui->comboQuickFilter, &ComboQuickFilterView::filterTextChanged, this,
+    connect(ui->comboQuickFilter, &ComboQuickFilterView::filterChanged, this,
             [this](const QString &text) {
                 proxyModel->setFilterWildcard(text);
                 updateItemCount();

src/widgets/AbstractFilterView.cpp

@@ -1,17 +1,57 @@
 #include "AbstractFilterView.h"
 
+#include "common/CutterSearchable.h"
+#include "common/Helpers.h"
+#include "common/Configuration.h"
+
 #include <QAction>
+#include <QIcon>
 #include <QMenu>
 
 AbstractFilterView::AbstractFilterView(QWidget *parent) : QWidget(parent) {}
 
 void AbstractFilterView::setupSharedConnections()
 {
+    auto *optionsMenu = new QMenu(this);
+    caseSensitiveAction = optionsMenu->addAction(tr("&Case Sensitive"));
+    caseSensitiveAction->setCheckable(true);
+    caseSensitiveAction->setChecked(Config()->getQuickFilterCaseSensitive());
+
+    wholeWordsAction = optionsMenu->addAction(tr("&Exact Match"));
+    wholeWordsAction->setCheckable(true);
+    wholeWordsAction->setChecked(Config()->getQuickFilterWholeWords());
+
+    regexAction = optionsMenu->addAction(tr("&Regular Expression"));
+    regexAction->setCheckable(true);
+    regexAction->setChecked(Config()->getQuickFilterRegex());
+
+    auto emitFilterChanged = [this]() { emit filterChanged(lineEdit()->text(), filterOptions()); };
+
+    connect(caseSensitiveAction, &QAction::toggled, this, emitFilterChanged);
+    connect(Config(), &Configuration::quickFilterCaseSensitiveChanged, caseSensitiveAction, &QAction::setChecked);
+
+    connect(wholeWordsAction, &QAction::toggled, this, emitFilterChanged);
+    connect(Config(), &Configuration::quickFilterWholeWordsChanged, wholeWordsAction, &QAction::setChecked);
+
+    connect(regexAction, &QAction::toggled, this, emitFilterChanged);
+    connect(Config(), &Configuration::quickFilterRegexChanged, regexAction, &QAction::setChecked);
+
+    auto *optionsAction = new QAction(this);
+    const int lineEditHeight = lineEdit()->fontMetrics().height();
+    const int targetIconSize = qRound(lineEditHeight * 0.8);
+    const QIcon cogIcon(":/img/icons/cog_light.svg");
+    const qreal dpr = qhelpers::devicePixelRatio(this);
+    QPixmap pixmap = cogIcon.pixmap(qRound(targetIconSize * dpr), qRound(targetIconSize * dpr));
+    pixmap.setDevicePixelRatio(dpr);
+    optionsAction->setIcon(pixmap);
+    optionsAction->setMenu(optionsMenu);
+    lineEdit()->addAction(optionsAction, QLineEdit::LeadingPosition);
+
     debounceTimer = new QTimer(this);
     debounceTimer->setSingleShot(true);
 
     connect(debounceTimer, &QTimer::timeout, this,
-            [this]() { emit filterTextChanged(lineEdit()->text()); });
+            [this]() { emit filterChanged(lineEdit()->text(), filterOptions()); });
 
     connect(lineEdit(), &QLineEdit::textChanged, this, [this]() { debounceTimer->start(150); });
 }
@@ -44,6 +84,21 @@ void AbstractFilterView::closeFilter()
     emit filterClosed();
 }
 
+int AbstractFilterView::filterOptions() const
+{
+    int options = 0;
+    if (caseSensitiveAction->isChecked()) {
+        options |= SearchOption::CaseSensitive;
+    }
+    if (wholeWordsAction->isChecked()) {
+        options |= SearchOption::WholeWords;
+    }
+    if (regexAction->isChecked()) {
+        options |= SearchOption::RegExp;
+    }
+    return options;
+}
+
 void AbstractFilterView::showCustomContextMenu(const QPoint &pos)
 {
     const QWidget *child = this->childAt(pos);

src/widgets/AbstractFilterView.h

@@ -3,6 +3,8 @@
 
 #include "ItemCountLineEdit.h"
 
+#include <QAction>
+#include <QPoint>
 #include <QTimer>
 #include <QWidget>
 
@@ -15,17 +17,18 @@ class AbstractFilterView : public QWidget
     Q_OBJECT
 public:
     explicit AbstractFilterView(QWidget *parent = nullptr);
+    virtual ~AbstractFilterView() = default;
 
     virtual void setItemCount(int count);
     virtual void showItemCount(bool show);
 
     void showFilter();
-    void clearFilter();
+    virtual void clearFilter();
 
     virtual void closeFilter();
 
 signals:
-    void filterTextChanged(const QString &text);
+    void filterChanged(const QString &text, int options);
     void filterClosed();
 
 protected:
@@ -34,7 +37,13 @@ class AbstractFilterView : public QWidget
     void setupSharedConnections();
     void showCustomContextMenu(const QPoint &pos);
 
-    QTimer *debounceTimer;
+    int filterOptions() const;
+
+    QTimer *debounceTimer = nullptr;
+
+    QAction *caseSensitiveAction = nullptr;
+    QAction *wholeWordsAction = nullptr;
+    QAction *regexAction = nullptr;
 };
 
 #endif // ABSTRACTFILTERVIEW_H