HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r1076:666a84a7f3b2

Adds a a gui controller class to manage global actions across the application.

trabillard -

r1076:666a84a7f3b2

parent child

Context file:

r1076:666a84a7f3b2

gui/include/Actions/ActionsGuiController.h created 644 +22 0

@@ -0,0 +1,22
	1	#ifndef SCIQLOP_ACTIONSGUICONTROLLER_H
	2	#define SCIQLOP_ACTIONSGUICONTROLLER_H
	3
	4	#include <Actions/SelectionZoneAction.h>
	5	#include <Common/spimpl.h>
	6
	7	#include <memory>
	8
	9	class ActionsGuiController {
	10	public:
	11	ActionsGuiController();
	12
	13	std::shared_ptr<SelectionZoneAction>
	14	addSectionZoneAction(const QString &name, SelectionZoneAction::ExecuteFunction function);
	15	QVector<std::shared_ptr<SelectionZoneAction> > selectionZoneActions() const;
	16
	17	private:
	18	class ActionsGuiControllerPrivate;
	19	spimpl::unique_impl_ptr<ActionsGuiControllerPrivate> impl;
	20	};
	21
	22	#endif // SCIQLOP_ACTIONSGUICONTROLLER_H

gui/include/Actions/SelectionZoneAction.h created 644 +49 0

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

gui/src/Actions/ActionsGuiController.cpp created 644 +26 0

@@ -0,0 +1,26
	1	#include "Actions/ActionsGuiController.h"
	2
	3	struct ActionsGuiController::ActionsGuiControllerPrivate {
	4
	5	QVector<std::shared_ptr<SelectionZoneAction> > m_SelectionZoneActions;
	6	};
	7
	8	ActionsGuiController::ActionsGuiController()
	9	: impl{spimpl::make_unique_impl<ActionsGuiControllerPrivate>()}
	10	{
	11	}
	12
	13	std::shared_ptr<SelectionZoneAction>
	14	ActionsGuiController::addSectionZoneAction(const QString &name,
	15	SelectionZoneAction::ExecuteFunction function)
	16	{
	17	auto action = std::make_shared<SelectionZoneAction>(name, function);
	18	impl->m_SelectionZoneActions.push_back(action);
	19
	20	return action;
	21	}
	22
	23	QVector<std::shared_ptr<SelectionZoneAction> > ActionsGuiController::selectionZoneActions() const
	24	{
	25	return impl->m_SelectionZoneActions;
	26	}

gui/src/Actions/SelectionZoneAction.cpp created 644 +30 0

@@ -0,0 +1,30
	1	#include <Actions/SelectionZoneAction.h>
	2	#include <Visualization/VisualizationSelectionZoneItem.h>
	3
	4	Q_LOGGING_CATEGORY(LOG_SelectionZoneAction, "SelectionZoneAction")
	5
	6	struct SelectionZoneAction::SelectionZoneActionPrivate {
	7	explicit SelectionZoneActionPrivate(const QString &name,
	8	SelectionZoneAction::ExecuteFunction fun)
	9	: m_Name{name}, m_Fun{std::move(fun)}
	10	{
	11	}
	12
	13	QString m_Name;
	14	SelectionZoneAction::ExecuteFunction m_Fun;
	15	};
	16
	17	SelectionZoneAction::SelectionZoneAction(const QString &name, ExecuteFunction fun)
	18	: impl{spimpl::make_unique_impl<SelectionZoneActionPrivate>(name, std::move(fun))}
	19	{
	20	}
	21
	22	QString SelectionZoneAction::name() const noexcept
	23	{
	24	return impl->m_Name;
	25	}
	26
	27	void SelectionZoneAction::execute(const QVector<VisualizationSelectionZoneItem *> &item)
	28	{
	29	impl->m_Fun(item);
	30	}

gui/include/SqpApplication.h +2 0

             #ifndef SCIQLOP_SQPAPPLICATION_H
             #define SCIQLOP_SQPAPPLICATION_H
             #include "SqpApplication.h"
             #include <QApplication>
             #include <QLoggingCategory>
             #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_SqpApplication)
             #if defined(sqpApp)
             #undef sqpApp
             #endif
             #define sqpApp (static_cast<SqpApplication *>(QCoreApplication::instance()))
             class DataSourceController;
             class NetworkController;
             class TimeController;
             class VariableController;
             class VisualizationController;
             class DragDropGuiController;
+            class ActionsGuiController;
             /**
              * @brief The SqpApplication class aims to make the link between SciQlop
              * and its plugins. This is the intermediate class that SciQlop has to use
              * in the way to connect a data source. Please first use load method to initialize
              * a plugin specified by its metadata name (JSON plugin source) then others specifics
              * method will be able to access it.
              * You can load a data source driver plugin then create a data source.
              */
             class SqpApplication : public QApplication {
                 Q_OBJECT
             public:
                 explicit SqpApplication(int &argc, char **argv);
                 virtual ~SqpApplication();
                 void initialize();
                 /// Accessors for the differents sciqlop controllers
                 DataSourceController &dataSourceController() noexcept;
                 NetworkController &networkController() noexcept;
                 TimeController &timeController() noexcept;
                 VariableController &variableController() noexcept;
                 VisualizationController &visualizationController() noexcept;
                 /// Accessors for the differents sciqlop helpers, these helpers classes are like controllers but
                 /// doesn't live in a thread and access gui
                 DragDropGuiController &dragDropGuiController() noexcept;
+                ActionsGuiController &actionsGuiController() noexcept;
                 enum class PlotsInteractionMode { None, ZoomBox, DragAndDrop, SelectionZones };
                 enum class PlotsCursorMode { NoCursor, Vertical, Temporal, Horizontal, Cross };
                 PlotsInteractionMode plotsInteractionMode() const;
                 void setPlotsInteractionMode(PlotsInteractionMode mode);
                 PlotsCursorMode plotsCursorMode() const;
                 void setPlotsCursorMode(PlotsCursorMode mode);
             private:
                 class SqpApplicationPrivate;
                 spimpl::unique_impl_ptr<SqpApplicationPrivate> impl;
             };
             #endif // SCIQLOP_SQPAPPLICATION_H

gui/meson.build +5 -2

             gui_moc_headers = [
               'include/DataSource/DataSourceWidget.h',
               'include/Settings/SqpSettingsDialog.h',
               'include/Settings/SqpSettingsGeneralWidget.h',
               'include/SidePane/SqpSidePane.h',
               'include/SqpApplication.h',
               'include/DragAndDrop/DragDropScroller.h',
               'include/DragAndDrop/DragDropTabSwitcher.h',
               'include/TimeWidget/TimeWidget.h',
               'include/Variable/VariableInspectorWidget.h',
               'include/Variable/RenameVariableDialog.h',
               'include/Visualization/qcustomplot.h',
               'include/Visualization/VisualizationGraphWidget.h',
               'include/Visualization/VisualizationTabWidget.h',
               'include/Visualization/VisualizationWidget.h',
               'include/Visualization/VisualizationZoneWidget.h',
               'include/Visualization/VisualizationDragDropContainer.h',
               'include/Visualization/VisualizationDragWidget.h',
-              'include/Visualization/ColorScaleEditor.h'
+              'include/Visualization/ColorScaleEditor.h',
+              'include/Visualization/SelectionZoneAction.h'
             ]
             gui_ui_files = [
               'ui/DataSource/DataSourceWidget.ui',
               'ui/Settings/SqpSettingsDialog.ui',
               'ui/Settings/SqpSettingsGeneralWidget.ui',
               'ui/SidePane/SqpSidePane.ui',
               'ui/TimeWidget/TimeWidget.ui',
               'ui/Variable/VariableInspectorWidget.ui',
               'ui/Variable/RenameVariableDialog.ui',
               'ui/Variable/VariableMenuHeaderWidget.ui',
               'ui/Visualization/VisualizationGraphWidget.ui',
               'ui/Visualization/VisualizationTabWidget.ui',
               'ui/Visualization/VisualizationWidget.ui',
               'ui/Visualization/VisualizationZoneWidget.ui',
               'ui/Visualization/ColorScaleEditor.ui'
             ]
             gui_qresources = ['resources/sqpguiresources.qrc']
             gui_moc_files = qt5.preprocess(moc_headers : gui_moc_headers,
                                            ui_files : gui_ui_files,
                                            qresources : gui_qresources)
             gui_sources = [
               'src/SqpApplication.cpp',
               'src/DragAndDrop/DragDropHelper.cpp',
               'src/DragAndDrop/DragDropScroller.cpp',
               'src/DragAndDrop/DragDropTabSwitcher.cpp',
               'src/Common/ColorUtils.cpp',
               'src/Common/VisualizationDef.cpp',
               'src/DataSource/DataSourceTreeWidgetItem.cpp',
               'src/DataSource/DataSourceTreeWidgetHelper.cpp',
               'src/DataSource/DataSourceWidget.cpp',
               'src/DataSource/DataSourceTreeWidget.cpp',
               'src/Settings/SqpSettingsDialog.cpp',
               'src/Settings/SqpSettingsGeneralWidget.cpp',
               'src/SidePane/SqpSidePane.cpp',
               'src/TimeWidget/TimeWidget.cpp',
               'src/Variable/VariableInspectorWidget.cpp',
               'src/Variable/VariableInspectorTableView.cpp',
               'src/Variable/VariableMenuHeaderWidget.cpp',
               'src/Variable/RenameVariableDialog.cpp',
               'src/Visualization/VisualizationGraphHelper.cpp',
               'src/Visualization/VisualizationGraphRenderingDelegate.cpp',
               'src/Visualization/VisualizationGraphWidget.cpp',
               'src/Visualization/VisualizationTabWidget.cpp',
               'src/Visualization/VisualizationWidget.cpp',
               'src/Visualization/VisualizationZoneWidget.cpp',
               'src/Visualization/qcustomplot.cpp',
               'src/Visualization/QCustomPlotSynchronizer.cpp',
               'src/Visualization/operations/FindVariableOperation.cpp',
               'src/Visualization/operations/GenerateVariableMenuOperation.cpp',
               'src/Visualization/operations/MenuBuilder.cpp',
               'src/Visualization/operations/RemoveVariableOperation.cpp',
               'src/Visualization/operations/RescaleAxeOperation.cpp',
               'src/Visualization/VisualizationDragDropContainer.cpp',
               'src/Visualization/VisualizationDragWidget.cpp',
               'src/Visualization/AxisRenderingUtils.cpp',
               'src/Visualization/PlottablesRenderingUtils.cpp',
               'src/Visualization/MacScrollBarStyle.cpp',
               'src/Visualization/VisualizationCursorItem.cpp',
               'src/Visualization/ColorScaleEditor.cpp',
               'src/Visualization/SqpColorScale.cpp',
               'src/Visualization/QCPColorMapIterator.cpp',
               'src/Visualization/VisualizationSelectionZoneItem.cpp',
-              'src/Visualization/VisualizationSelectionZoneManager.cpp'
+              'src/Visualization/VisualizationSelectionZoneManager.cpp',
+              'src/Visualization/SelectionZoneAction.cpp',
+              'src/Visualization/ActionsGuiController.cpp'
             ]
             gui_inc = include_directories(['include'])
             sciqlop_gui_lib = library('sciqlopgui',
                                    gui_sources,
                                    gui_moc_files,
                                    include_directories : [gui_inc],
                                    dependencies : [ qt5printsupport, qt5gui, qt5widgets, qt5svg, sciqlop_core],
                                    install : true
                                    )
             sciqlop_gui = declare_dependency(link_with : sciqlop_gui_lib,
                                             include_directories : gui_inc,
                                             dependencies : [qt5printsupport, qt5gui, qt5widgets, qt5svg, sciqlop_core])

gui/src/SqpApplication.cpp +9 -14

             #include "SqpApplication.h"
-            #include <Catalogue/CatalogueController.h>
+            #include <Actions/ActionsGuiController.h>
             #include <Data/IDataProvider.h>
             #include <DataSource/DataSourceController.h>
             #include <DragAndDrop/DragDropGuiController.h>
             #include <Network/NetworkController.h>
             #include <QThread>
             #include <Time/TimeController.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <Variable/VariableModel.h>
             #include <Visualization/VisualizationController.h>
             Q_LOGGING_CATEGORY(LOG_SqpApplication, "SqpApplication")
             class SqpApplication::SqpApplicationPrivate {
             public:
                 SqpApplicationPrivate()
                         : m_DataSourceController{std::make_unique<DataSourceController>()},
                           m_VariableController{std::make_unique<VariableController>()},
                           m_TimeController{std::make_unique<TimeController>()},
                           m_NetworkController{std::make_unique<NetworkController>()},
                           m_VisualizationController{std::make_unique<VisualizationController>()},
                           m_DragDropGuiController{std::make_unique<DragDropGuiController>()},
                           m_CatalogueController{std::make_unique<CatalogueController>()},
+                          m_ActionsGuiController{std::make_unique<ActionsGuiController>()},
                           m_PlotInterractionMode(SqpApplication::PlotsInteractionMode::None),
                           m_PlotCursorMode(SqpApplication::PlotsCursorMode::NoCursor)
                 {
                     // /////////////////////////////// //
                     // Connections between controllers //
                     // /////////////////////////////// //
                     // VariableController <-> DataSourceController
                     connect(m_DataSourceController.get(),
                             SIGNAL(variableCreationRequested(const QString &, const QVariantHash &,
                                                              std::shared_ptr<IDataProvider>)),
                             m_VariableController.get(),
                             SLOT(createVariable(const QString &, const QVariantHash &,
                                                 std::shared_ptr<IDataProvider>)));
                     connect(m_VariableController->variableModel(), &VariableModel::requestVariable,
                             m_DataSourceController.get(), &DataSourceController::requestVariable);
                     // VariableController <-> VisualizationController
                     connect(m_VariableController.get(),
                             SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)),
                             m_VisualizationController.get(),
                             SIGNAL(variableAboutToBeDeleted(std::shared_ptr<Variable>)), Qt::DirectConnection);
                     connect(m_VariableController.get(),
                             SIGNAL(rangeChanged(std::shared_ptr<Variable>, const SqpRange &)),
                             m_VisualizationController.get(),
                             SIGNAL(rangeChanged(std::shared_ptr<Variable>, const SqpRange &)));
                     m_DataSourceController->moveToThread(&m_DataSourceControllerThread);
                     m_DataSourceControllerThread.setObjectName("DataSourceControllerThread");
                     m_NetworkController->moveToThread(&m_NetworkControllerThread);
                     m_NetworkControllerThread.setObjectName("NetworkControllerThread");
                     m_VariableController->moveToThread(&m_VariableControllerThread);
                     m_VariableControllerThread.setObjectName("VariableControllerThread");
                     m_VisualizationController->moveToThread(&m_VisualizationControllerThread);
                     m_VisualizationControllerThread.setObjectName("VsualizationControllerThread");
-                    m_CatalogueController->moveToThread(&m_CatalogueControllerThread);
-                    m_CatalogueControllerThread.setObjectName("CatalogueControllerThread");
                     // Additionnal init
                     m_VariableController->setTimeController(m_TimeController.get());
                 }
                 virtual ~SqpApplicationPrivate()
                 {
                     m_DataSourceControllerThread.quit();
                     m_DataSourceControllerThread.wait();
                     m_NetworkControllerThread.quit();
                     m_NetworkControllerThread.wait();
                     m_VariableControllerThread.quit();
                     m_VariableControllerThread.wait();
                     m_VisualizationControllerThread.quit();
                     m_VisualizationControllerThread.wait();
-                    m_CatalogueControllerThread.quit();
-                    m_CatalogueControllerThread.wait();
                 }
                 std::unique_ptr<DataSourceController> m_DataSourceController;
                 std::unique_ptr<VariableController> m_VariableController;
                 std::unique_ptr<TimeController> m_TimeController;
                 std::unique_ptr<NetworkController> m_NetworkController;
                 std::unique_ptr<VisualizationController> m_VisualizationController;
-                std::unique_ptr<CatalogueController> m_CatalogueController;
                 QThread m_DataSourceControllerThread;
                 QThread m_NetworkControllerThread;
                 QThread m_VariableControllerThread;
                 QThread m_VisualizationControllerThread;
-                QThread m_CatalogueControllerThread;
                 std::unique_ptr<DragDropGuiController> m_DragDropGuiController;
+                std::unique_ptr<ActionsGuiController> m_ActionsGuiController;
                 SqpApplication::PlotsInteractionMode m_PlotInterractionMode;
                 SqpApplication::PlotsCursorMode m_PlotCursorMode;
             };
             SqpApplication::SqpApplication(int &argc, char **argv)
                     : QApplication{argc, argv}, impl{spimpl::make_unique_impl<SqpApplicationPrivate>()}
             {
                 qCDebug(LOG_SqpApplication()) << tr("SqpApplication construction") << QThread::currentThread();
                 connect(&impl->m_DataSourceControllerThread, &QThread::started,
                         impl->m_DataSourceController.get(), &DataSourceController::initialize);
                 connect(&impl->m_DataSourceControllerThread, &QThread::finished,
                         impl->m_DataSourceController.get(), &DataSourceController::finalize);
                 connect(&impl->m_NetworkControllerThread, &QThread::started, impl->m_NetworkController.get(),
                         &NetworkController::initialize);
                 connect(&impl->m_NetworkControllerThread, &QThread::finished, impl->m_NetworkController.get(),
                         &NetworkController::finalize);
                 connect(&impl->m_VariableControllerThread, &QThread::started, impl->m_VariableController.get(),
                         &VariableController::initialize);
                 connect(&impl->m_VariableControllerThread, &QThread::finished, impl->m_VariableController.get(),
                         &VariableController::finalize);
                 connect(&impl->m_VisualizationControllerThread, &QThread::started,
                         impl->m_VisualizationController.get(), &VisualizationController::initialize);
                 connect(&impl->m_VisualizationControllerThread, &QThread::finished,
                         impl->m_VisualizationController.get(), &VisualizationController::finalize);
-                connect(&impl->m_CatalogueControllerThread, &QThread::started,
-                        impl->m_CatalogueController.get(), &CatalogueController::initialize);
-                connect(&impl->m_CatalogueControllerThread, &QThread::finished,
-                        impl->m_CatalogueController.get(), &CatalogueController::finalize);
                 impl->m_DataSourceControllerThread.start();
                 impl->m_NetworkControllerThread.start();
                 impl->m_VariableControllerThread.start();
                 impl->m_VisualizationControllerThread.start();
-                impl->m_CatalogueControllerThread.start();
             }
             SqpApplication::~SqpApplication()
             {
             }
             void SqpApplication::initialize()
             {
             }
             DataSourceController &SqpApplication::dataSourceController() noexcept
             {
                 return *impl->m_DataSourceController;
             }
             NetworkController &SqpApplication::networkController() noexcept
             {
                 return *impl->m_NetworkController;
             }
             TimeController &SqpApplication::timeController() noexcept
             {
                 return *impl->m_TimeController;
             }
             VariableController &SqpApplication::variableController() noexcept
             {
                 return *impl->m_VariableController;
             }
             VisualizationController &SqpApplication::visualizationController() noexcept
             {
                 return *impl->m_VisualizationController;
             }
             DragDropGuiController &SqpApplication::dragDropGuiController() noexcept
             {
                 return *impl->m_DragDropGuiController;
             }
+            ActionsGuiController &SqpApplication::actionsGuiController() noexcept
+            {
+                return *impl->m_ActionsGuiController;
+            }
             SqpApplication::PlotsInteractionMode SqpApplication::plotsInteractionMode() const
             {
                 return impl->m_PlotInterractionMode;
             }
             void SqpApplication::setPlotsInteractionMode(SqpApplication::PlotsInteractionMode mode)
             {
                 impl->m_PlotInterractionMode = mode;
             }
             SqpApplication::PlotsCursorMode SqpApplication::plotsCursorMode() const
             {
                 return impl->m_PlotCursorMode;
             }
             void SqpApplication::setPlotsCursorMode(SqpApplication::PlotsCursorMode mode)
             {
                 impl->m_PlotCursorMode = mode;
             }

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