GIT_REPOSITORIES/LPP/Users/mperrinel/SCIQLOP-Initialisation Commit - r135:7a9a79ed3b02

Defines actions for a data source items...

Alexandre Leroux -

r135:7a9a79ed3b02

parent child

Context file:

r135:7a9a79ed3b02

Collapse all files

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/DataSourceItem.h +12 0

             #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 };
             /**
              * @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 = {});
+                /// @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
                  * @param dataIndex the index to search
                  * @return the data found if index is valid, default QVariant otherwise
                  */
                 QVariant data(int dataIndex) 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;
                 DataSourceItemType type() const noexcept;
             private:
                 class DataSourceItemPrivate;
                 spimpl::unique_impl_ptr<DataSourceItemPrivate> impl;
             };
             #endif // SCIQLOP_DATASOURCEITEMMODEL_H

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

             #include <DataSource/DataSourceItem.h>
+            #include <DataSource/DataSourceItemAction.h>
             #include <QVector>
             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{}
                 {
                 }
                 DataSourceItem *m_Parent;
                 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)
                     : impl{spimpl::make_unique_impl<DataSourceItemPrivate>(type, std::move(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;
                 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
             {
                 return impl->m_Data.value(dataIndex);
             }
             DataSourceItem *DataSourceItem::parentItem() const noexcept
             {
                 return impl->m_Parent;
             }
             DataSourceItemType DataSourceItem::type() const noexcept
             {
                 return impl->m_Type;
             }

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