GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r479:14a4a9cf453e

Merge pull request from SCIQLOP-Initialisation develop...

perrinel -

r479:14a4a9cf453e

parent child

Context file:

r479:14a4a9cf453e

gui/include/DataSource/DataSourceTreeWidgetHelper.h created 644 +23 0

@@ -0,0 +1,23
	1	#ifndef SCIQLOP_DATASOURCETREEWIDGETHELPER_H
	2	#define SCIQLOP_DATASOURCETREEWIDGETHELPER_H
	3
	4	#include <functional>
	5
	6	class DataSourceTreeWidgetItem;
	7	class QTreeWidget;
	8
	9	class DataSourceTreeWidgetHelper {
	10	public:
	11	/// Signature of the function associated to the filtering action
	12	using FilterFunction = std::function<bool(const DataSourceTreeWidgetItem &dataSourceItem)>;
	13
	14	/**
	15	* Filters a tree widget according to a function. If an item is valid according to this
	16	* function, all of its ancestors and children are shown
	17	* @param treeWidget the widget to filter
	18	* @param fun the filter function
	19	*/
	20	static void filter(QTreeWidget &treeWidget, FilterFunction fun) noexcept;
	21	};
	22
	23	#endif // SCIQLOP_DATASOURCETREEWIDGETHELPER_H

gui/src/DataSource/DataSourceTreeWidgetHelper.cpp created 644 +36 0

@@ -0,0 +1,36
	1	#include "DataSource/DataSourceTreeWidgetHelper.h"
	2	#include "DataSource/DataSourceTreeWidgetItem.h"
	3
	4	namespace {
	5
	6	bool filterTreeItem(DataSourceTreeWidgetItem &treeItem,
	7	DataSourceTreeWidgetHelper::FilterFunction fun, bool parentValid = false)
	8	{
	9	auto selfValid = parentValid \|\| fun(treeItem);
	10
	11	auto childValid = false;
	12	auto childCount = treeItem.childCount();
	13	for (auto i = 0; i < childCount; ++i) {
	14	if (auto childItem = dynamic_cast<DataSourceTreeWidgetItem *>(treeItem.child(i))) {
	15	childValid \|= filterTreeItem(*childItem, fun, selfValid);
	16	}
	17	}
	18
	19	auto valid = selfValid \|\| childValid;
	20
	21	treeItem.setHidden(!valid);
	22
	23	return valid;
	24	}
	25
	26	} // namespace
	27
	28	void DataSourceTreeWidgetHelper::filter(QTreeWidget &treeWidget, FilterFunction fun) noexcept
	29	{
	30	auto itemCount = treeWidget.topLevelItemCount();
	31	for (auto i = 0; i < itemCount; ++i) {
	32	if (auto item = dynamic_cast<DataSourceTreeWidgetItem *>(treeWidget.topLevelItem(i))) {
	33	filterTreeItem(*item, fun);
	34	}
	35	}
	36	}

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/include/DataSource/DataSourceWidget.h +3 0

             #ifndef SCIQLOP_DATASOURCEWIDGET_H
             #define SCIQLOP_DATASOURCEWIDGET_H
             #include <QWidget>
             namespace Ui {
             class DataSourceWidget;
             } // Ui
             class DataSourceItem;
             /**
              * @brief The DataSourceWidget handles the graphical representation (as a tree) of the data sources
              * attached to SciQlop.
              */
             class DataSourceWidget : public QWidget {
                 Q_OBJECT
             public:
                 explicit DataSourceWidget(QWidget *parent = 0);
                 virtual ~DataSourceWidget() noexcept;
             public slots:
                 /**
                  * Adds a data source. An item associated to the data source is created and then added to the
                  * representation tree
                  * @param dataSource the data source to add. The pointer has to be not null
                  */
                 void addDataSource(DataSourceItem *dataSource) noexcept;
             private:
                 Ui::DataSourceWidget *ui;
             private slots:
+                /// Slot called when the filtering text has changed
+                void filterChanged(const QString &text) noexcept;
                 /// Slot called when right clicking on an item in the tree (displays a menu)
                 void onTreeMenuRequested(const QPoint &pos) noexcept;
             };
             #endif // SCIQLOP_DATASOURCEWIDGET_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 +23 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));
                     }
                 }
             }

gui/ui/DataSource/DataSourceWidget.ui +3 -12

             <?xml version="1.0" encoding="UTF-8"?>
             <ui version="4.0">
              <class>DataSourceWidget</class>
              <widget class="QWidget" name="DataSourceWidget">
               <property name="geometry">
                <rect>
                 <x>0</x>
                 <y>0</y>
                 <width>400</width>
                 <height>300</height>
                </rect>
               </property>
               <property name="windowTitle">
                <string>Data sources</string>
               </property>
               <layout class="QGridLayout" name="gridLayout">
-               <property name="topMargin">
-                <number>0</number>
-               </property>
-               <property name="rightMargin">
-                <number>0</number>
-               </property>
-               <property name="bottomMargin">
-                <number>0</number>
-               </property>
-               <property name="spacing">
-                <number>0</number>
-               </property>
                <item row="0" column="0">
+                <widget class="QLineEdit" name="filterLineEdit"/>
+               </item>
+               <item row="1" column="0">
                 <widget class="QTreeWidget" name="treeWidget">
                  <column>
                   <property name="text">
                    <string notr="true">1</string>
                   </property>
                  </column>
                 </widget>
                </item>
               </layout>
              </widget>
              <resources/>
              <connections/>
             </ui>

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