GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r877:e6294435151a

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

                  void initialize();
                  void finalize();
+                 void requestVariable(const QVariantHash &productData);
              signals:
                  /// Signal emitted when a structure has been set for a data source
                  void dataSourceItemSet(DataSourceItem *dataSourceItem);

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

                  DataSourceItemType type() const noexcept;
+                 /**
+                  * @brief Searches the first child matching the specified data.
+                  * @param data The data to search.
+                  * @param recursive So the search recursively.
+                  * @return the item matching the data or nullptr if it was not found.
+                  */
+                 DataSourceItem *findItem(const QVariantHash &data, bool recursive);
                  bool operator==(const DataSourceItem &other);
                  bool operator!=(const DataSourceItem &other);

core/include/Variable/VariableModel.h +1 0

              signals:
                  void abortProgessRequested(std::shared_ptr<Variable> variable);
+                 void requestVariable(const QVariantHash &productData);
              private:
                  class VariableModelPrivate;

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

              #include <QMutex>
              #include <QThread>
+             #include <QDataStream>
              #include <QDir>
              #include <QStandardPaths>
                  /// @remarks Data providers are stored as shared_ptr as they can be sent to a variable and
                  /// continue to live without necessarily the data source controller
                  std::map<QUuid, std::shared_ptr<IDataProvider> > m_DataProviders;
+                 // Search for the first datasource item matching the specified data
+                 DataSourceItem *findDataSourceItem(const QVariantHash &data)
+                 {
+                     DataSourceItem *sourceItem = nullptr;
+                     for (const auto &item : m_DataSourceItems) {
+                         sourceItem = item.second->findItem(data, true);
+                         if (sourceItem) {
+                             break;
+                         }
+                     }
+                     return sourceItem;
+                 }
              };
              DataSourceController::DataSourceController(QObject *parent)
                  impl->m_WorkingMutex.unlock();
              }
+             void DataSourceController::requestVariable(const QVariantHash &productData)
+             {
+                 DataSourceItem *sourceItem = impl->findDataSourceItem(productData);
+                 if (sourceItem) {
+                     auto sourceName = sourceItem->rootItem().name();
+                     auto sourceId = impl->m_DataSources.key(sourceName);
+                     loadProductItem(sourceId, *sourceItem);
+                 }
+                 else {
+                     qCWarning(LOG_DataSourceController()) << tr("requestVariable, product data not found");
+                 }
+             }
              void DataSourceController::waitForFinish()
              {
                  QMutexLocker locker{&impl->m_WorkingMutex};

core/src/DataSource/DataSourceItem.cpp +18 0

                  return impl->m_Type;
              }
+             DataSourceItem *DataSourceItem::findItem(const QVariantHash &data, bool recursive)
+             {
+                 for (const auto &child : impl->m_Children) {
+                     if (child->impl->m_Data == data) {
+                         return child.get();
+                     }
+                     if (recursive) {
+                         auto foundItem = child->findItem(data, true);
+                         if (foundItem) {
+                             return foundItem;
+                         }
+                     }
+                 }
+                 return nullptr;
+             }
              bool DataSourceItem::operator==(const DataSourceItem &other)
              {
                  // Compares items' attributes

core/src/Variable/VariableModel.cpp +20 -3

              #include <Data/IDataSeries.h>
+             #include <QDataStream>
              #include <QMimeData>
              #include <QSize>
              #include <unordered_map>
              Qt::DropActions VariableModel::supportedDropActions() const
              {
-                 return Qt::MoveAction;
+                 return Qt::CopyAction | Qt::MoveAction;
              }
              Qt::DropActions VariableModel::supportedDragActions() const
              bool VariableModel::canDropMimeData(const QMimeData *data, Qt::DropAction action, int row,
                                                  int column, const QModelIndex &parent) const
              {
-                 return false;
+                 // drop of a product
+                 return data->hasFormat(MIME_TYPE_PRODUCT_LIST);
              }
              bool VariableModel::dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column,
                                               const QModelIndex &parent)
              {
-                 return false;
+                 bool dropDone = false;
+                 if (data->hasFormat(MIME_TYPE_PRODUCT_LIST)) {
+                     QDataStream stream(data->data(MIME_TYPE_PRODUCT_LIST));
+                     QVariantList productList;
+                     stream >> productList;
+                     for (auto metaData : productList) {
+                         emit requestVariable(metaData.toHash());
+                     }
+                     dropDone = true;
+                 }
+                 return dropDone;
              }
              void VariableModel::abortProgress(const QModelIndex &index)

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

                  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

gui/src/SqpApplication.cpp +4 0

              #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")
                              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>)),

gui/src/Visualization/VisualizationTabWidget.cpp +1 0

                          << tr("VisualizationTabWidget::dropVariables, dropping multiple variables, operation "
                                "aborted.");
                      return;
+                 }
                  tabWidget->createZone(variables, index);
              }

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

                      return;
                  }
-                 zoneWidget->createGraph({variable}, index);
+                 zoneWidget->createGraph(variables, index);
              }

gui/ui/Variable/VariableInspectorWidget.ui +3 0

                <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>

	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