GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r154:42e91aee0749

Merge pull request from SCIQLOP-Initialisation develop...

perrinel -

r154:42e91aee0749

parent child

Context file:

r154:42e91aee0749

core/include/DataSource/DataSourceItemAction.h created 644 +48 0

@@ -0,0 +1,48
	1	#ifndef SCIQLOP_DATASOURCEITEMACTION_H
	2	#define SCIQLOP_DATASOURCEITEMACTION_H
	3
	4	#include <Common/spimpl.h>
	5
	6	#include <QLoggingCategory>
	7	#include <QObject>
	8
	9	Q_DECLARE_LOGGING_CATEGORY(LOG_DataSourceItemAction)
	10
	11	class DataSourceItem;
	12
	13	/**
	14	* @brief The DataSourceItemAction class represents an action on a data source item.
	15	*
	16	* An action is a function that will be executed when the slot execute() is called.
	17	*/
	18	class DataSourceItemAction : public QObject {
	19
	20	Q_OBJECT
	21
	22	public:
	23	/// Signature of the function associated to the action
	24	using ExecuteFunction = std::function<void(DataSourceItem &dataSourceItem)>;
	25
	26	/**
	27	* Ctor
	28	* @param name the name of the action
	29	* @param fun the function that will be called when the action is executed
	30	* @sa execute()
	31	*/
	32	explicit DataSourceItemAction(const QString &name, ExecuteFunction fun);
	33
	34	QString name() const noexcept;
	35
	36	/// Sets the data source item concerned by the action
	37	void setDataSourceItem(DataSourceItem *dataSourceItem) noexcept;
	38
	39	public slots:
	40	/// Executes the action
	41	void execute();
	42
	43	private:
	44	class DataSourceItemActionPrivate;
	45	spimpl::unique_impl_ptr<DataSourceItemActionPrivate> impl;
	46	};
	47
	48	#endif // SCIQLOP_DATASOURCEITEMACTION_H

core/src/DataSource/DataSourceItemAction.cpp created 644 +42 0

@@ -0,0 +1,42
	1	#include <DataSource/DataSourceItemAction.h>
	2
	3	Q_LOGGING_CATEGORY(LOG_DataSourceItemAction, "DataSourceItemAction")
	4
	5	struct DataSourceItemAction::DataSourceItemActionPrivate {
	6	explicit DataSourceItemActionPrivate(const QString &name,
	7	DataSourceItemAction::ExecuteFunction fun)
	8	: m_Name{name}, m_Fun{std::move(fun)}, m_DataSourceItem{nullptr}
	9	{
	10	}
	11
	12	QString m_Name;
	13	DataSourceItemAction::ExecuteFunction m_Fun;
	14	/// Item associated to the action (can be null, in which case the action will not be executed)
	15	DataSourceItem *m_DataSourceItem;
	16	};
	17
	18	DataSourceItemAction::DataSourceItemAction(const QString &name, ExecuteFunction fun)
	19	: impl{spimpl::make_unique_impl<DataSourceItemActionPrivate>(name, std::move(fun))}
	20	{
	21	}
	22
	23	QString DataSourceItemAction::name() const noexcept
	24	{
	25	return impl->m_Name;
	26	}
	27
	28	void DataSourceItemAction::setDataSourceItem(DataSourceItem *dataSourceItem) noexcept
	29	{
	30	impl->m_DataSourceItem = dataSourceItem;
	31	}
	32
	33	void DataSourceItemAction::execute()
	34	{
	35	if (impl->m_DataSourceItem) {
	36	impl->m_Fun(*impl->m_DataSourceItem);
	37	}
	38	else {
	39	qCDebug(LOG_DataSourceItemAction())
	40	<< tr("Can't execute action : no item has been associated");
	41	}
	42	}

core/include/DataSource/DataSourceController.h +6 0

                 void setDataProvider(const QUuid &dataSourceUid,
                                      std::unique_ptr<IDataProvider> dataProvider) noexcept;
+                /**
+                 * Loads an item (product) as a variable in SciQlop
+                 * @param productItem the item to load
+                 */
+                void loadProductItem(const DataSourceItem &productItem) noexcept;
             public slots:
                 /// Manage init/end of the controller
                 void initialize();

core/include/DataSource/DataSourceItem.h +14 0

             #include <QVariant>
             #include <QVector>
+            class DataSourceItemAction;
             /**
              * Possible types of an item
              */
             public:
                 explicit DataSourceItem(DataSourceItemType type, QVector<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
                  */
                 QVariant data(int dataIndex) 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

core/src/DataSource/DataSourceController.cpp +5 0

                 }
             }
+            void DataSourceController::loadProductItem(const DataSourceItem &productItem) noexcept
+            {
+                /// @todo ALX
+            }
             void DataSourceController::initialize()
             {
                 qCDebug(LOG_DataSourceController()) << tr("DataSourceController init")

core/src/DataSource/DataSourceItem.cpp +31 -1

             #include <DataSource/DataSourceItem.h>
+            #include <DataSource/DataSourceItemAction.h>
             #include <QVector>
+            namespace {
+            /// Index of the 'name' value in the item
+            const auto NAME_INDEX = 0;
+            } // namespace
             struct DataSourceItem::DataSourceItemPrivate {
                 explicit DataSourceItemPrivate(DataSourceItemType type, QVector<QVariant> data)
-                        : m_Parent{nullptr}, m_Children{}, m_Type{type}, m_Data{std::move(data)}
+                        : m_Parent{nullptr}, m_Children{}, m_Type{type}, m_Data{std::move(data)}, m_Actions{}
                 {
                 }
                 std::vector<std::unique_ptr<DataSourceItem> > m_Children;
                 DataSourceItemType m_Type;
                 QVector<QVariant> m_Data;
+                std::vector<std::unique_ptr<DataSourceItemAction> > m_Actions;
             };
             DataSourceItem::DataSourceItem(DataSourceItemType type, QVector<QVariant> data)
             {
             }
+            QVector<DataSourceItemAction *> DataSourceItem::actions() const noexcept
+            {
+                QVector<DataSourceItemAction *> result{};
+                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;
                 return impl->m_Data.value(dataIndex);
             }
+            QString DataSourceItem::name() const noexcept
+            {
+                return data(NAME_INDEX).toString();
+            }
             DataSourceItem *DataSourceItem::parentItem() const noexcept
             {
                 return impl->m_Parent;

core/vera-exclusions/exclusions.txt +3 0

             ArrayData\.h:\d+:.*IPSIS_S04_VARIABLE.*found: (D)
             ArrayData\.h:\d+:.*IPSIS_S06.*found: (D)
             ArrayData\.h:\d+:.*IPSIS_S06.*found: (Dim)
+            # Ignore false positive relative to an alias
+            DataSourceItemAction\.h:\d+:.*IPSIS_S06.*found: (ExecuteFunction)

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

                 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;

gui/include/DataSource/DataSourceWidget.h +4 0

             private:
                 Ui::DataSourceWidget *ui;
+            private slots:
+                /// 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 +26 0

             #include <DataSource/DataSourceItem.h>
+            #include <DataSource/DataSourceItemAction.h>
             #include <DataSource/DataSourceTreeWidgetItem.h>
             #include <SqpApplication.h>
+            #include <QAction>
             Q_LOGGING_CATEGORY(LOG_DataSourceTreeWidgetItem, "DataSourceTreeWidgetItem")
             namespace {
                 /// 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)
             {
                 // 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
                     QTreeWidgetItem::setData(column, role, value);
                 }
             }
+            QList<QAction *> DataSourceTreeWidgetItem::actions() const noexcept
+            {
+                return impl->m_Actions;
+            }

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

             #include <DataSource/DataSourceItem.h>
             #include <DataSource/DataSourceTreeWidgetItem.h>
+            #include <QMenu>
             namespace {
             /// Number of columns displayed in the tree
                 // 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);
             }
             void DataSourceWidget::addDataSource(DataSourceItem *dataSource) noexcept
                     ui->treeWidget->addTopLevelItem(createTreeWidgetItem(dataSource));
                 }
             }
+            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));
+                    }
+                }
+            }

plugins/mockplugin/src/MockPlugin.cpp +19 -7

             #include <DataSource/DataSourceController.h>
             #include <DataSource/DataSourceItem.h>
+            #include <DataSource/DataSourceItemAction.h>
             #include <SqpApplication.h>
                 return std::make_unique<CosinusProvider>();
             }
+            std::unique_ptr<DataSourceItem> createProductItem(const QString &productName)
+            {
+                auto result = std::make_unique<DataSourceItem>(DataSourceItemType::PRODUCT,
+                                                               QVector<QVariant>{productName});
+                // Add action to load product from DataSourceController
+                result->addAction(std::make_unique<DataSourceItemAction>(
+                    QObject::tr("Load %1 product").arg(productName), [productName](DataSourceItem &item) {
+                        if (auto app = sqpApp) {
+                            app->dataSourceController().loadProductItem(item);
+                        }
+                    }));
+                return result;
+            }
             /// Creates the data source item relative to the plugin
             std::unique_ptr<DataSourceItem> createDataSourceItem() noexcept
             {
                 // Magnetic field products
-                auto fgmProduct = std::make_unique<DataSourceItem>(DataSourceItemType::PRODUCT,
-                                                                   QVector<QVariant>{QStringLiteral("FGM")});
-                auto scProduct = std::make_unique<DataSourceItem>(DataSourceItemType::PRODUCT,
-                                                                  QVector<QVariant>{QStringLiteral("SC")});
                 auto magneticFieldFolder = std::make_unique<DataSourceItem>(
                     DataSourceItemType::NODE, QVector<QVariant>{QStringLiteral("Magnetic field")});
-                magneticFieldFolder->appendChild(std::move(fgmProduct));
+                magneticFieldFolder->appendChild(createProductItem(QStringLiteral("FGM")));
-                magneticFieldFolder->appendChild(std::move(scProduct));
+                magneticFieldFolder->appendChild(createProductItem(QStringLiteral("SC")));
                 // Electric field products
                 auto electricFieldFolder = std::make_unique<DataSourceItem>(

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