HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r477:eab21078feec

Implements filter function for data source...

Alexandre Leroux -

r477:eab21078feec

parent child

Context file:

r477:eab21078feec

Collapse all files

gui/include/DataSource/DataSourceTreeWidgetItem.h +2 0

             #ifndef SCIQLOP_DATASOURCETREEWIDGETITEM_H
             #define SCIQLOP_DATASOURCETREEWIDGETITEM_H
             #include <Common/spimpl.h>
             #include <QLoggingCategory>
             #include <QTreeWidgetItem>
             Q_DECLARE_LOGGING_CATEGORY(LOG_DataSourceTreeWidgetItem)
             class DataSourceItem;
             /**
              * @brief The DataSourceTreeWidgetItem is the graphical representation of a data source item. It is
              * intended to be displayed in a QTreeWidget.
              * @sa DataSourceItem
              */
             class DataSourceTreeWidgetItem : public QTreeWidgetItem {
             public:
                 explicit DataSourceTreeWidgetItem(const DataSourceItem *data, int type = Type);
                 explicit DataSourceTreeWidgetItem(QTreeWidget *parent, const DataSourceItem *data,
                                                   int type = Type);
+                const DataSourceItem *data() const;
                 virtual QVariant data(int column, int role) const override;
                 virtual void setData(int column, int role, const QVariant &value) override;
                 /// @return the actions associated to the item
                 QList<QAction *> actions() const noexcept;
             private:
                 class DataSourceTreeWidgetItemPrivate;
                 spimpl::unique_impl_ptr<DataSourceTreeWidgetItemPrivate> impl;
             };
             #endif // SCIQLOP_DATASOURCETREEWIDGETITEM_H

gui/src/DataSource/DataSourceTreeWidgetItem.cpp +5 0

             #include <DataSource/DataSourceItem.h>
             #include <DataSource/DataSourceItemAction.h>
             #include <DataSource/DataSourceTreeWidgetItem.h>
             #include <QAction>
             Q_LOGGING_CATEGORY(LOG_DataSourceTreeWidgetItem, "DataSourceTreeWidgetItem")
             namespace {
             // Column indexes
             const auto NAME_COLUMN = 0;
             QIcon itemIcon(const DataSourceItem *dataSource)
             {
                 if (dataSource) {
                     auto dataSourceType = dataSource->type();
                     switch (dataSourceType) {
                         case DataSourceItemType::NODE: {
                             return dataSource->isRoot() ? QIcon{":/icones/dataSourceRoot.png"}
                                                         : QIcon{":/icones/dataSourceNode.png"};
                         }
                         case DataSourceItemType::PRODUCT:
                             return QIcon{":/icones/dataSourceProduct.png"};
                         case DataSourceItemType::COMPONENT:
                             return QIcon{":/icones/dataSourceComponent.png"};
                         default:
                             // No action
                             break;
                     }
                     qCWarning(LOG_DataSourceTreeWidgetItem())
                         << QObject::tr("Can't set data source icon : unknown data source type");
                 }
                 else {
                     qCCritical(LOG_DataSourceTreeWidgetItem())
                         << QObject::tr("Can't set data source icon : the data source is null");
                 }
                 // Default cases
                 return QIcon{};
             }
             /// @return the tooltip text for a variant. The text depends on whether the data is a simple variant
             /// or a list of variants
             QString tooltipValue(const QVariant &variant) noexcept
             {
                 // If the variant is a list of variants, the text of the tooltip is of the form: {val1, val2,
                 // ...}
                 if (variant.canConvert<QVariantList>()) {
                     auto valueString = QStringLiteral("{");
                     auto variantList = variant.value<QVariantList>();
                     for (auto it = variantList.cbegin(), end = variantList.cend(); it != end; ++it) {
                         valueString.append(it->toString());
                         if (std::distance(it, end) != 1) {
                             valueString.append(", ");
                         }
                     }
                     valueString.append(QStringLiteral("}"));
                     return valueString;
                 }
                 else {
                     return variant.toString();
                 }
             }
             QString itemTooltip(const DataSourceItem *dataSource) noexcept
             {
                 // The tooltip displays all item's data
                 if (dataSource) {
                     auto result = QString{};
                     const auto &data = dataSource->data();
                     for (auto it = data.cbegin(), end = data.cend(); it != end; ++it) {
                         result.append(QString{"<b>%1:</b> %2<br/>"}.arg(it.key(), tooltipValue(it.value())));
                     }
                     return result;
                 }
                 else {
                     qCCritical(LOG_DataSourceTreeWidgetItem())
                         << QObject::tr("Can't set data source tooltip : the data source is null");
                     return QString{};
                 }
             }
             } // namespace
             struct DataSourceTreeWidgetItem::DataSourceTreeWidgetItemPrivate {
                 explicit DataSourceTreeWidgetItemPrivate(const DataSourceItem *data) : m_Data{data} {}
                 /// Model used to retrieve data source information
                 const DataSourceItem *m_Data;
                 /// Actions associated to the item. The parent of the item (QTreeWidget) takes the ownership of
                 /// the actions
                 QList<QAction *> m_Actions;
             };
             DataSourceTreeWidgetItem::DataSourceTreeWidgetItem(const DataSourceItem *data, int type)
                     : DataSourceTreeWidgetItem{nullptr, data, type}
             {
             }
             DataSourceTreeWidgetItem::DataSourceTreeWidgetItem(QTreeWidget *parent, const DataSourceItem *data,
                                                                int type)
                     : QTreeWidgetItem{parent, type},
                       impl{spimpl::make_unique_impl<DataSourceTreeWidgetItemPrivate>(data)}
             {
                 // Sets the icon and the tooltip depending on the data source
                 setIcon(0, itemIcon(impl->m_Data));
                 setToolTip(0, itemTooltip(impl->m_Data));
                 // Generates tree actions based on the item actions
                 auto createTreeAction = [this, &parent](const auto &itemAction) {
                     auto treeAction = new QAction{itemAction->name(), parent};
                     // Executes item action when tree action is triggered
                     QObject::connect(treeAction, &QAction::triggered, itemAction,
                                      &DataSourceItemAction::execute);
                     return treeAction;
                 };
                 auto itemActions = impl->m_Data->actions();
                 std::transform(std::cbegin(itemActions), std::cend(itemActions),
                                std::back_inserter(impl->m_Actions), createTreeAction);
             }
+            const DataSourceItem *DataSourceTreeWidgetItem::data() const
+            {
+                return impl->m_Data;
+            }
             QVariant DataSourceTreeWidgetItem::data(int column, int role) const
             {
                 if (role == Qt::DisplayRole) {
                     if (impl->m_Data) {
                         switch (column) {
                             case NAME_COLUMN:
                                 return impl->m_Data->name();
                             default:
                                 // No action
                                 break;
                         }
                         qCWarning(LOG_DataSourceTreeWidgetItem())
                             << QObject::tr("Can't get data (unknown column %1)").arg(column);
                     }
                     else {
                         qCCritical(LOG_DataSourceTreeWidgetItem()) << QObject::tr("Can't get data (null item)");
                     }
                     return QVariant{};
                 }
                 else {
                     return QTreeWidgetItem::data(column, role);
                 }
             }
             void DataSourceTreeWidgetItem::setData(int column, int role, const QVariant &value)
             {
                 // Data can't be changed by edition
                 if (role != Qt::EditRole) {
                     QTreeWidgetItem::setData(column, role, value);
                 }
             }
             QList<QAction *> DataSourceTreeWidgetItem::actions() const noexcept
             {
                 return impl->m_Actions;
             }

gui/src/DataSource/DataSourceWidget.cpp +16 0

             #include <DataSource/DataSourceWidget.h>
             #include <ui_DataSourceWidget.h>
             #include <DataSource/DataSourceItem.h>
+            #include <DataSource/DataSourceTreeWidgetHelper.h>
             #include <DataSource/DataSourceTreeWidgetItem.h>
             #include <QMenu>
             namespace {
             /// Number of columns displayed in the tree
             const auto TREE_NB_COLUMNS = 1;
             /// Header labels for the tree
             const auto TREE_HEADER_LABELS = QStringList{QObject::tr("Name")};
             /**
              * Creates the item associated to a data source
              * @param dataSource the data source for which to create the item
              * @return the new item
              */
             DataSourceTreeWidgetItem *createTreeWidgetItem(DataSourceItem *dataSource)
             {
                 // Creates item for the data source
                 auto item = new DataSourceTreeWidgetItem{dataSource};
                 // Generates items for the children of the data source
                 for (auto i = 0; i < dataSource->childCount(); ++i) {
                     item->addChild(createTreeWidgetItem(dataSource->child(i)));
                 }
                 return item;
             }
             } // namespace
             DataSourceWidget::DataSourceWidget(QWidget *parent) : QWidget{parent}, ui{new Ui::DataSourceWidget}
             {
                 ui->setupUi(this);
                 // Set tree properties
                 ui->treeWidget->setColumnCount(TREE_NB_COLUMNS);
                 ui->treeWidget->setHeaderLabels(TREE_HEADER_LABELS);
                 ui->treeWidget->setContextMenuPolicy(Qt::CustomContextMenu);
                 // Connection to show a menu when right clicking on the tree
                 connect(ui->treeWidget, &QTreeWidget::customContextMenuRequested, this,
                         &DataSourceWidget::onTreeMenuRequested);
                 // Connection to filter tree
                 connect(ui->filterLineEdit, &QLineEdit::textChanged, this, &DataSourceWidget::filterChanged);
             }
             DataSourceWidget::~DataSourceWidget() noexcept
             {
                 delete ui;
             }
             void DataSourceWidget::addDataSource(DataSourceItem *dataSource) noexcept
             {
                 // Creates the item associated to the source and adds it to the tree widget. The tree widget
                 // takes the ownership of the item
                 if (dataSource) {
                     ui->treeWidget->addTopLevelItem(createTreeWidgetItem(dataSource));
                 }
             }
             void DataSourceWidget::filterChanged(const QString &text) noexcept
             {
+                auto validateItem = [&text](const DataSourceTreeWidgetItem &item) {
+                    auto regExp = QRegExp{text, Qt::CaseInsensitive, QRegExp::Wildcard};
+                    // An item is valid if any of its metadata validates the text filter
+                    auto itemMetadata = item.data()->data();
+                    auto itemMetadataEnd = itemMetadata.cend();
+                    auto acceptFilter
+                        = [&regExp](const auto &variant) { return variant.toString().contains(regExp); };
+                    return std::find_if(itemMetadata.cbegin(), itemMetadataEnd, acceptFilter)
+                           != itemMetadataEnd;
+                };
+                // Applies filter on tree widget
+                DataSourceTreeWidgetHelper::filter(*ui->treeWidget, validateItem);
             }
             void DataSourceWidget::onTreeMenuRequested(const QPoint &pos) noexcept
             {
                 // Retrieves the selected item in the tree, and build the menu from its actions
                 if (auto selectedItem = dynamic_cast<DataSourceTreeWidgetItem *>(ui->treeWidget->itemAt(pos))) {
                     QMenu treeMenu{};
                     treeMenu.addActions(selectedItem->actions());
                     if (!treeMenu.isEmpty()) {
                         treeMenu.exec(mapToGlobal(pos));
                     }
                 }
             }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages