From 5a50815a763fb421298a06a6d0380b8f5364e7cd 2018-08-16 13:00:17
From: Alexis Jeandet <alexis.jeandet@member.fsf.org>
Date: 2018-08-16 13:00:17
Subject: [PATCH] Quick variable model copied from existing one

Signed-off-by: Alexis Jeandet <alexis.jeandet@member.fsf.org>

---

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 573f29d..5398b04 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -80,6 +80,7 @@ FILE (GLOB_RECURSE core_SRCS
     ./include/Visualization/VisualizationController.h
     ./include/PluginManager/PluginManager.h
     ./include/Variable/VariableModel.h
+    ./include/Variable/VariableModel2.h
     ./include/Variable/VariableAcquisitionWorker.h
     ./include/Variable/VariableCacheStrategy.h
     ./include/Variable/VariableSynchronizationGroup.h
@@ -118,6 +119,7 @@ FILE (GLOB_RECURSE core_SRCS
     ./src/Variable/VariableController.cpp
     ./src/Variable/VariableController2.cpp
     ./src/Variable/VariableModel.cpp
+    ./src/Variable/VariableModel2.cpp
     ./src/Variable/VariableCacheController.cpp
     ./src/Variable/VariableSynchronizationGroup.cpp
     ./src/Variable/VariableSynchronizationGroup2.cpp
diff --git a/include/Variable/VariableController2.h b/include/Variable/VariableController2.h
index eae31e9..1d4409b 100644
--- a/include/Variable/VariableController2.h
+++ b/include/Variable/VariableController2.h
@@ -5,6 +5,7 @@
 #include <QObject>
 #include <QMutexLocker>
 #include <QUuid>
+#include <QByteArray>
 #include <QItemSelectionModel>
 #include <Common/spimpl.h>
 #include <Variable/Variable.h>
@@ -30,12 +31,13 @@ public:
     void deleteVariable(const std::shared_ptr<Variable>& variable);
     void changeRange(const std::shared_ptr<Variable>& variable, const DateTimeRange& r);
     void asyncChangeRange(const std::shared_ptr<Variable>& variable, const DateTimeRange& r);
-    const std::set<std::shared_ptr<Variable>> variables();
+    const std::vector<std::shared_ptr<Variable>> variables();
 
     bool isReady(const std::shared_ptr<Variable>& variable);
 
     void synchronize(const std::shared_ptr<Variable>& var, const std::shared_ptr<Variable>& with);
 
+    QByteArray mimeData(const std::vector<std::shared_ptr<Variable>> &variables) const;
 
 signals:
     void variableAdded(const std::shared_ptr<Variable>&);
diff --git a/include/Variable/VariableModel2.h b/include/Variable/VariableModel2.h
new file mode 100644
index 0000000..8ff9ccd
--- /dev/null
+++ b/include/Variable/VariableModel2.h
@@ -0,0 +1,62 @@
+#ifndef SCIQLOP_VARIABLEMODEL2_H
+#define SCIQLOP_VARIABLEMODEL2_H
+
+#include "CoreGlobal.h"
+
+#include <Data/DateTimeRange.h>
+
+#include <QAbstractTableModel>
+#include <QLoggingCategory>
+
+#include <Common/MetaTypes.h>
+#include <Common/spimpl.h>
+
+
+
+class IDataSeries;
+class Variable;
+class VariableController2;
+
+/**
+ * @brief The VariableModel class aims to hold the variables that have been created in SciQlop
+ */
+class SCIQLOP_CORE_EXPORT VariableModel2 : public QAbstractTableModel {
+    enum VariableRoles { ProgressRole = Qt::UserRole };
+    Q_OBJECT
+    std::shared_ptr<VariableController2> _variableController;
+public:
+    explicit VariableModel2(const std::shared_ptr<VariableController2>& variableController, QObject *parent = nullptr);
+
+    // /////////////////////////// //
+    // QAbstractTableModel methods //
+    // /////////////////////////// //
+
+    virtual int columnCount(const QModelIndex &parent = QModelIndex{}) const override;
+    virtual int rowCount(const QModelIndex &parent = QModelIndex{}) const override;
+    virtual QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
+    virtual QVariant headerData(int section, Qt::Orientation orientation,
+                                int role = Qt::DisplayRole) const override;
+    virtual Qt::ItemFlags flags(const QModelIndex &index) const override;
+
+    // ///////////////// //
+    // Drag&Drop methods //
+    // ///////////////// //
+
+    virtual Qt::DropActions supportedDropActions() const override;
+    virtual Qt::DropActions supportedDragActions() const override;
+    virtual QStringList mimeTypes() const override;
+    virtual QMimeData *mimeData(const QModelIndexList &indexes) const override;
+    virtual bool canDropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column,
+                                 const QModelIndex &parent) const override;
+    virtual bool dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column,
+                              const QModelIndex &parent) override;
+
+
+signals:
+
+private slots:
+    /// Slot called when data of a variable has been updated
+    void variableUpdated() noexcept;
+};
+
+#endif // SCIQLOP_VARIABLEMODEL2_H
diff --git a/src/Variable/VariableController2.cpp b/src/Variable/VariableController2.cpp
index 5817304..cf95e4c 100644
--- a/src/Variable/VariableController2.cpp
+++ b/src/Variable/VariableController2.cpp
@@ -2,6 +2,7 @@
 #include <QThreadPool>
 #include <QRunnable>
 #include <QObject>
+#include <QDataStream>
 
 #include "Variable/VariableController2.h"
 #include "Variable/VariableSynchronizationGroup2.h"
@@ -60,13 +61,13 @@ class VariableController2::VariableController2Private
             return _variables[variable];
         }
 
-        inline const std::set<std::shared_ptr<Variable>> variables()
+        inline const std::vector<std::shared_ptr<Variable>> variables()
         {
-            std::set<std::shared_ptr<Variable>> vars;
+            std::vector<std::shared_ptr<Variable>> vars;
             QReadLocker lock{&_lock};
             for(const auto  &var:_variables)
             {
-                vars.insert(var);
+                vars.push_back(var);
             }
             return  vars;
         }
@@ -288,7 +289,7 @@ public:
         _maps.synchronize(var, with);
     }
 
-    inline const std::set<std::shared_ptr<Variable>> variables()
+    inline const std::vector<std::shared_ptr<Variable>> variables()
     {
         return _maps.variables();
     }
@@ -331,7 +332,7 @@ void VariableController2::asyncChangeRange(const std::shared_ptr<Variable> &vari
     impl->asyncChangeRange(variable, r);
 }
 
-const std::set<std::shared_ptr<Variable> > VariableController2::variables()
+const std::vector<std::shared_ptr<Variable> > VariableController2::variables()
 {
     return impl->variables();
 }
@@ -345,3 +346,13 @@ void VariableController2::synchronize(const std::shared_ptr<Variable> &var, cons
 {
     impl->synchronize(var, with);
 }
+
+QByteArray VariableController2::mimeData(const std::vector<std::shared_ptr<Variable> > &variables) const
+{
+    auto encodedData = QByteArray{};
+    QDataStream stream{&encodedData, QIODevice::WriteOnly};
+    for (auto &var : variables) {
+        stream << var->ID().toByteArray();
+    }
+    return encodedData;
+}
diff --git a/src/Variable/VariableModel2.cpp b/src/Variable/VariableModel2.cpp
new file mode 100644
index 0000000..3e56000
--- /dev/null
+++ b/src/Variable/VariableModel2.cpp
@@ -0,0 +1,250 @@
+#include <Variable/Variable.h>
+#include <Variable/VariableController2.h>
+#include <Variable/VariableModel2.h>
+
+#include <Common/DateUtils.h>
+#include <Common/MimeTypesDef.h>
+#include <Common/StringUtils.h>
+
+#include <Data/IDataSeries.h>
+
+#include <DataSource/DataSourceController.h>
+#include <Time/TimeController.h>
+
+#include <QMimeData>
+#include <QSize>
+#include <QTimer>
+#include <unordered_map>
+
+namespace {
+
+// Column indexes
+const auto NAME_COLUMN = 0;
+const auto TSTART_COLUMN = 1;
+const auto TEND_COLUMN = 2;
+const auto NBPOINTS_COLUMN = 3;
+const auto UNIT_COLUMN = 4;
+const auto MISSION_COLUMN = 5;
+const auto PLUGIN_COLUMN = 6;
+const auto NB_COLUMNS = 7;
+
+// Column properties
+const auto DEFAULT_HEIGHT = 25;
+const auto DEFAULT_WIDTH = 100;
+
+struct ColumnProperties {
+    ColumnProperties(const QString &name = {}, int width = DEFAULT_WIDTH,
+                     int height = DEFAULT_HEIGHT)
+            : m_Name{name}, m_Width{width}, m_Height{height}
+    {
+    }
+
+    QString m_Name;
+    int m_Width;
+    int m_Height;
+};
+
+const auto COLUMN_PROPERTIES = QHash<int, ColumnProperties>{
+    {NAME_COLUMN, {QObject::tr("Name")}},      {TSTART_COLUMN, {QObject::tr("tStart"), 180}},
+    {TEND_COLUMN, {QObject::tr("tEnd"), 180}}, {NBPOINTS_COLUMN, {QObject::tr("Nb points")}},
+    {UNIT_COLUMN, {QObject::tr("Unit")}},      {MISSION_COLUMN, {QObject::tr("Mission")}},
+    {PLUGIN_COLUMN, {QObject::tr("Plugin")}}};
+
+QString uniqueName(const QString &defaultName,
+                   const std::vector<std::shared_ptr<Variable> > &variables)
+{
+    auto forbiddenNames = std::vector<QString>(variables.size());
+    std::transform(variables.cbegin(), variables.cend(), forbiddenNames.begin(),
+                   [](const auto &variable) { return variable->name(); });
+    auto uniqueName = StringUtils::uniqueName(defaultName, forbiddenNames);
+    Q_ASSERT(!uniqueName.isEmpty());
+
+    return uniqueName;
+}
+
+} // namespace
+
+
+
+VariableModel2::VariableModel2(const std::shared_ptr<VariableController2> &variableController, QObject *parent)
+    : QAbstractTableModel{parent}, _variableController{variableController}
+{
+}
+
+
+int VariableModel2::columnCount(const QModelIndex &parent) const
+{
+    Q_UNUSED(parent);
+
+    return NB_COLUMNS;
+}
+
+int VariableModel2::rowCount(const QModelIndex &parent) const
+{
+    Q_UNUSED(parent);
+    return static_cast<int>(_variableController->variables().size());
+}
+
+QVariant VariableModel2::data(const QModelIndex &index, int role) const
+{
+    if (!index.isValid()) {
+        return QVariant{};
+    }
+
+    if (index.row() < 0 || index.row() >= rowCount()) {
+        return QVariant{};
+    }
+
+    if (role == Qt::DisplayRole) {
+        if (auto variable = _variableController->variables()[index.row()]) {
+            switch (index.column()) {
+                case NAME_COLUMN:
+                    return variable->name();
+                case TSTART_COLUMN: {
+                    if(auto range = variable->realRange(); range.has_value())
+                        return  DateUtils::dateTime(range.value().m_TStart).toString(DATETIME_FORMAT);
+                    return QVariant{};
+                }
+                case TEND_COLUMN: {
+                    if(auto range = variable->realRange(); range.has_value())
+                        return  DateUtils::dateTime(range.value().m_TEnd).toString(DATETIME_FORMAT);
+                    return QVariant{};
+                }
+                case NBPOINTS_COLUMN:
+                    return variable->nbPoints();
+                case UNIT_COLUMN:
+                    return variable->metadata().value(QStringLiteral("units"));
+                case MISSION_COLUMN:
+                    return variable->metadata().value(QStringLiteral("mission"));
+                case PLUGIN_COLUMN:
+                    return variable->metadata().value(QStringLiteral("plugin"));
+                default:
+                    // No action
+                    break;
+            }
+        }
+    }
+    else if (role == VariableRoles::ProgressRole) {
+        return QVariant{};
+    }
+
+    return QVariant{};
+}
+
+QVariant VariableModel2::headerData(int section, Qt::Orientation orientation, int role) const
+{
+    if (role != Qt::DisplayRole && role != Qt::SizeHintRole) {
+        return QVariant{};
+    }
+
+    if (orientation == Qt::Horizontal) {
+        auto propertiesIt = COLUMN_PROPERTIES.find(section);
+        if (propertiesIt != COLUMN_PROPERTIES.cend()) {
+            // Role is either DisplayRole or SizeHintRole
+            return (role == Qt::DisplayRole)
+                       ? QVariant{propertiesIt->m_Name}
+                       : QVariant{QSize{propertiesIt->m_Width, propertiesIt->m_Height}};
+        }
+        else {
+            qWarning(LOG_VariableModel())
+                << tr("Can't get header data (unknown column %1)").arg(section);
+        }
+    }
+
+    return QVariant{};
+}
+
+Qt::ItemFlags VariableModel2::flags(const QModelIndex &index) const
+{
+    return QAbstractTableModel::flags(index) | Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled;
+}
+
+Qt::DropActions VariableModel2::supportedDropActions() const
+{
+    return Qt::CopyAction | Qt::MoveAction;
+}
+
+Qt::DropActions VariableModel2::supportedDragActions() const
+{
+    return Qt::CopyAction | Qt::MoveAction;
+}
+
+QStringList VariableModel2::mimeTypes() const
+{
+    return {MIME_TYPE_VARIABLE_LIST, MIME_TYPE_TIME_RANGE};
+}
+
+QMimeData *VariableModel2::mimeData(const QModelIndexList &indexes) const
+{
+    auto mimeData = new QMimeData;
+    std::vector<std::shared_ptr<Variable> > variables;
+
+    DateTimeRange firstTimeRange;
+    for (const auto &index : indexes) {
+        if (index.column() == 0) { // only the first column
+            auto variable = _variableController->variables()[index.row()];
+            if (variable.get() && index.isValid()) {
+
+                if (variables.size()==0) {
+                    // Gets the range of the first variable
+                    firstTimeRange = std::move(variable->range());
+                }
+                variables.push_back(variable);
+            }
+        }
+    }
+
+    auto variablesEncodedData = _variableController->mimeData(variables);
+    mimeData->setData(MIME_TYPE_VARIABLE_LIST, variablesEncodedData);
+
+    if (variables.size() == 1) {
+        // No time range MIME data if multiple variables are dragged
+        auto timeEncodedData = TimeController::mimeDataForTimeRange(firstTimeRange);
+        mimeData->setData(MIME_TYPE_TIME_RANGE, timeEncodedData);
+    }
+
+    return mimeData;
+}
+
+bool VariableModel2::canDropMimeData(const QMimeData *data, Qt::DropAction action, int row,
+                                    int column, const QModelIndex &parent) const
+{
+    // drop of a product
+    return data->hasFormat(MIME_TYPE_PRODUCT_LIST)
+           || (data->hasFormat(MIME_TYPE_TIME_RANGE) && parent.isValid()
+               && !data->hasFormat(MIME_TYPE_VARIABLE_LIST));
+}
+
+bool VariableModel2::dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column,
+                                 const QModelIndex &parent)
+{
+    auto dropDone = false;
+
+    if (data->hasFormat(MIME_TYPE_PRODUCT_LIST)) {
+        auto productList
+            = DataSourceController::productsDataForMimeData(data->data(MIME_TYPE_PRODUCT_LIST));
+
+        for (auto metaData : productList) {
+            //emit requestVariable(metaData.toHash());
+            //@TODO No idea what this does
+        }
+
+        dropDone = true;
+    }
+    else if (data->hasFormat(MIME_TYPE_TIME_RANGE) && parent.isValid()) {
+        auto variable = _variableController->variables()[parent.row()];
+        auto range = TimeController::timeRangeForMimeData(data->data(MIME_TYPE_TIME_RANGE));
+
+        _variableController->asyncChangeRange(variable, range);
+
+        dropDone = true;
+    }
+
+    return dropDone;
+}
+
+void VariableModel2::variableUpdated() noexcept
+{
+
+}
+