search_text_widget.h

Go to the documentation of this file.

 
/*
 * This file depends on Qt which is licensed under LGPLv3.
 * See ADTF_DIR/3rdparty/qt5 and doc/license for detailed information.
 */
 
#pragma once
 
#include <adtf_utils.h>
 
#include <QActionGroup>
#include <QLabel>
#include <QLineEdit>
#include <QMetaType>
#include <QObject>
#include <QPushButton>
#include <QSortFilterProxyModel>
#include <QSpinBox>
#include <QStandardItemModel>
#include <QString>
#include <QThreadPool>
#include <QHash>
#include <QSet>
#include <QStringListModel>
#include <QCompleter>
#include <QEvent>
#include <adtfui/themed_icon.h>
 
#include <optional>
 
namespace std
{
Q_DECL_CONST_FUNCTION Q_DECL_CONSTEXPR inline uint qHash(const ::std::tuple<quintptr, int>& i, uint seed = 0) noexcept
{
    return ::qHash(std::get<0>(i), seed) + ::qHash(std::get<1>(i), seed);
}
} // namespace std
 
namespace adtf
{
namespace ui
{
namespace widget
{
namespace detail
{
enum class FilterType
{
    normal,
    wildcard,
    regex,
    fuzzy
};
 
class cSearchTextWidget;
 
// cFilterModel
class IFilterModel : public QSortFilterProxyModel
{
    Q_OBJECT
 
public:
    using QSortFilterProxyModel::QSortFilterProxyModel;
    virtual void SetFilterColumn(int64_t nFilterColumn) = 0;
    virtual void ClearMatchingData() = 0;
    virtual void SetMatchingTexts(QSet<QString> oMatchingTexts) = 0;
 
protected:
    virtual void ClearMappingCache() = 0;
};
 
template<template<class, class> class MAP = QHash, template<class> class SET = QSet>
class filter_model final : public IFilterModel
{
public:
    filter_model(QObject* parent = nullptr): IFilterModel(parent)
    {
        setDynamicSortFilter(false);
    }
 
    QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const override
    {
        if (role == Qt::DecorationRole)
        {
            if (section == m_nFilterColumn)
            {
                static const auto oFilterIcon = create_themed_icon(":/Filter.svg");
                return oFilterIcon;
            }
        }
        return QSortFilterProxyModel::headerData(section, orientation, role);
    }
    void setSourceModel(QAbstractItemModel* pNewSourceModel) override
    {
        filter_model::ClearMappingCache();
        const auto pOldSourceModel = sourceModel();
        if (pOldSourceModel)
        {
            disconnect(pOldSourceModel, &QAbstractItemModel::rowsAboutToBeInserted, this,
                       &filter_model::ClearMappingCache);
            disconnect(pOldSourceModel, &QAbstractItemModel::rowsAboutToBeMoved, this,
                       &filter_model::ClearMappingCache);
            disconnect(pOldSourceModel, &QAbstractItemModel::rowsAboutToBeRemoved, this,
                       &filter_model::ClearMappingCache);
            disconnect(pOldSourceModel, &QAbstractItemModel::columnsAboutToBeInserted, this,
                       &filter_model::ClearMappingCache);
            disconnect(pOldSourceModel, &QAbstractItemModel::columnsAboutToBeMoved, this,
                       &filter_model::ClearMappingCache);
            disconnect(pOldSourceModel, &QAbstractItemModel::columnsAboutToBeRemoved, this,
                       &filter_model::ClearMappingCache);
            disconnect(pOldSourceModel, &QAbstractItemModel::modelAboutToBeReset, this,
                       &filter_model::ClearMappingCache);
        }
        if (pNewSourceModel)
        {
            connect(pNewSourceModel, &QAbstractItemModel::rowsAboutToBeInserted, this,
                    &filter_model::ClearMappingCache);
            connect(pNewSourceModel, &QAbstractItemModel::rowsAboutToBeMoved, this, &filter_model::ClearMappingCache);
            connect(pNewSourceModel, &QAbstractItemModel::rowsAboutToBeRemoved, this, &filter_model::ClearMappingCache);
            connect(pNewSourceModel, &QAbstractItemModel::columnsAboutToBeInserted, this,
                    &filter_model::ClearMappingCache);
            connect(pNewSourceModel, &QAbstractItemModel::columnsAboutToBeMoved, this,
                    &filter_model::ClearMappingCache);
            connect(pNewSourceModel, &QAbstractItemModel::columnsAboutToBeRemoved, this,
                    &filter_model::ClearMappingCache);
            connect(pNewSourceModel, &QAbstractItemModel::modelAboutToBeReset, this, &filter_model::ClearMappingCache);
        }
 
        QSortFilterProxyModel::setSourceModel(pNewSourceModel);
    }
 
    void SetFilterColumn(int64_t nFilterColumn) override
    {
        m_nFilterColumn = nFilterColumn;
        ClearMatchingData();
        emit headerDataChanged(Qt::Horizontal, 0, columnCount() - 1);
    }
    void ClearMatchingData() override
    {
        if (m_setMatchingTexts)
        {
            m_setMatchingTexts.reset();
            ClearMappingCache();
            invalidate();
        }
    }
    void SetMatchingTexts(QSet<QString> oMatchingTexts) override
    {
        m_setMatchingTexts = SET<QString>{oMatchingTexts.cbegin(), oMatchingTexts.cend()};
        ClearMappingCache();
        invalidate();
    }
 
protected:
    bool filterAcceptsRow(int source_row, const QModelIndex& source_parent) const override
    {
        if (!m_setMatchingTexts || m_nFilterColumn < 0)
        {
            return true;
        }
 
        return filterAcceptsRowInternal(sourceModel(), source_row, source_parent);
    }
 
private:
    bool filterAcceptsRowInternal(const QAbstractItemModel* pSourceModel,
                                  int source_row,
                                  const QModelIndex& source_parent) const
    {
        // Build a custom index that avoids model queries for early rejection.
        const auto oHashKey = std::tuple{source_parent.internalId(), source_row};
 
        if (const auto it = static_cast<const decltype(m_oAcceptedItems)&>(m_oAcceptedItems).find(oHashKey);
            it != m_oAcceptedItems.cend())
        {
            // Cached success is always a success.
            // Cached failure can still skip any further backtracking.
 
            // Some minor difference between Qt and STL alike containers...
            if constexpr (std::is_same_v<MAP<std::tuple<quintptr, int>, bool>, QHash<std::tuple<quintptr, int>, bool>>)
            {
                return it.value();
            }
            else
            {
                return it->second;
            }
        }
 
        bool result = false;
 
        // Accept all children of accepted items. (if source_parent is not already root)
        if (source_parent.isValid())
        {
            auto oGrandParent = pSourceModel->parent(source_parent);
            if (filterAcceptsRowInternal(pSourceModel, source_parent.row(), oGrandParent))
            {
                // This will inevitably also apply to any future child node.
                result = true;
            }
        }
 
        const auto oRowIndex = pSourceModel->index(source_row, 0, source_parent);
        if (!result)
        {
            const auto oElementIndex =
                m_nFilterColumn != 0 ? pSourceModel->sibling(source_row, m_nFilterColumn, oRowIndex) : oRowIndex;
            // When backtracking and there wasn't a match / cached result, start string comparison.
            if ((*m_setMatchingTexts).contains(pSourceModel->data(oElementIndex).toString()))
            {
                result = true;
            }
        }
 
        if (!pSourceModel->flags(oRowIndex).testFlag(Qt::ItemNeverHasChildren))
        {
            // Cache both successes and failures. Don't bother with leaf nodes though, they will be queried only
            // once.
            if constexpr (std::is_same_v<MAP<std::tuple<quintptr, int>, bool>, QHash<std::tuple<quintptr, int>, bool>>)
            {
                m_oAcceptedItems.insert(oHashKey, result);
            }
            else
            {
                m_oAcceptedItems.emplace(oHashKey, result);
            }
        }
        return result;
    }
 
    void ClearMappingCache() override
    {
        m_oAcceptedItems.clear();
    }
 
    int64_t m_nFilterColumn = -1;
 
    std::optional<SET<QString>> m_setMatchingTexts;
 
    // Mapping of NON-PERSISTENT source indices to cached acceptance state.
    // Only valid until next structural change to source model.
    mutable MAP<std::tuple<quintptr, int>, bool> m_oAcceptedItems;
};

class cSearchTextWidget : public QFrame
{
    Q_OBJECT
 
signals:
    void selectedFilterColumnChanged();
    void searchParametersChanged();
 
public:
    cSearchTextWidget(QWidget* pParent = nullptr);
    ~cSearchTextWidget();
 
public:
    void SetFilterModel(IFilterModel& oFilterModel);

    uint64_t GetSelectedFilterColumn() const;
    void SetFilterColumnNames(const std::vector<QString>& vecFilterColumnNames);
    void SetFilterColumnNamesFromModel(const QAbstractItemModel& oModel);

    void SetSearchText(const QString& strSearchText);
    void Clear();

    FilterType GetSelectedFilterType() const;
    void SelectFilterType(FilterType oFilterType);

    bool IsCaseSensitive() const;
    void SetCaseSensitive(bool bCaseSensitive);
 
private:
    void UpdateUi();
 
    void HandleChangedSearchParameters();
 
    void SetCachedText(QSet<QString> oCachedText, bool reset = false, bool schedule = true);
 
    void SearchNormalString();
    void SearchWildcard();
    void SearchRegexString();
    void SearchFuzzy();
 
    void SetMatchingTexts(QSet<QString> oMatchingTexts);
 
    QSet<QString> ComputeItemTexts(const QModelIndex& oModelIndex, const uint64_t nFilterColumn);
    void ComputeTreeModelIndexs(const QModelIndex& oModelIndex,
                                const uint64_t nFilterColumn,
                                const std::function<void(const QModelIndex& oIndex)>& fnCallback);
 
protected:
    bool eventFilter(QObject* obj, QEvent* event) override;
 
private:
    IFilterModel* m_pFilterModel = nullptr;
    QAbstractItemModel* m_pSourceModel = nullptr;
 
    QLineEdit* m_pSearchTextLineEdit = nullptr;
    QLabel* m_pErrorLabel = nullptr;
    QToolButton* m_pClearButton = nullptr;
    QMenu* m_pFilterMenu = nullptr;
    QActionGroup* m_pFilterActionGroup = nullptr;
    QAction* m_pFuzzyFilterAction = nullptr;
    QAction* m_pCaseSensitiveAction = nullptr;
    QPushButton* m_pFilterButton = nullptr;
    QMenu* m_pFilterColumnMenu = nullptr;
    QActionGroup* m_pFilterColumnActionGroup = nullptr;
    QWidget* m_pFuzzyParametersWidget = nullptr;
    QSpinBox* m_pFuzzyScaledScoreThresholdSpinBox = nullptr;
    QStringListModel* m_pAutoCompletionModel = nullptr;
    QCompleter* m_pAutoCompleter = nullptr;
    QTimer* m_pPendingSearch = nullptr;
 
    bool m_bIsInInitialization = false;
 
    struct cSearchIndexState
    {
        uint64_t nSelectedFilterColumn = std::numeric_limits<uint64_t>::max();
        QSet<QString> setItemTextCache;
        std::optional<QSet<QString>> setMatchingItemText;
    };
    cSearchIndexState m_oSearchIndex;
 
    QThreadPool m_oSearchThreadPool;
    std::atomic<bool> m_bSearchCanceled = false;
};
 
} // namespace detail
 
} // namespace widget
} // namespace ui
} // namespace adtf
Q_DECLARE_METATYPE(adtf::ui::widget::detail::FilterType)