File indexing completed on 2024-04-28 15:51:45

 /*
     SPDX-FileCopyrightText: 2003 Scott Wheeler <wheeler@kde.org>
     SPDX-FileCopyrightText: 2005 Rafal Rzepecki <divide@users.sourceforge.net>
     SPDX-FileCopyrightText: 2006 Hamish Rodda <rodda@kde.org>
     SPDX-FileCopyrightText: 2007 Pino Toscano <pino@kde.org>
 
     SPDX-License-Identifier: LGPL-2.0-only
 */
 
 #include "ktreeviewsearchline.h"
 
 #include <QApplication>
 #include <QContextMenuEvent>
 #include <QHBoxLayout>
 #include <QHeaderView>
 #include <QLabel>
 #include <QList>
 #include <QMenu>
 #include <QRegularExpression>
 #include <QTimer>
 #include <QToolButton>
 #include <QTreeView>
 
 #include <KLocalizedString>
 #include <KToolBar>
 #include <QDebug>
 
 class KTreeViewSearchLine::Private
 {
 public:
     explicit Private(KTreeViewSearchLine *_parent)
         : parent(_parent)
         , treeView(nullptr)
         , caseSensitive(Qt::CaseInsensitive)
         , regularExpression(false)
         , activeSearch(false)
         , queuedSearches(0)
     {
     }
 
     KTreeViewSearchLine *parent;
     QTreeView *treeView;
     Qt::CaseSensitivity caseSensitive;
     bool regularExpression;
     bool activeSearch;
     QString search;
     int queuedSearches;
 
     void rowsInserted(const QModelIndex &parent, int start, int end) const;
     void treeViewDeleted(QObject *object);
     void slotCaseSensitive();
     void slotRegularExpression();
 
     void checkItemParentsNotVisible(QTreeView *treeView);
     bool filterItems(QTreeView *treeView, const QModelIndex &index);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // private slots
 ////////////////////////////////////////////////////////////////////////////////
 
 void KTreeViewSearchLine::Private::rowsInserted(const QModelIndex &parentIndex, int start, int end) const
 {
     QAbstractItemModel *model = qobject_cast<QAbstractItemModel *>(parent->sender());
     if (!model) {
         return;
     }
 
     QTreeView *widget = nullptr;
     if (treeView->model() == model) {
         widget = treeView;
     }
 
     if (!widget) {
         return;
     }
 
     for (int i = start; i <= end; ++i) {
         widget->setRowHidden(i, parentIndex, !parent->itemMatches(parentIndex, i, parent->text()));
     }
 }
 
 void KTreeViewSearchLine::Private::treeViewDeleted(QObject *object)
 {
     if (object == treeView) {
         treeView = nullptr;
         parent->setEnabled(false);
     }
 }
 
 void KTreeViewSearchLine::Private::slotCaseSensitive()
 {
     if (caseSensitive == Qt::CaseSensitive) {
         parent->setCaseSensitivity(Qt::CaseInsensitive);
     } else {
         parent->setCaseSensitivity(Qt::CaseSensitive);
     }
 
     parent->updateSearch();
 }
 
 void KTreeViewSearchLine::Private::slotRegularExpression()
 {
     if (regularExpression) {
         parent->setRegularExpression(false);
     } else {
         parent->setRegularExpression(true);
     }
 
     parent->updateSearch();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // private methods
 ////////////////////////////////////////////////////////////////////////////////
 
 /** Check whether \p item, its siblings and their descendants should be shown. Show or hide the items as necessary.
  *
  *  \p item  The list view item to start showing / hiding items at. Typically, this is the first child of another item, or the
  *              the first child of the list view.
  *  \return \c true if an item which should be visible is found, \c false if all items found should be hidden. If this function
  *             returns true and \p highestHiddenParent was not 0, highestHiddenParent will have been shown.
  */
 bool KTreeViewSearchLine::Private::filterItems(QTreeView *treeView, const QModelIndex &index)
 {
     bool childMatch = false;
     const int rowcount = treeView->model()->rowCount(index);
     for (int i = 0; i < rowcount; ++i) {
         childMatch |= filterItems(treeView, treeView->model()->index(i, 0, index));
     }
 
     // Should this item be shown? It should if any children should be, or if it matches.
     const QModelIndex parentindex = index.parent();
     if (childMatch || parent->itemMatches(parentindex, index.row(), search)) {
         treeView->setRowHidden(index.row(), parentindex, false);
         return true;
     }
 
     treeView->setRowHidden(index.row(), parentindex, true);
 
     return false;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // public methods
 ////////////////////////////////////////////////////////////////////////////////
 
 KTreeViewSearchLine::KTreeViewSearchLine(QWidget *parent, QTreeView *treeView)
     : KLineEdit(parent)
     , d(new Private(this))
 {
     connect(this, &KTreeViewSearchLine::textChanged, this, &KTreeViewSearchLine::queueSearch);
 
     setClearButtonEnabled(true);
     setTreeView(treeView);
 
     if (!treeView) {
         setEnabled(false);
     }
 }
 
 KTreeViewSearchLine::~KTreeViewSearchLine()
 {
     delete d;
 }
 
 Qt::CaseSensitivity KTreeViewSearchLine::caseSensitivity() const
 {
     return d->caseSensitive;
 }
 
 bool KTreeViewSearchLine::regularExpression() const
 {
     return d->regularExpression;
 }
 
 QTreeView *KTreeViewSearchLine::treeView() const
 {
     return d->treeView;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // public slots
 ////////////////////////////////////////////////////////////////////////////////
 
 void KTreeViewSearchLine::updateSearch(const QString &pattern)
 {
     d->search = pattern.isNull() ? text() : pattern;
 
     updateSearch(d->treeView);
 }
 
 void KTreeViewSearchLine::updateSearch(QTreeView *treeView)
 {
     if (!treeView || !treeView->model()->rowCount()) {
         return;
     }
 
     // If there's a selected item that is visible, make sure that it's visible
     // when the search changes too (assuming that it still matches).
 
     QModelIndex currentIndex = treeView->currentIndex();
 
     bool wasUpdateEnabled = treeView->updatesEnabled();
     treeView->setUpdatesEnabled(false);
     d->filterItems(treeView, treeView->rootIndex());
     treeView->setUpdatesEnabled(wasUpdateEnabled);
 
     if (currentIndex.isValid()) {
         treeView->scrollTo(currentIndex);
     }
 }
 
 void KTreeViewSearchLine::setCaseSensitivity(Qt::CaseSensitivity caseSensitivity)
 {
     if (d->caseSensitive != caseSensitivity) {
         d->caseSensitive = caseSensitivity;
         updateSearch();
         Q_EMIT searchOptionsChanged();
     }
 }
 
 void KTreeViewSearchLine::setRegularExpression(bool value)
 {
     if (d->regularExpression != value) {
         d->regularExpression = value;
         updateSearch();
         Q_EMIT searchOptionsChanged();
     }
 }
 
 void KTreeViewSearchLine::setTreeView(QTreeView *treeView)
 {
     disconnectTreeView(d->treeView);
     d->treeView = treeView;
     connectTreeView(treeView);
 
     setEnabled(treeView != nullptr);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // protected members
 ////////////////////////////////////////////////////////////////////////////////
 
 bool KTreeViewSearchLine::itemMatches(const QModelIndex &parentIndex, int row, const QString &pattern) const
 {
     if (pattern.isEmpty()) {
         return true;
     }
 
     if (!parentIndex.isValid() && parentIndex != d->treeView->rootIndex()) {
         return false;
     }
 
     // Construct a regular expression object with the right options.
     QRegularExpression re;
     if (d->regularExpression) {
         re.setPattern(pattern);
         re.setPatternOptions(d->caseSensitive ? QRegularExpression::NoPatternOption : QRegularExpression::CaseInsensitiveOption);
     }
 
     // If the search column list is populated, search just the columns
     // specified.  If it is empty default to searching all of the columns.
     QAbstractItemModel *model = d->treeView->model();
     const int columncount = model->columnCount(parentIndex);
     for (int i = 0; i < columncount; ++i) {
         const QString str = model->data(model->index(row, i, parentIndex), Qt::DisplayRole).toString();
         if (d->regularExpression) {
             return str.contains(re);
         } else {
             return str.contains(pattern, d->caseSensitive ? Qt::CaseSensitive : Qt::CaseInsensitive);
         }
     }
 
     return false;
 }
 
 void KTreeViewSearchLine::contextMenuEvent(QContextMenuEvent *event)
 {
     QMenu *popup = KLineEdit::createStandardContextMenu();
 
     popup->addSeparator();
     QMenu *optionsSubMenu = popup->addMenu(i18n("Search Options"));
     QAction *caseSensitiveAction = optionsSubMenu->addAction(i18nc("Enable case sensitive search in the side navigation panels", "Case Sensitive"), this, [this] { d->slotCaseSensitive(); });
     caseSensitiveAction->setCheckable(true);
     caseSensitiveAction->setChecked(d->caseSensitive);
     QAction *regularExpressionAction = optionsSubMenu->addAction(i18nc("Enable regular expression search in the side navigation panels", "Regular Expression"), this, [this] { d->slotRegularExpression(); });
     regularExpressionAction->setCheckable(true);
     regularExpressionAction->setChecked(d->regularExpression);
 
     popup->exec(event->globalPos());
     delete popup;
 }
 
 void KTreeViewSearchLine::connectTreeView(QTreeView *treeView)
 {
     if (treeView) {
         connect(treeView, &QTreeView::destroyed, this, &KTreeViewSearchLine::treeViewDeleted);
 
         connect(treeView->model(), &QAbstractItemModel::rowsInserted, this, &KTreeViewSearchLine::rowsInserted);
     }
 }
 
 void KTreeViewSearchLine::disconnectTreeView(QTreeView *treeView)
 {
     if (treeView) {
         disconnect(treeView, &QTreeView::destroyed, this, &KTreeViewSearchLine::treeViewDeleted);
 
         disconnect(treeView->model(), &QAbstractItemModel::rowsInserted, this, &KTreeViewSearchLine::rowsInserted);
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // protected slots
 ////////////////////////////////////////////////////////////////////////////////
 
 void KTreeViewSearchLine::queueSearch(const QString &search)
 {
     d->queuedSearches++;
     d->search = search;
 
     QTimer::singleShot(200, this, &KTreeViewSearchLine::activateSearch);
 }
 
 void KTreeViewSearchLine::activateSearch()
 {
     --(d->queuedSearches);
 
     if (d->queuedSearches == 0) {
         updateSearch(d->search);
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // private functions
 ////////////////////////////////////////////////////////////////////////////////
 
 void KTreeViewSearchLine::rowsInserted(const QModelIndex &parent, int start, int end) const
 {
     d->rowsInserted(parent, start, end);
 }
 
 void KTreeViewSearchLine::treeViewDeleted(QObject *treeView)
 {
     d->treeViewDeleted(treeView);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // KTreeViewSearchLineWidget
 ////////////////////////////////////////////////////////////////////////////////
 
 class KTreeViewSearchLineWidget::Private
 {
 public:
     Private()
         : treeView(nullptr)
         , searchLine(nullptr)
     {
     }
 
     QTreeView *treeView;
     KTreeViewSearchLine *searchLine;
 };
 
 KTreeViewSearchLineWidget::KTreeViewSearchLineWidget(QWidget *parent, QTreeView *treeView)
     : QWidget(parent)
     , d(new Private)
 {
     d->treeView = treeView;
 
     QTimer::singleShot(0, this, &KTreeViewSearchLineWidget::createWidgets);
 }
 
 KTreeViewSearchLineWidget::~KTreeViewSearchLineWidget()
 {
     delete d;
 }
 
 KTreeViewSearchLine *KTreeViewSearchLineWidget::createSearchLine(QTreeView *treeView) const
 {
     return new KTreeViewSearchLine(const_cast<KTreeViewSearchLineWidget *>(this), treeView);
 }
 
 void KTreeViewSearchLineWidget::createWidgets()
 {
     QLabel *label = new QLabel(i18n("S&earch:"), this);
     label->setObjectName(QStringLiteral("kde toolbar widget"));
 
     searchLine()->show();
 
     label->setBuddy(d->searchLine);
     label->show();
 
     QHBoxLayout *layout = new QHBoxLayout(this);
     layout->setSpacing(5);
     layout->setContentsMargins(0, 0, 0, 0);
     layout->addWidget(label);
     layout->addWidget(d->searchLine);
 }
 
 KTreeViewSearchLine *KTreeViewSearchLineWidget::searchLine() const
 {
     if (!d->searchLine) {
         d->searchLine = createSearchLine(d->treeView);
     }
 
     return d->searchLine;
 }
 
 #include "moc_ktreeviewsearchline.cpp"