HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r362:7becb422304c

Merge branch 'feature/DataSourceItemUpdate' into develop

Alexandre Leroux -

r362:7becb422304c

parent child

Context file:

r362:7becb422304c

Collapse all files

gui/resources/icones/dataSourceComponent.png created 644 binary 0 0

	1	NO CONTENT: new file 100644, binary diff hidden			NO CONTENT: new file 100644, binary diff hidden

NO CONTENT: new file 100644, binary diff hidden

gui/resources/icones/dataSourceNode.png created 644 binary 0 0

	1	NO CONTENT: new file 100644, binary diff hidden			NO CONTENT: new file 100644, binary diff hidden

NO CONTENT: new file 100644, binary diff hidden

gui/resources/icones/dataSourceProduct.png created 644 binary 0 0

	1	NO CONTENT: new file 100644, binary diff hidden			NO CONTENT: new file 100644, binary diff hidden

NO CONTENT: new file 100644, binary diff hidden

gui/resources/icones/dataSourceRoot.png created 644 binary 0 0

	1	NO CONTENT: new file 100644, binary diff hidden			NO CONTENT: new file 100644, binary diff hidden

NO CONTENT: new file 100644, binary diff hidden

core/include/DataSource/DataSourceItem.h +27 -6

             #ifndef SCIQLOP_DATASOURCEITEM_H
             #define SCIQLOP_DATASOURCEITEM_H
             #include <Common/spimpl.h>
             #include <QVariant>
             #include <QVector>
             class DataSourceItemAction;
             /**
              * Possible types of an item
              */
-            enum class DataSourceItemType { NODE, PRODUCT };
+            enum class DataSourceItemType { NODE, PRODUCT, COMPONENT };
             /**
              * @brief The DataSourceItem class aims to represent a structure element of a data source.
              * A data source has a tree structure that is made up of a main DataSourceItem object (root)
              * containing other DataSourceItem objects (children).
              * For each DataSourceItem can be associated a set of data representing it.
              */
             class DataSourceItem {
             public:
-                explicit DataSourceItem(DataSourceItemType type, QVector<QVariant> data = {});
+                /// Key associated with the name of the item
+                static const QString NAME_DATA_KEY;
+                explicit DataSourceItem(DataSourceItemType type, const QString &name);
+                explicit DataSourceItem(DataSourceItemType type, QHash<QString, QVariant> data = {});
                 /// @return the actions of the item as a vector
                 QVector<DataSourceItemAction *> actions() const noexcept;
                 /**
                  * Adds an action to the item. The item takes ownership of the action, and the action is
                  * automatically associated to the item
                  * @param action the action to add
                  */
                 void addAction(std::unique_ptr<DataSourceItemAction> action) noexcept;
                 /**
                  * Adds a child to the item. The item takes ownership of the child.
                  * @param child the child to add
                  */
                 void appendChild(std::unique_ptr<DataSourceItem> child) noexcept;
                 /**
                  * Returns the item's child associated to an index
                  * @param childIndex the index to search
                  * @return a pointer to the child if index is valid, nullptr otherwise
                  */
                 DataSourceItem *child(int childIndex) const noexcept;
                 int childCount() const noexcept;
                 /**
-                 * Get the data associated to an index
+                 * Get the data associated to a key
-                 * @param dataIndex the index to search
+                 * @param key the key to search
-                 * @return the data found if index is valid, default QVariant otherwise
+                 * @return the data found if key is valid, default QVariant otherwise
                  */
-                QVariant data(int dataIndex) const noexcept;
+                QVariant data(const QString &key) const noexcept;
+                /// Gets all data
+                const QHash<QString, QVariant> &data() const noexcept;
+                bool isRoot() const noexcept;
                 QString name() const noexcept;
                 /**
                  * Get the item's parent
                  * @return a pointer to the parent if it exists, nullptr if the item is a root
                  */
                 DataSourceItem *parentItem() const noexcept;
+                /**
+                 * Sets or appends a value to a key
+                 * @param key the key
+                 * @param value the value
+                 * @param append if true, the value is added to the values already existing for the key,
+                 * otherwise it replaces the existing values
+                 */
+                void setData(const QString &key, const QVariant &value, bool append = false) noexcept;
                 DataSourceItemType type() const noexcept;
+                bool operator==(const DataSourceItem &other);
+                bool operator!=(const DataSourceItem &other);
             private:
                 class DataSourceItemPrivate;
                 spimpl::unique_impl_ptr<DataSourceItemPrivate> impl;
             };
             #endif // SCIQLOP_DATASOURCEITEMMODEL_H

core/src/DataSource/DataSourceItem.cpp +66 -12

             #include <DataSource/DataSourceItem.h>
             #include <DataSource/DataSourceItemAction.h>
             #include <QVector>
-            namespace {
+            const QString DataSourceItem::NAME_DATA_KEY = QStringLiteral("name");
-            /// Index of the 'name' value in the item
-            const auto NAME_INDEX = 0;
-            } // namespace
             struct DataSourceItem::DataSourceItemPrivate {
-                explicit DataSourceItemPrivate(DataSourceItemType type, QVector<QVariant> data)
+                explicit DataSourceItemPrivate(DataSourceItemType type, QHash<QString, QVariant> data)
                         : m_Parent{nullptr}, m_Children{}, m_Type{type}, m_Data{std::move(data)}, m_Actions{}
                 {
                 }
                 DataSourceItem *m_Parent;
                 std::vector<std::unique_ptr<DataSourceItem> > m_Children;
                 DataSourceItemType m_Type;
-                QVector<QVariant> m_Data;
+                QHash<QString, QVariant> m_Data;
                 std::vector<std::unique_ptr<DataSourceItemAction> > m_Actions;
             };
-            DataSourceItem::DataSourceItem(DataSourceItemType type, QVector<QVariant> data)
+            DataSourceItem::DataSourceItem(DataSourceItemType type, const QString &name)
+                    : DataSourceItem{type, QHash<QString, QVariant>{{NAME_DATA_KEY, name}}}
+            {
+            }
+            DataSourceItem::DataSourceItem(DataSourceItemType type, QHash<QString, QVariant> data)
                     : impl{spimpl::make_unique_impl<DataSourceItemPrivate>(type, std::move(data))}
             {
             }
             QVector<DataSourceItemAction *> DataSourceItem::actions() const noexcept
             {
                 auto result = QVector<DataSourceItemAction *>{};
                 std::transform(std::cbegin(impl->m_Actions), std::cend(impl->m_Actions),
                                std::back_inserter(result), [](const auto &action) { return action.get(); });
                 return result;
             }
             void DataSourceItem::addAction(std::unique_ptr<DataSourceItemAction> action) noexcept
             {
                 action->setDataSourceItem(this);
                 impl->m_Actions.push_back(std::move(action));
             }
             void DataSourceItem::appendChild(std::unique_ptr<DataSourceItem> child) noexcept
             {
                 child->impl->m_Parent = this;
                 impl->m_Children.push_back(std::move(child));
             }
             DataSourceItem *DataSourceItem::child(int childIndex) const noexcept
             {
                 if (childIndex < 0 || childIndex >= childCount()) {
                     return nullptr;
                 }
                 else {
                     return impl->m_Children.at(childIndex).get();
                 }
             }
             int DataSourceItem::childCount() const noexcept
             {
                 return impl->m_Children.size();
             }
-            QVariant DataSourceItem::data(int dataIndex) const noexcept
+            QVariant DataSourceItem::data(const QString &key) const noexcept
             {
-                return impl->m_Data.value(dataIndex);
+                return impl->m_Data.value(key);
+            }
+            const QHash<QString, QVariant> &DataSourceItem::data() const noexcept
+            {
+                return impl->m_Data;
+            }
+            bool DataSourceItem::isRoot() const noexcept
+            {
+                return impl->m_Parent == nullptr;
             }
             QString DataSourceItem::name() const noexcept
             {
-                return data(NAME_INDEX).toString();
+                return data(NAME_DATA_KEY).toString();
             }
             DataSourceItem *DataSourceItem::parentItem() const noexcept
             {
                 return impl->m_Parent;
             }
+            void DataSourceItem::setData(const QString &key, const QVariant &value, bool append) noexcept
+            {
+                auto it = impl->m_Data.constFind(key);
+                if (append && it != impl->m_Data.constEnd()) {
+                    // Case of an existing value to which we want to add to the new value
+                    if (it->canConvert<QVariantList>()) {
+                        auto variantList = it->value<QVariantList>();
+                        variantList.append(value);
+                        impl->m_Data.insert(key, variantList);
+                    }
+                    else {
+                        impl->m_Data.insert(key, QVariantList{*it, value});
+                    }
+                }
+                else {
+                    // Other cases :
+                    // - new value in map OR
+                    // - replacement of an existing value (not appending)
+                    impl->m_Data.insert(key, value);
+                }
+            }
             DataSourceItemType DataSourceItem::type() const noexcept
             {
                 return impl->m_Type;
             }
+            bool DataSourceItem::operator==(const DataSourceItem &other)
+            {
+                // Compares items' attributes
+                if (std::tie(impl->m_Type, impl->m_Data) == std::tie(other.impl->m_Type, other.impl->m_Data)) {
+                    // Compares contents of items' children
+                    return std::equal(std::cbegin(impl->m_Children), std::cend(impl->m_Children),
+                                      std::cbegin(other.impl->m_Children),
+                                      [](const auto &itemChild, const auto &otherChild) {
+                                          return *itemChild == *otherChild;
+                                      });
+                }
+                else {
+                    return false;
+                }
+            }
+            bool DataSourceItem::operator!=(const DataSourceItem &other)
+            {
+                return !(*this == other);
+            }

core/tests/DataSource/TestDataSourceController.cpp +1 -3

             #include <DataSource/DataSourceController.h>
             #include <DataSource/DataSourceItem.h>
             #include <QObject>
             #include <QtTest>
             #include <memory>
             class TestDataSourceController : public QObject {
                 Q_OBJECT
             private slots:
                 void testRegisterDataSource();
                 void testSetDataSourceItem();
             };
             void TestDataSourceController::testRegisterDataSource()
             {
                 DataSourceController dataSourceController{};
                 auto uid = dataSourceController.registerDataSource(QStringLiteral("Source1"));
                 QVERIFY(!uid.isNull());
             }
             void TestDataSourceController::testSetDataSourceItem()
             {
                 DataSourceController dataSourceController{};
                 // Spy to test controllers' signals
                 QSignalSpy signalSpy{&dataSourceController, SIGNAL(dataSourceItemSet(DataSourceItem *))};
                 // Create a data source item
                 auto source1Name = QStringLiteral("Source1");
-                auto source1Values = QVector<QVariant>{source1Name};
+                auto source1Item = std::make_unique<DataSourceItem>(DataSourceItemType::PRODUCT, source1Name);
-                auto source1Item
-                    = std::make_unique<DataSourceItem>(DataSourceItemType::PRODUCT, std::move(source1Values));
                 // Add data source item to the controller and check that a signal has been emitted after setting
                 // data source item in the controller
                 auto source1Uid = dataSourceController.registerDataSource(source1Name);
                 dataSourceController.setDataSourceItem(source1Uid, std::move(source1Item));
                 QCOMPARE(signalSpy.count(), 1);
                 // Try to a data source item with an unregistered uid and check that no signal has been emitted
                 auto unregisteredUid = QUuid::createUuid();
                 dataSourceController.setDataSourceItem(
                     unregisteredUid, std::make_unique<DataSourceItem>(DataSourceItemType::PRODUCT));
                 QCOMPARE(signalSpy.count(), 1);
             }
             QTEST_MAIN(TestDataSourceController)
             #include "TestDataSourceController.moc"

gui/resources/sqpguiresources.qrc +4 0

             <RCC>
                 <qresource prefix="/">
+            		<file>icones/dataSourceComponent.png</file>
+            		<file>icones/dataSourceNode.png</file>
+            		<file>icones/dataSourceProduct.png</file>
+            		<file>icones/dataSourceRoot.png</file>
             		<file>icones/delete.png</file>
                     <file>icones/openInspector.png</file>
                     <file>icones/next.png</file>
                     <file>icones/plot.png</file>
                     <file>icones/previous.png</file>
                     <file>icones/unplot.png</file>
                 </qresource>
             </RCC>

gui/src/DataSource/DataSourceTreeWidgetItem.cpp +78 -8

             #include <DataSource/DataSourceItem.h>
             #include <DataSource/DataSourceItemAction.h>
             #include <DataSource/DataSourceTreeWidgetItem.h>
-            #include <SqpApplication.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:
+                        case DataSourceItemType::NODE: {
-                            return sqpApp->style()->standardIcon(QStyle::SP_DirIcon);
+                            return dataSource->isRoot() ? QIcon{":/icones/dataSourceRoot.png"}
+                                                        : QIcon{":/icones/dataSourceNode.png"};
+                        }
                         case DataSourceItemType::PRODUCT:
-                            return sqpApp->style()->standardIcon(QStyle::SP_FileIcon);
+                            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 {
-                    qCWarning(LOG_DataSourceTreeWidgetItem())
+                    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 depending on the data source
+                // 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);
             }
             QVariant DataSourceTreeWidgetItem::data(int column, int role) const
             {
                 if (role == Qt::DisplayRole) {
-                    return (impl->m_Data) ? impl->m_Data->data(column) : QVariant{};
+                    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;
             }

plugins/mockplugin/src/MockPlugin.cpp +6 -8

             #include "MockPlugin.h"
             #include "CosinusProvider.h"
             #include <DataSource/DataSourceController.h>
             #include <DataSource/DataSourceItem.h>
             #include <DataSource/DataSourceItemAction.h>
             #include <SqpApplication.h>
             Q_LOGGING_CATEGORY(LOG_MockPlugin, "MockPlugin")
             namespace {
             /// Name of the data source
             const auto DATA_SOURCE_NAME = QStringLiteral("MMS");
             /// Creates the data provider relative to the plugin
             std::unique_ptr<IDataProvider> createDataProvider() noexcept
             {
                 return std::make_unique<CosinusProvider>();
             }
             std::unique_ptr<DataSourceItem> createProductItem(const QString &productName,
                                                               const QUuid &dataSourceUid)
             {
-                auto result = std::make_unique<DataSourceItem>(DataSourceItemType::PRODUCT,
+                auto result = std::make_unique<DataSourceItem>(DataSourceItemType::PRODUCT, productName);
-                                                               QVector<QVariant>{productName});
                 // Add action to load product from DataSourceController
                 result->addAction(std::make_unique<DataSourceItemAction>(
                     QObject::tr("Load %1 product").arg(productName),
                     [productName, dataSourceUid](DataSourceItem &item) {
                         if (auto app = sqpApp) {
                             app->dataSourceController().loadProductItem(dataSourceUid, item);
                         }
                     }));
                 return result;
             }
             /// Creates the data source item relative to the plugin
             std::unique_ptr<DataSourceItem> createDataSourceItem(const QUuid &dataSourceUid) noexcept
             {
                 // Magnetic field products
-                auto magneticFieldFolder = std::make_unique<DataSourceItem>(
+                auto magneticFieldFolder = std::make_unique<DataSourceItem>(DataSourceItemType::NODE,
-                    DataSourceItemType::NODE, QVector<QVariant>{QStringLiteral("Magnetic field")});
+                                                                            QStringLiteral("Magnetic field"));
                 magneticFieldFolder->appendChild(createProductItem(QStringLiteral("FGM"), dataSourceUid));
                 magneticFieldFolder->appendChild(createProductItem(QStringLiteral("SC"), dataSourceUid));
                 // Electric field products
-                auto electricFieldFolder = std::make_unique<DataSourceItem>(
+                auto electricFieldFolder = std::make_unique<DataSourceItem>(DataSourceItemType::NODE,
-                    DataSourceItemType::NODE, QVector<QVariant>{QStringLiteral("Electric field")});
+                                                                            QStringLiteral("Electric field"));
                 // Root
-                auto root = std::make_unique<DataSourceItem>(DataSourceItemType::NODE,
+                auto root = std::make_unique<DataSourceItem>(DataSourceItemType::NODE, DATA_SOURCE_NAME);
-                                                             QVector<QVariant>{DATA_SOURCE_NAME});
                 root->appendChild(std::move(magneticFieldFolder));
                 root->appendChild(std::move(electricFieldFolder));
                 return root;
             }
             } // namespace
             void MockPlugin::initialize()
             {
                 if (auto app = sqpApp) {
                     // Registers to the data source controller
                     auto &dataSourceController = app->dataSourceController();
                     auto dataSourceUid = dataSourceController.registerDataSource(DATA_SOURCE_NAME);
                     // Sets data source tree
                     dataSourceController.setDataSourceItem(dataSourceUid, createDataSourceItem(dataSourceUid));
                     // Sets data provider
                     dataSourceController.setDataProvider(dataSourceUid, createDataProvider());
                 }
                 else {
                     qCWarning(LOG_MockPlugin()) << tr("Can't access to SciQlop application");
                 }
             }

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