HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r1495:9c439b3d7daf

New data sources system switch complete...

jeandet -

r1495:9c439b3d7daf

parent child

Context file:

r1495:9c439b3d7daf

app/PySide2-bindings/PyDataProvider.h +7 -6

             #include <Data/DataProviderParameters.h>
             #include <Data/DataSeriesType.h>
             #include <Data/IDataProvider.h>
-            #include <DataSource/DataSourceController.h>
             #include <DataSource/DataSourceItem.h>
             #include <DataSource/DataSourceItemAction.h>
+            #include <DataSource/datasources.h>
             #include <QPair>
             #include <SqpApplication.h>
             // must be included last because of Python/Qt definition of slots
             public:
                 PyDataProvider()
                 {
-                    auto& dataSourceController = sqpApp->dataSourceController();
+                    auto& dataSources = sqpApp->dataSources();
-                    dataSourceController.registerProvider(this);
+                    dataSources.addProvider(this);
                 }
                 virtual ~PyDataProvider() {}
                 inline void register_products(const QVector<Product*>& products)
                 {
-                    auto& dataSourceController = sqpApp->dataSourceController();
+                    auto& dataSources = sqpApp->dataSources();
                     auto id = this->id();
                     auto data_source_name = this->name();
                     std::for_each(std::cbegin(products), std::cend(products),
-                        [&id, &dataSourceController](const Product* product) {
+                        [&id, &dataSources](const Product* product) {
-                            dataSourceController.setDataSourceItem(id, product->path, product->metadata);
+                            dataSources.addDataSourceItem(id, product->path, product->metadata);
                         });
                 }
             };

app/src/MainWindow.cpp 0 -5

             #include <Catalogue/CatalogueController.h>
             #include <Catalogue2/browser.h>
-            #include <DataSource/DataSourceController.h>
             #include <DataSource/DataSourceItem.h>
             #include <DataSource/DataSourceWidget.h>
             #include <Settings/SqpSettingsDialog.h>
                 // Widgets / controllers connections
-                // DataSource
-                connect(&sqpApp->dataSourceController(), &DataSourceController::dataSourceItemSet,
-                    m_Ui->dataSourceWidget, &DataSourceWidget::addDataSource);
                 // Time
                 //    connect(timeWidget, SIGNAL(timeUpdated(DateTimeRange)), &sqpApp->timeController(),
                 //        SLOT(onTimeToUpdate(DateTimeRange)));

core +1 -1

	@@ -1,1 +1,1
	1	Subproject commit b081849458c211dcc59f72b11542959db2301162		1	Subproject commit 46467fb43b8d07fe4f4a45df949ec4ae858ccf9d

gui/include/DataSource/DataSourceWidget.h +8 -20

             #include <QWidget>
-            #include <memory>
+            #include <QSortFilterProxyModel>
-            namespace Ui {
+            namespace Ui
+            {
             class DataSourceWidget;
             } // Ui
              * @brief The DataSourceWidget handles the graphical representation (as a tree) of the data sources
              * attached to SciQlop.
              */
-            class DataSourceWidget : public QWidget {
+            class DataSourceWidget : public QWidget
+            {
                 Q_OBJECT
             public:
-                explicit DataSourceWidget(QWidget *parent = 0);
+                explicit DataSourceWidget(QWidget* parent = 0);
                 virtual ~DataSourceWidget() noexcept;
-            public slots:
-                /**
-                 * Adds a data source. An item associated to the data source is created and then added to the
-                 * representation tree
-                 * @param dataSource the data source to add. The pointer has to be not null
-                 */
-                void addDataSource(DataSourceItem *dataSource) noexcept;
             private:
                 void updateTreeWidget() noexcept;
-                Ui::DataSourceWidget *ui;
+                Ui::DataSourceWidget* ui;
-                std::unique_ptr<DataSourceItem> m_Root;
+                QSortFilterProxyModel m_model_proxy;
-            private slots:
-                /// Slot called when the filtering text has changed
-                void filterChanged(const QString &text) noexcept;
-                /// 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/include/SqpApplication.h +3 -1

             #define sqpApp (static_cast<SqpApplication*>(QCoreApplication::instance()))
             class DataSourceController;
+            class DataSources;
             class NetworkController;
             class TimeController;
             class VariableController;
                 void initialize();
                 /// Accessors for the differents sciqlop controllers
-                DataSourceController& dataSourceController() noexcept;
+                //DataSourceController& dataSourceController() noexcept;
+                DataSources& dataSources() noexcept;
                 NetworkController& networkController() noexcept;
                 TimeController& timeController() noexcept;
                 VariableController2& variableController() noexcept;

gui/meson.build 0 -6

              './include/DragAndDrop/DragDropScroller.h',
              './include/Settings/SqpSettingsDialog.h',
              './include/Settings/SqpSettingsGeneralWidget.h',
-             './include/DataSource/DataSourceTreeWidgetHelper.h',
-             './include/DataSource/DataSourceTreeWidget.h',
-             './include/DataSource/DataSourceTreeWidgetItem.h',
              './include/DataSource/DataSourceWidget.h',
              './include/Catalogue2/repositoriestreeview.h',
              './include/Catalogue2/browser.h',
              './src/DragAndDrop/DragDropGuiController.cpp',
              './src/Settings/SqpSettingsGeneralWidget.cpp',
              './src/Settings/SqpSettingsDialog.cpp',
-             './src/DataSource/DataSourceTreeWidgetItem.cpp',
-             './src/DataSource/DataSourceTreeWidgetHelper.cpp',
              './src/DataSource/DataSourceWidget.cpp',
-             './src/DataSource/DataSourceTreeWidget.cpp',
              './src/Catalogue2/eventstreeview.cpp',
              './src/Catalogue2/eventeditor.cpp',
              './src/Catalogue2/repositoriestreeview.cpp',

gui/src/DataSource/DataSourceWidget.cpp +10 -92

@@ -2,11 +2,10
2		2
3	#include <ui_DataSourceWidget.h>	3	#include <ui_DataSourceWidget.h>
4		4
5	#include <DataSource/~~DataSourceItem~~.h>	5	#include <DataSource/datasources.h>
6	#include <DataSource/DataSourceTreeWidgetHelper.h>	6
7	#include <DataSource/DataSourceTreeWidgetItem.h>	7	#include <SqpApplication.h>
8		8
9	#include <QMenu>
10		9
11	namespace	10	namespace
12	{	11	{
@@ -17,47 +16,23 const auto TREE_NB_COLUMNS = 1;
17	/// Header labels for the tree	16	/// Header labels for the tree
18	const auto TREE_HEADER_LABELS = QStringList { QObject::tr("Name") };	17	const auto TREE_HEADER_LABELS = QStringList { QObject::tr("Name") };
19		18
20	/**
21	* Creates the item associated to a data source
22	* @param dataSource the data source for which to create the item
23	* @return the new item
24	*/
25	DataSourceTreeWidgetItem* createTreeWidgetItem(DataSourceItem* dataSource)
26	{
27	// Creates item for the data source
28	auto item = new DataSourceTreeWidgetItem { dataSource };
29	// Generates items for the children of the data source
30	std::for_each(dataSource->cbegin(), dataSource->cend(),
31	[&item](const std::unique_ptr<DataSourceItem>& child) {
32	item->addChild(createTreeWidgetItem(child.get()));
33	});
34	return item;
35	}
36
37	} // namespace	19	} // namespace
38		20
39	DataSourceWidget::DataSourceWidget(QWidget* parent)	21	DataSourceWidget::DataSourceWidget(QWidget* parent)
40	: QWidget { parent }	22	: QWidget { parent }
41	, ui { new Ui::DataSourceWidget }	23	, ui { new Ui::DataSourceWidget }
42	, m_Root { std::make_unique<DataSourceItem>(
43	DataSourceItemType::NODE, QStringLiteral("Sources")) }
44	{	24	{
45	ui->setupUi(this);	25	ui->setupUi(this);
46		26	m_model_proxy.setSourceModel(&(sqpApp->dataSources()));
47	// Set tree properties	27	ui->treeView->setModel(&m_model_proxy);
48	ui->treeWidget->setColumnCount(TREE_NB_COLUMNS);	28	ui->treeView->setDragEnabled(true);
49	ui->treeWidget->setHeaderLabels(TREE_HEADER_LABELS);	29	m_model_proxy.setFilterRole(Qt::ToolTipRole);
50	ui->treeWidget->setContextMenuPolicy(Qt::CustomContextMenu);	30	m_model_proxy.setRecursiveFilteringEnabled(true);
51
52	// Connection to show a menu when right clicking on the tree
53	connect(ui->treeWidget, &QTreeWidget::customContextMenuRequested, this,
54	&DataSourceWidget::onTreeMenuRequested);
55		31
56	// Connection to filter tree	32	// Connection to filter tree
57	connect(ui->filterLineEdit, &QLineEdit::textChanged, ~~this~~, &~~DataSourceWidget~~::~~filterChanged~~);	33	connect(ui->filterLineEdit, &QLineEdit::textChanged, &m_model_proxy, static_cast<void (QSortFilterProxyModel::*)(const QString&)>(
		34	&QSortFilterProxyModel::setFilterRegExp));
58		35
59	// First init
60	updateTreeWidget();
61	}	36	}
62		37
63	DataSourceWidget::~DataSourceWidget() noexcept	38	DataSourceWidget::~DataSourceWidget() noexcept
@@ -65,60 +40,3 DataSourceWidget::~DataSourceWidget() noexcept
65	delete ui;	40	delete ui;
66	}	41	}
67		42
68	void DataSourceWidget::addDataSource(DataSourceItem* dataSource) noexcept
69	{
70	// Merges the data source (without taking its root)
71	if (dataSource)
72	{
73	std::for_each(std::cbegin(dataSource), std::cend(dataSource),
74	[this](const auto& child) { this->m_Root->merge(*child.get()); });
75	updateTreeWidget();
76	}
77	}
78
79	void DataSourceWidget::updateTreeWidget() noexcept
80	{
81	ui->treeWidget->clear();
82
83	auto rootItem = createTreeWidgetItem(m_Root.get());
84	ui->treeWidget->addTopLevelItem(rootItem);
85	rootItem->setExpanded(true);
86
87	// Sorts tree
88	ui->treeWidget->setSortingEnabled(true);
89	ui->treeWidget->sortByColumn(0, Qt::AscendingOrder);
90	}
91
92	void DataSourceWidget::filterChanged(const QString& text) noexcept
93	{
94	auto validateItem = [&text](const DataSourceTreeWidgetItem& item) {
95	auto regExp = QRegExp { text, Qt::CaseInsensitive, QRegExp::Wildcard };
96
97	// An item is valid if any of its metadata validates the text filter
98	auto itemMetadata = item.data()->data();
99	auto itemMetadataEnd = itemMetadata.cend();
100	auto acceptFilter
101	= [&regExp](const auto& variant) { return variant.toString().contains(regExp); };
102
103	return std::find_if(itemMetadata.cbegin(), itemMetadataEnd, acceptFilter)
104	!= itemMetadataEnd;
105	};
106
107	// Applies filter on tree widget
108	DataSourceTreeWidgetHelper::filter(*ui->treeWidget, validateItem);
109	}
110
111	void DataSourceWidget::onTreeMenuRequested(const QPoint& pos) noexcept
112	{
113	// Retrieves the selected item in the tree, and build the menu from its actions
114	if (auto selectedItem = dynamic_cast<DataSourceTreeWidgetItem*>(ui->treeWidget->itemAt(pos)))
115	{
116	QMenu treeMenu {};
117	treeMenu.addActions(selectedItem->actions());
118
119	if (!treeMenu.isEmpty())
120	{
121	treeMenu.exec(QCursor::pos());
122	}
123	}
124	}

gui/src/DragAndDrop/DragDropGuiController.cpp +6 -7

             #include "Visualization/VisualizationWidget.h"
             #include "Visualization/operations/FindVariableOperation.h"
-            #include "DataSource/DataSourceController.h"
             #include "Variable/VariableController2.h"
-            #include "Common/MimeTypesDef.h"
+            #include "MimeTypes/MimeTypes.h"
             #include "Common/VisualizationDef.h"
             #include <QDir>
                 auto result = false;
-                if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST))
+                if (mimeData->hasFormat(MIME::MIME_TYPE_VARIABLE_LIST))
                 {
                     auto variables = sqpApp->variableController().variables(
-                        Variable2::IDs(mimeData->data(MIME_TYPE_VARIABLE_LIST)));
+                        Variable2::IDs(mimeData->data(MIME::MIME_TYPE_VARIABLE_LIST)));
                     if (variables.size() == 1)
                     {
                         // result = false: cannot drop multiple variables in the visualisation
                     }
                 }
-                else if (mimeData->hasFormat(MIME_TYPE_PRODUCT_LIST))
+                else if (mimeData->hasFormat(MIME::MIME_TYPE_PRODUCT_LIST))
                 {
-                    auto productDataList = sqpApp->dataSourceController().productsDataForMimeData(
+                    auto productDataList = MIME::decode(
-                        mimeData->data(MIME_TYPE_PRODUCT_LIST));
+                        mimeData->data(MIME::MIME_TYPE_PRODUCT_LIST));
                     if (productDataList.count() == 1)
                     {
                         result = true;

gui/src/SqpApplication.cpp +11 -16

             #include <Actions/ActionsGuiController.h>
             #include <Catalogue/CatalogueController.h>
             #include <Data/IDataProvider.h>
-            #include <DataSource/DataSourceController.h>
+            #include <DataSource/datasources.h>
             #include <DragAndDrop/DragDropGuiController.h>
             #include <Network/NetworkController.h>
             #include <QThread>
                     // /////////////////////////////// //
                     // VariableController <-> DataSourceController
-                    connect(&m_DataSourceController, &DataSourceController::createVariable,
+                    connect(&m_DataSources, static_cast<void (DataSources::*)(const QString&, const QVariantHash&,
+                            std::shared_ptr<IDataProvider>)>(&DataSources::createVariable),
                         [](const QString& variableName, const QVariantHash& variableMetadata,
                             std::shared_ptr<IDataProvider> variableProvider) {
                             sqpApp->variableController().createVariable(variableName, variableMetadata,
                         });
-                    m_DataSourceController.moveToThread(&m_DataSourceControllerThread);
-                    m_DataSourceControllerThread.setObjectName("DataSourceControllerThread");
                     m_NetworkController.moveToThread(&m_NetworkControllerThread);
                     m_NetworkControllerThread.setObjectName("NetworkControllerThread");
                 virtual ~SqpApplicationPrivate()
                 {
-                    m_DataSourceControllerThread.quit();
-                    m_DataSourceControllerThread.wait();
                     m_NetworkControllerThread.quit();
                     m_NetworkControllerThread.wait();
                 }
-                DataSourceController m_DataSourceController;
+                DataSources m_DataSources;
                 std::shared_ptr<VariableController2> m_VariableController;
                 TimeController m_TimeController;
                 NetworkController m_NetworkController;
                 CatalogueController m_CatalogueController;
-                QThread m_DataSourceControllerThread;
                 QThread m_NetworkControllerThread;
                 DragDropGuiController m_DragDropGuiController;
                 QGuiApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
-                connect(&impl->m_DataSourceControllerThread, &QThread::started, &impl->m_DataSourceController,
-                    &DataSourceController::initialize);
-                connect(&impl->m_DataSourceControllerThread, &QThread::finished, &impl->m_DataSourceController,
-                    &DataSourceController::finalize);
                 connect(&impl->m_NetworkControllerThread, &QThread::started, &impl->m_NetworkController,
                     &NetworkController::initialize);
                 connect(&impl->m_NetworkControllerThread, &QThread::finished, &impl->m_NetworkController,
                     &NetworkController::finalize);
-                impl->m_DataSourceControllerThread.start();
                 impl->m_NetworkControllerThread.start();
             }
             void SqpApplication::initialize() {}
-            DataSourceController& SqpApplication::dataSourceController() noexcept
+            //DataSourceController& SqpApplication::dataSourceController() noexcept
+            //{
+            //    return impl->m_DataSourceController;
+            //}
+            DataSources& SqpApplication::dataSources() noexcept
             {
-                return impl->m_DataSourceController;
+                return impl->m_DataSources;
             }
             NetworkController& SqpApplication::networkController() noexcept

gui/src/TimeWidget/TimeWidget.cpp +5 -5

             #include "ui_TimeWidget.h"
             #include <Common/DateUtils.h>
-            #include <Common/MimeTypesDef.h>
+            #include <MimeTypes/MimeTypes.h>
             #include <DragAndDrop/DragDropGuiController.h>
             #include <SqpApplication.h>
             void TimeWidget::dragEnterEvent(QDragEnterEvent* event)
             {
-                if (event->mimeData()->hasFormat(MIME_TYPE_TIME_RANGE))
+                if (event->mimeData()->hasFormat(MIME::MIME_TYPE_TIME_RANGE))
                 {
                     event->acceptProposedAction();
                     setStyleSheet("QDateTimeEdit{background-color: #BBD5EE; border:2px solid #2A7FD4}");
             void TimeWidget::dropEvent(QDropEvent* event)
             {
-                if (event->mimeData()->hasFormat(MIME_TYPE_TIME_RANGE))
+                if (event->mimeData()->hasFormat(MIME::MIME_TYPE_TIME_RANGE))
                 {
-                    auto mimeData = event->mimeData()->data(MIME_TYPE_TIME_RANGE);
+                    auto mimeData = event->mimeData()->data(MIME::MIME_TYPE_TIME_RANGE);
                     auto timeRange = TimeController::timeRangeForMimeData(mimeData);
                     setTimeRange(timeRange);
                 auto mimeData = new QMimeData;
                 auto timeData = TimeController::mimeDataForTimeRange(timeRange());
-                mimeData->setData(MIME_TYPE_TIME_RANGE, timeData);
+                mimeData->setData(MIME::MIME_TYPE_TIME_RANGE, timeData);
                 drag->setMimeData(mimeData);

gui/src/Variable/VariableInspectorWidget.cpp +3 -3

-            #include <DataSource/DataSourceController.h>
+            #include <DataSource/datasources.h>
             #include <Variable/RenameVariableDialog.h>
             #include <Variable/VariableController2.h>
             #include <Variable/VariableInspectorWidget.h>
                 m_model = new VariableModel2();
                 ui->tableView->setModel(m_model);
-                connect(m_model, &VariableModel2::createVariable, [](const QVariantHash& productData) {
+                connect(m_model, &VariableModel2::createVariable, [](const QString& productPath) {
-                    sqpApp->dataSourceController().requestVariable(productData);
+                    sqpApp->dataSources().createVariable(productPath);
                 });
                 auto vc = &(sqpApp->variableController());
                 connect(vc, &VariableController2::variableAdded, m_model, &VariableModel2::variableAdded);

gui/src/Visualization/VisualizationGraphWidget.cpp +5 -5

             #include <Actions/ActionsGuiController.h>
             #include <Actions/FilteringAction.h>
-            #include <Common/MimeTypesDef.h>
+            #include <MimeTypes/MimeTypes.h>
             #include <cpp_utils_qt/cpp_utils_qt.hpp>
             #include <containers/algorithms.hpp>
             #include <Data/DateTimeRangeHelper.h>
                 if (sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones
                     && selectionZoneItemUnderCursor)
                 {
-                    mimeData->setData(MIME_TYPE_TIME_RANGE,
+                    mimeData->setData(MIME::MIME_TYPE_TIME_RANGE,
                         TimeController::mimeDataForTimeRange(selectionZoneItemUnderCursor->range()));
-                    mimeData->setData(MIME_TYPE_SELECTION_ZONE,
+                    mimeData->setData(MIME::MIME_TYPE_SELECTION_ZONE,
                         TimeController::mimeDataForTimeRange(selectionZoneItemUnderCursor->range()));
                 }
                 else
                 {
-                    mimeData->setData(MIME_TYPE_GRAPH, QByteArray {});
+                    mimeData->setData(MIME::MIME_TYPE_GRAPH, QByteArray {});
                     auto timeRangeData = TimeController::mimeDataForTimeRange(graphRange());
-                    mimeData->setData(MIME_TYPE_TIME_RANGE, timeRangeData);
+                    mimeData->setData(MIME::MIME_TYPE_TIME_RANGE, timeRangeData);
                 }
                 return mimeData;

gui/src/Visualization/VisualizationTabWidget.cpp +16 -16

             #include "Visualization/MacScrollBarStyle.h"
-            #include "DataSource/DataSourceController.h"
+            #include "DataSource/datasources.h"
             #include "Variable/VariableController2.h"
-            #include "Common/MimeTypesDef.h"
+            #include "MimeTypes/MimeTypes.h"
             #include "DragAndDrop/DragDropGuiController.h"
             #include "SqpApplication.h"
                 ui->dragDropContainer->layout()->setContentsMargins(0, 0, 0, 12);
                 ui->dragDropContainer->layout()->setSpacing(0);
                 ui->dragDropContainer->setMimeType(
-                    MIME_TYPE_GRAPH, VisualizationDragDropContainer::DropBehavior::Inserted);
+                    MIME::MIME_TYPE_GRAPH, VisualizationDragDropContainer::DropBehavior::Inserted);
                 ui->dragDropContainer->setMimeType(
-                    MIME_TYPE_ZONE, VisualizationDragDropContainer::DropBehavior::Inserted);
+                    MIME::MIME_TYPE_ZONE, VisualizationDragDropContainer::DropBehavior::Inserted);
                 ui->dragDropContainer->setMimeType(
-                    MIME_TYPE_VARIABLE_LIST, VisualizationDragDropContainer::DropBehavior::Inserted);
+                    MIME::MIME_TYPE_VARIABLE_LIST, VisualizationDragDropContainer::DropBehavior::Inserted);
                 ui->dragDropContainer->setMimeType(
-                    MIME_TYPE_PRODUCT_LIST, VisualizationDragDropContainer::DropBehavior::Inserted);
+                    MIME::MIME_TYPE_PRODUCT_LIST, VisualizationDragDropContainer::DropBehavior::Inserted);
                 ui->dragDropContainer->setAcceptMimeDataFunction([this](auto mimeData) {
                     return sqpApp->dragDropGuiController().checkMimeDataForVisualization(
             void VisualizationTabWidget::dropMimeData(int index, const QMimeData* mimeData)
             {
-                if (mimeData->hasFormat(MIME_TYPE_GRAPH))
+                if (mimeData->hasFormat(MIME::MIME_TYPE_GRAPH))
                 {
                     impl->dropGraph(index, this);
                 }
-                else if (mimeData->hasFormat(MIME_TYPE_ZONE))
+                else if (mimeData->hasFormat(MIME::MIME_TYPE_ZONE))
                 {
                     impl->dropZone(index, this);
                 }
-                else if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST))
+                else if (mimeData->hasFormat(MIME::MIME_TYPE_VARIABLE_LIST))
                 {
                     auto variables = sqpApp->variableController().variables(
-                        Variable2::IDs(mimeData->data(MIME_TYPE_VARIABLE_LIST)));
+                        Variable2::IDs(mimeData->data(MIME::MIME_TYPE_VARIABLE_LIST)));
                     impl->dropVariables(variables, index, this);
                 }
-                else if (mimeData->hasFormat(MIME_TYPE_PRODUCT_LIST))
+                else if (mimeData->hasFormat(MIME::MIME_TYPE_PRODUCT_LIST))
                 {
-                    auto productsData = sqpApp->dataSourceController().productsDataForMimeData(
+                    auto productsData = MIME::decode(
-                        mimeData->data(MIME_TYPE_PRODUCT_LIST));
+                        mimeData->data(MIME::MIME_TYPE_PRODUCT_LIST));
                     impl->dropProducts(productsData, index, this);
                 }
                 else
                     },
                     Qt::QueuedConnection);
-                auto productData = productsMetaData.first().toHash();
+                auto productPath = productsMetaData.first().toString();
-                QMetaObject::invokeMethod(&sqpApp->dataSourceController(), "requestVariable",
+                QMetaObject::invokeMethod(&sqpApp->dataSources(), "createVariable",
-                    Qt::QueuedConnection, Q_ARG(QVariantHash, productData));
+                                          Qt::QueuedConnection, Q_ARG(QString, productPath));
             }

gui/src/Visualization/VisualizationZoneWidget.cpp +32 -32

             #include "Visualization/VisualizationWidget.h"
             #include "ui_VisualizationZoneWidget.h"
-            #include "Common/MimeTypesDef.h"
+            #include "MimeTypes/MimeTypes.h"
             #include "Common/VisualizationDef.h"
             #include <Data/DateTimeRange.h>
             #include <Data/DateTimeRangeHelper.h>
-            #include <DataSource/DataSourceController.h>
+            #include <DataSource/datasources.h>
             #include <Time/TimeController.h>
             #include <Variable/Variable2.h>
             #include <Variable/VariableController2.h>
                 ui->dragDropContainer->setPlaceHolderType(DragDropGuiController::PlaceHolderType::Graph);
                 ui->dragDropContainer->setMimeType(
-                    MIME_TYPE_GRAPH, VisualizationDragDropContainer::DropBehavior::Inserted);
+                    MIME::MIME_TYPE_GRAPH, VisualizationDragDropContainer::DropBehavior::Inserted);
                 ui->dragDropContainer->setMimeType(
-                    MIME_TYPE_VARIABLE_LIST, VisualizationDragDropContainer::DropBehavior::InsertedAndMerged);
+                    MIME::MIME_TYPE_VARIABLE_LIST, VisualizationDragDropContainer::DropBehavior::InsertedAndMerged);
                 ui->dragDropContainer->setMimeType(
-                    MIME_TYPE_PRODUCT_LIST, VisualizationDragDropContainer::DropBehavior::InsertedAndMerged);
+                    MIME::MIME_TYPE_PRODUCT_LIST, VisualizationDragDropContainer::DropBehavior::InsertedAndMerged);
                 ui->dragDropContainer->setMimeType(
-                    MIME_TYPE_TIME_RANGE, VisualizationDragDropContainer::DropBehavior::Merged);
+                    MIME::MIME_TYPE_TIME_RANGE, VisualizationDragDropContainer::DropBehavior::Merged);
                 ui->dragDropContainer->setMimeType(
-                    MIME_TYPE_ZONE, VisualizationDragDropContainer::DropBehavior::Forbidden);
+                    MIME::MIME_TYPE_ZONE, VisualizationDragDropContainer::DropBehavior::Forbidden);
                 ui->dragDropContainer->setMimeType(
-                    MIME_TYPE_SELECTION_ZONE, VisualizationDragDropContainer::DropBehavior::Forbidden);
+                    MIME::MIME_TYPE_SELECTION_ZONE, VisualizationDragDropContainer::DropBehavior::Forbidden);
                 ui->dragDropContainer->setAcceptMimeDataFunction([this](auto mimeData) {
                     return sqpApp->dragDropGuiController().checkMimeDataForVisualization(
                         mimeData, ui->dragDropContainer);
                         return false;
                     }
-                    if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST))
+                    if (mimeData->hasFormat(MIME::MIME_TYPE_VARIABLE_LIST))
                     {
                         auto variables = sqpApp->variableController().variables(
-                            Variable2::IDs(mimeData->data(MIME_TYPE_VARIABLE_LIST)));
+                            Variable2::IDs(mimeData->data(MIME::MIME_TYPE_VARIABLE_LIST)));
                         if (variables.size() != 1)
                         {
                 Q_UNUSED(position);
                 auto mimeData = new QMimeData;
-                mimeData->setData(MIME_TYPE_ZONE, QByteArray {});
+                mimeData->setData(MIME::MIME_TYPE_ZONE, QByteArray {});
                 if (auto firstGraph = this->firstGraph())
                 {
                     auto timeRangeData = TimeController::mimeDataForTimeRange(firstGraph->graphRange());
-                    mimeData->setData(MIME_TYPE_TIME_RANGE, timeRangeData);
+                    mimeData->setData(MIME::MIME_TYPE_TIME_RANGE, timeRangeData);
                 }
                 return mimeData;
             void VisualizationZoneWidget::dropMimeData(int index, const QMimeData* mimeData)
             {
-                if (mimeData->hasFormat(MIME_TYPE_GRAPH))
+                if (mimeData->hasFormat(MIME::MIME_TYPE_GRAPH))
                 {
                     impl->dropGraph(index, this);
                 }
-                else if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST))
+                else if (mimeData->hasFormat(MIME::MIME_TYPE_VARIABLE_LIST))
                 {
                     auto variables = sqpApp->variableController().variables(
-                        Variable2::IDs(mimeData->data(MIME_TYPE_VARIABLE_LIST)));
+                        Variable2::IDs(mimeData->data(MIME::MIME_TYPE_VARIABLE_LIST)));
                     impl->dropVariables(variables, index, this);
                 }
-                else if (mimeData->hasFormat(MIME_TYPE_PRODUCT_LIST))
+                else if (mimeData->hasFormat(MIME::MIME_TYPE_PRODUCT_LIST))
                 {
-                    auto products = sqpApp->dataSourceController().productsDataForMimeData(
+                    auto products = MIME::decode(
-                        mimeData->data(MIME_TYPE_PRODUCT_LIST));
+                        mimeData->data(MIME::MIME_TYPE_PRODUCT_LIST));
                     impl->dropProducts(products, index, this);
                 }
                 else
                     return;
                 }
-                if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST))
+                if (mimeData->hasFormat(MIME::MIME_TYPE_VARIABLE_LIST))
                 {
                     auto variables = sqpApp->variableController().variables(
-                        Variable2::IDs(mimeData->data(MIME_TYPE_VARIABLE_LIST)));
+                        Variable2::IDs(mimeData->data(MIME::MIME_TYPE_VARIABLE_LIST)));
                     for (const auto& var : variables)
                     {
                         graphWidget->addVariable(var, graphWidget->graphRange());
                     }
                 }
-                else if (mimeData->hasFormat(MIME_TYPE_PRODUCT_LIST))
+                else if (mimeData->hasFormat(MIME::MIME_TYPE_PRODUCT_LIST))
                 {
-                    auto products = sqpApp->dataSourceController().productsDataForMimeData(
+                    auto products = MIME::decode(
-                        mimeData->data(MIME_TYPE_PRODUCT_LIST));
+                        mimeData->data(MIME::MIME_TYPE_PRODUCT_LIST));
                     auto context = new QObject { this };
-                    auto range = TimeController::timeRangeForMimeData(mimeData->data(MIME_TYPE_TIME_RANGE));
+                    auto range = TimeController::timeRangeForMimeData(mimeData->data(MIME::MIME_TYPE_TIME_RANGE));
                     // BTW this is really dangerous, this assumes the next created variable will be this one...
                     connect(&sqpApp->variableController(), &VariableController2::variableAdded, context,
                         [this, graphWidget, context, range](auto variable) {
                         },
                         Qt::QueuedConnection);
-                    auto productData = products.first().toHash();
+                    auto productPath = products.first().toString();
-                    QMetaObject::invokeMethod(&sqpApp->dataSourceController(), "requestVariable",
+                    QMetaObject::invokeMethod(&sqpApp->dataSources(), "createVariable",
-                        Qt::QueuedConnection, Q_ARG(QVariantHash, productData));
+                                              Qt::QueuedConnection, Q_ARG(QString, productPath));
                 }
-                else if (mimeData->hasFormat(MIME_TYPE_TIME_RANGE))
+                else if (mimeData->hasFormat(MIME::MIME_TYPE_TIME_RANGE))
                 {
-                    auto range = TimeController::timeRangeForMimeData(mimeData->data(MIME_TYPE_TIME_RANGE));
+                    auto range = TimeController::timeRangeForMimeData(mimeData->data(MIME::MIME_TYPE_TIME_RANGE));
                     graphWidget->setGraphRange(range, true, true);
                 }
                 else
                     },
                     Qt::QueuedConnection);
-                auto productData = productsData.first().toHash();
+                auto productPath = productsData.first().toString();
-                QMetaObject::invokeMethod(&sqpApp->dataSourceController(), "requestVariable",
+                QMetaObject::invokeMethod(&sqpApp->dataSources(), "createVariable",
-                    Qt::QueuedConnection, Q_ARG(QVariantHash, productData));
+                                          Qt::QueuedConnection, Q_ARG(QString, productPath));
             }

gui/ui/DataSource/DataSourceWidget.ui +1 -13

                 <widget class="QLineEdit" name="filterLineEdit"/>
                </item>
                <item row="1" column="0">
-                <widget class="DataSourceTreeWidget" name="treeWidget">
+                <widget class="QTreeView" name="treeView">
                  <property name="dragEnabled">
                   <bool>true</bool>
                  </property>
                  <property name="selectionMode">
                   <enum>QAbstractItemView::ExtendedSelection</enum>
                  </property>
-                 <column>
-                  <property name="text">
-                   <string notr="true">1</string>
-                  </property>
-                 </column>
                 </widget>
                </item>
               </layout>
              </widget>
-             <customwidgets>
-              <customwidget>
-               <class>DataSourceTreeWidget</class>
-               <extends>QTreeWidget</extends>
-               <header>DataSource/DataSourceTreeWidget.h</header>
-              </customwidget>
-             </customwidgets>
              <resources/>
              <connections/>
             </ui>

gui/include/DataSource/DataSourceTreeWidget.h removed 0 -15

	1	NO CONTENT: file was removed			NO CONTENT: file was removed

NO CONTENT: file was removed

gui/include/DataSource/DataSourceTreeWidgetHelper.h removed 0 -23

	1	NO CONTENT: file was removed			NO CONTENT: file was removed

NO CONTENT: file was removed

gui/include/DataSource/DataSourceTreeWidgetItem.h removed 0 -37

	1	NO CONTENT: file was removed			NO CONTENT: file was removed

NO CONTENT: file was removed

gui/src/DataSource/DataSourceTreeWidget.cpp removed 0 -47

	1	NO CONTENT: file was removed			NO CONTENT: file was removed

NO CONTENT: file was removed

gui/src/DataSource/DataSourceTreeWidgetHelper.cpp removed 0 -36

	1	NO CONTENT: file was removed			NO CONTENT: file was removed

NO CONTENT: file was removed

gui/src/DataSource/DataSourceTreeWidgetItem.cpp removed 0 -225

	1	NO CONTENT: file was removed			NO CONTENT: file was removed

NO CONTENT: file was removed

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