GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r862:e45b43f0766d

Drag of product

trabillard -

r862:e45b43f0766d

parent child

Context file:

r862:e45b43f0766d

gui/include/DataSource/DataSourceTreeWidget.h created 644 +14 0

@@ -0,0 +1,14
	1	#ifndef SCIQLOP_DATASOURCETREEWIDGET_H
	2	#define SCIQLOP_DATASOURCETREEWIDGET_H
	3
	4	#include <QTreeWidget>
	5
	6	class DataSourceTreeWidget : public QTreeWidget {
	7	public:
	8	DataSourceTreeWidget(QWidget *parent);
	9
	10	protected:
	11	QMimeData mimeData(const QList<QTreeWidgetItem > items) const override;
	12	};
	13
	14	#endif // SCIQLOP_DATASOURCETREEWIDGET_H

gui/src/DataSource/DataSourceTreeWidget.cpp created 644 +38 0

@@ -0,0 +1,38
	1	#include "DataSource/DataSourceTreeWidget.h"
	2	#include "Common/MimeTypesDef.h"
	3	#include "DataSource/DataSourceItem.h"
	4	#include "DataSource/DataSourceTreeWidgetItem.h"
	5
	6	#include <QMimeData>
	7
	8	DataSourceTreeWidget::DataSourceTreeWidget(QWidget *parent) : QTreeWidget(parent) {}
	9
	10	QMimeData DataSourceTreeWidget::mimeData(const QList<QTreeWidgetItem > items) const
	11	{
	12	auto mimeData = new QMimeData;
	13
	14	// Basic check to ensure the item are correctly typed
	15	Q_ASSERT(items.isEmpty() \|\| dynamic_cast<DataSourceTreeWidgetItem *>(items.first()) != nullptr);
	16
	17	QVariantList productData;
	18
	19	for (auto item : items) {
	20	auto dataSourceTreeItem = static_cast<DataSourceTreeWidgetItem *>(item);
	21	auto dataSource = dataSourceTreeItem->data();
	22
	23	if (dataSource->type() == DataSourceItemType::COMPONENT
	24	\|\| dataSource->type() == DataSourceItemType::PRODUCT) {
	25	auto metaData = dataSource->data();
	26	productData << metaData;
	27	}
	28	}
	29
	30	QByteArray encodedData;
	31	QDataStream stream(&encodedData, QIODevice::WriteOnly);
	32
	33	stream << productData;
	34
	35	mimeData->setData(MIME_TYPE_PRODUCT_LIST, encodedData);
	36
	37	return mimeData;
	38	}

core/include/Common/MimeTypesDef.h +1 0

             #ifndef SCIQLOP_MIMETYPESDEF_H
             #define SCIQLOP_MIMETYPESDEF_H
             #include "CoreGlobal.h"
             #include <QString>
             // ////////////////// //
             // SciQlop Mime Types //
             // ////////////////// //
             extern SCIQLOP_CORE_EXPORT const QString MIME_TYPE_GRAPH;
             extern SCIQLOP_CORE_EXPORT const QString MIME_TYPE_ZONE;
             extern SCIQLOP_CORE_EXPORT const QString MIME_TYPE_VARIABLE_LIST;
+            extern SCIQLOP_CORE_EXPORT const QString MIME_TYPE_PRODUCT_LIST;
             extern SCIQLOP_CORE_EXPORT const QString MIME_TYPE_TIME_RANGE;
             #endif // SCIQLOP_MIMETYPESDEF_H

core/meson.build +2 0

             core_moc_headers = [
               'include/Data/IDataProvider.h',
               'include/DataSource/DataSourceController.h',
               'include/DataSource/DataSourceItemAction.h',
+              'include/DataSource/DataSourceWidget.h',
               'include/Network/NetworkController.h',
               'include/Time/TimeController.h',
               'include/Variable/Variable.h',
               'include/Variable/VariableCacheController.h',
               'include/Variable/VariableController.h',
               'include/Variable/VariableAcquisitionWorker.h',
               'include/Variable/VariableCacheStrategy.h',
               'include/Variable/VariableSynchronizationGroup.h',
               'include/Variable/VariableModel.h',
               'include/Visualization/VisualizationController.h'
             ]
             core_moc_files = qt5.preprocess(moc_headers : core_moc_headers)
             core_sources = [
               'src/Common/DateUtils.cpp',
               'src/Common/StringUtils.cpp',
               'src/Common/MimeTypesDef.cpp',
               'src/Data/ScalarSeries.cpp',
               'src/Data/DataSeriesIterator.cpp',
               'src/Data/ArrayDataIterator.cpp',
               'src/Data/VectorSeries.cpp',
               'src/DataSource/DataSourceController.cpp',
               'src/DataSource/DataSourceItem.cpp',
               'src/DataSource/DataSourceItemAction.cpp',
+              'src/DataSource/DataSourceWidget.cpp',
               'src/Network/NetworkController.cpp',
               'src/Plugin/PluginManager.cpp',
               'src/Settings/SqpSettingsDefs.cpp',
               'src/Time/TimeController.cpp',
               'src/Variable/Variable.cpp',
               'src/Variable/VariableCacheController.cpp',
               'src/Variable/VariableController.cpp',
               'src/Variable/VariableAcquisitionWorker.cpp',
               'src/Variable/VariableSynchronizationGroup.cpp',
               'src/Variable/VariableModel.cpp',
               'src/Visualization/VisualizationController.cpp'
             ]
             core_inc = include_directories(['include', '../plugin/include'])
             sciqlop_core_lib = library('sciqlopcore',
                                    core_sources,
                                    core_moc_files,
                                    cpp_args : '-DCORE_LIB',
                                    include_directories : core_inc,
                                    dependencies : [qt5core, qt5network],
                                    install : true
                                    )
             sciqlop_core = declare_dependency(link_with : sciqlop_core_lib,
                                             include_directories : core_inc,
                                             dependencies : [qt5core, qt5network])
             subdir('tests')

core/src/Common/MimeTypesDef.cpp +1 0

             #include "Common/MimeTypesDef.h"
             const QString MIME_TYPE_GRAPH = QStringLiteral("scqlop/graph");
             const QString MIME_TYPE_ZONE = QStringLiteral("scqlop/zone");
             const QString MIME_TYPE_VARIABLE_LIST = QStringLiteral("scqlop/var-list");
+            const QString MIME_TYPE_PRODUCT_LIST = QStringLiteral("scqlop/product-list");
             const QString MIME_TYPE_TIME_RANGE = QStringLiteral("scqlop/time-range");

gui/src/DataSource/DataSourceTreeWidgetItem.cpp +9 0

             #include <DataSource/DataSourceItem.h>
             #include <DataSource/DataSourceItemAction.h>
             #include <DataSource/DataSourceTreeWidgetItem.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 dataSource->isRoot() ? QIcon{":/icones/dataSourceRoot.png"}
                                                         : QIcon{":/icones/dataSourceNode.png"};
                         }
                         case DataSourceItemType::PRODUCT:
                             return QIcon{":/icones/dataSourceProduct.png"};
                         case DataSourceItemType::COMPONENT:
                             return QIcon{":/icones/dataSourceComponent.png"};
                         default:
                             // No action
                             break;
                     }
                     qCWarning(LOG_DataSourceTreeWidgetItem())
                         << QObject::tr("Can't set data source icon : unknown data source type");
                 }
                 else {
                     qCCritical(LOG_DataSourceTreeWidgetItem())
                         << QObject::tr("Can't set data source icon : the data source is null");
                 }
                 // Default cases
                 return QIcon{};
             }
             /// @return the tooltip text for a variant. The text depends on whether the data is a simple variant
             /// or a list of variants
             QString tooltipValue(const QVariant &variant) noexcept
             {
                 // If the variant is a list of variants, the text of the tooltip is of the form: {val1, val2,
                 // ...}
                 if (variant.canConvert<QVariantList>()) {
                     auto valueString = QStringLiteral("{");
                     auto variantList = variant.value<QVariantList>();
                     for (auto it = variantList.cbegin(), end = variantList.cend(); it != end; ++it) {
                         valueString.append(it->toString());
                         if (std::distance(it, end) != 1) {
                             valueString.append(", ");
                         }
                     }
                     valueString.append(QStringLiteral("}"));
                     return valueString;
                 }
                 else {
                     return variant.toString();
                 }
             }
             QString itemTooltip(const DataSourceItem *dataSource) noexcept
             {
                 // The tooltip displays all item's data
                 if (dataSource) {
                     auto result = QString{};
                     const auto &data = dataSource->data();
                     for (auto it = data.cbegin(), end = data.cend(); it != end; ++it) {
                         result.append(QString{"<b>%1:</b> %2<br/>"}.arg(it.key(), tooltipValue(it.value())));
                     }
                     return result;
                 }
                 else {
                     qCCritical(LOG_DataSourceTreeWidgetItem())
                         << QObject::tr("Can't set data source tooltip : the data source is null");
                     return QString{};
                 }
             }
             } // 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 and the tooltip depending on the data source
                 setIcon(0, itemIcon(impl->m_Data));
                 setToolTip(0, itemTooltip(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);
+                // Sets the flags of the items
+                auto flags = Qt::ItemIsSelectable | Qt::ItemIsEnabled;
+                if (data->type() == DataSourceItemType::COMPONENT
+                    || data->type() == DataSourceItemType::PRODUCT) {
+                    flags |= Qt::ItemIsDragEnabled;
+                }
+                setFlags(flags);
             }
             const DataSourceItem *DataSourceTreeWidgetItem::data() const
             {
                 return impl->m_Data;
             }
             QVariant DataSourceTreeWidgetItem::data(int column, int role) const
             {
                 if (role == Qt::DisplayRole) {
                     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;
             }

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

             <?xml version="1.0" encoding="UTF-8"?>
             <ui version="4.0">
              <class>DataSourceWidget</class>
              <widget class="QWidget" name="DataSourceWidget">
               <property name="geometry">
                <rect>
                 <x>0</x>
                 <y>0</y>
                 <width>400</width>
                 <height>300</height>
                </rect>
               </property>
               <property name="windowTitle">
                <string>Data sources</string>
               </property>
               <layout class="QGridLayout" name="gridLayout">
                <item row="0" column="0">
                 <widget class="QLineEdit" name="filterLineEdit"/>
                </item>
                <item row="1" column="0">
-                <widget class="QTreeWidget" name="treeWidget">
+                <widget class="DataSourceTreeWidget" name="treeWidget">
+                 <property name="dragEnabled">
+                  <bool>true</bool>
+                 </property>
+                 <property name="dragDropMode">
+                  <enum>QAbstractItemView::DragOnly</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/ui/Variable/VariableInspectorWidget.ui +3 0

             <?xml version="1.0" encoding="UTF-8"?>
             <ui version="4.0">
              <class>VariableInspectorWidget</class>
              <widget class="QWidget" name="VariableInspectorWidget">
               <property name="geometry">
                <rect>
                 <x>0</x>
                 <y>0</y>
                 <width>400</width>
                 <height>300</height>
                </rect>
               </property>
               <property name="windowTitle">
                <string>Variables</string>
               </property>
               <layout class="QGridLayout" name="gridLayout">
                <item row="0" column="0">
                 <widget class="QTableView" name="tableView">
+                 <property name="acceptDrops">
+                  <bool>true</bool>
+                 </property>
                  <property name="dragEnabled">
                   <bool>true</bool>
                  </property>
                  <property name="dragDropMode">
                   <enum>QAbstractItemView::DragDrop</enum>
                  </property>
                  <property name="sortingEnabled">
                   <bool>true</bool>
                  </property>
                  <attribute name="horizontalHeaderStretchLastSection">
                   <bool>true</bool>
                  </attribute>
                 </widget>
                </item>
               </layout>
              </widget>
              <resources/>
              <connections/>
             </ui>

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