GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r343:21cfeb46fc36

Updates references to DataSourceItem after changes

Alexandre Leroux -

r343:21cfeb46fc36

parent child

Context file:

r343:21cfeb46fc36

Collapse all files

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/src/DataSource/DataSourceTreeWidgetItem.cpp +20 -1

             #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:
                             return sqpApp->style()->standardIcon(QStyle::SP_DirIcon);
                         case DataSourceItemType::PRODUCT:
                             return sqpApp->style()->standardIcon(QStyle::SP_FileIcon);
                         default:
                             // No action
                             break;
                     }
                     qCWarning(LOG_DataSourceTreeWidgetItem())
                         << QObject::tr("Can't set data source icon : unknown data source type");
                 }
                 else {
                     qCWarning(LOG_DataSourceTreeWidgetItem())
                         << QObject::tr("Can't set data source icon : the data source is null");
                 }
                 // Default cases
                 return QIcon{};
             }
             } // 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
                 setIcon(0, itemIcon(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