GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r884:e439cb403ff9

LPP's Code Repositories

0

- This repo
- ?
- Use '/' key to quickly access this field. - Enter a name of repository, or repository group for quick search. - Prefix query to allow special search: user:admin, to search for usernames, always global user_group:devops, to search for user groups, always global pr:303, to search for pull request number, title, or description, always global commit:efced4, to search for commits, scoped to repositories or groups file:models.py, to search for file paths, scoped to repositories or groups For advanced full text search visit: repository search
Home
Public journal
Gists
Sign in

GIT_REPOSITORIES » LPP » Users » mperrinel » SciQLop-fork

RSS

Fork of HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop

Drop of variable, graph and zones on the time widget

trabillard -

r884:e439cb403ff9

parent child

                   */
                  void loadProductItem(const QUuid &dataSourceUid, const DataSourceItem &productItem) noexcept;
-                 QByteArray mimeDataForProductsData(const QVariantList &productsData) const;
-                 QVariantList productsDataForMimeData(const QByteArray &mimeData) const;
+                 /// Returns the MIME data associated to a list of product meta data
+                 static QByteArray mimeDataForProductsData(const QVariantList &productsData);
+                 /// Returns the list of meta data contained in a MIME data
+                 static QVariantList productsDataForMimeData(const QByteArray &mimeData);
              public slots:
                  /// Manage init/end of the controller

                  }
              }
-             QByteArray DataSourceController::mimeDataForProductsData(const QVariantList &productsData) const
+             QByteArray DataSourceController::mimeDataForProductsData(const QVariantList &productsData)
              {
                  QByteArray encodedData;
                  QDataStream stream{&encodedData, QIODevice::WriteOnly};
                  return encodedData;
              }
-             QVariantList DataSourceController::productsDataForMimeData(const QByteArray &mimeData) const
+             QVariantList DataSourceController::productsDataForMimeData(const QByteArray &mimeData)
              {
                  QDataStream stream{mimeData};

General Comments 3

trabillard

|

Pull request updated. Auto status change to "Under Review"

Changed commits:
  * 1 added
  * 0 removed

Changed files:
  * A core/tests/meson.build

Write
Preview

You need to be logged in to leave comments. Login now

	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

                  SqpRange dateTime() const noexcept;
+                 /// Returns the MIME data associated to a time range
+                 static QByteArray mimeDataForTimeRange(const SqpRange &timeRange);
+                 /// Returns the time range contained in a MIME data
+                 static SqpRange timeRangeForMimeData(const QByteArray &mimeData);
              signals:
                  /// Signal emitted to notify that time parameters has beed updated
                  void timeUpdated(SqpRange time);

                   */
                  void deleteVariables(const QVector<std::shared_ptr<Variable> > &variables) noexcept;
+                 /// Returns the MIME data associated to a list of variables
                  QByteArray mimeDataForVariables(const QList<std::shared_ptr<Variable> > &variables) const;
+                 /// Returns the list of variables contained in a MIME data
                  QList<std::shared_ptr<Variable> > variablesForMimeData(const QByteArray &mimeData) const;
                  static AcquisitionZoomType getZoomType(const SqpRange &range, const SqpRange &oldRange);

              #include "Time/TimeController.h"
+             #include <QDataStream>
              Q_LOGGING_CATEGORY(LOG_TimeController, "TimeController")
              struct TimeController::TimeControllerPrivate {
                  return impl->m_DateTime;
              }
+             QByteArray TimeController::mimeDataForTimeRange(const SqpRange &timeRange)
+             {
+                 QByteArray encodedData;
+                 QDataStream stream{&encodedData, QIODevice::WriteOnly};
+                 stream << timeRange.m_TStart << timeRange.m_TEnd;
+                 return encodedData;
+             }
+             SqpRange TimeController::timeRangeForMimeData(const QByteArray &mimeData)
+             {
+                 QDataStream stream{mimeData};
+                 SqpRange timeRange;
+                 stream >> timeRange.m_TStart >> timeRange.m_TEnd;
+                 return timeRange;
+             }
              void TimeController::onTimeToUpdate(SqpRange dateTime)
              {
                  impl->m_DateTime = dateTime;

              #include <Data/IDataSeries.h>
-             #include <QDataStream>
+             #include <DataSource/DataSourceController.h>
+             #include <Time/TimeController.h>
              #include <QMimeData>
              #include <QSize>
              #include <unordered_map>
              QStringList VariableModel::mimeTypes() const
              {
-                 return {MIME_TYPE_VARIABLE_LIST};
+                 return {MIME_TYPE_VARIABLE_LIST, MIME_TYPE_TIME_RANGE};
              }
              QMimeData *VariableModel::mimeData(const QModelIndexList &indexes) const
                  QList<std::shared_ptr<Variable> > variableList;
+                 SqpRange firstTimeRange;
                  for (const auto &index : indexes) {
                      if (index.column() == 0) { // only the first column
                          auto variable = impl->m_Variables.at(index.row());
                          if (variable.get() && index.isValid()) {
+                             if (variableList.isEmpty()) {
+                                 // Gets the range of the first variable
+                                 firstTimeRange = std::move(variable->range());
+                             }
                              variableList << variable;
                          }
                      }
                  }
-                 auto encodedData = impl->m_VariableController->mimeDataForVariables(variableList);
-                 mimeData->setData(MIME_TYPE_VARIABLE_LIST, encodedData);
+                 auto variablesEncodedData = impl->m_VariableController->mimeDataForVariables(variableList);
+                 mimeData->setData(MIME_TYPE_VARIABLE_LIST, variablesEncodedData);
+                 if (variableList.count() == 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;
              }
                  auto dropDone = false;
                  if (data->hasFormat(MIME_TYPE_PRODUCT_LIST)) {
-                     QDataStream stream(data->data(MIME_TYPE_PRODUCT_LIST));
-                     QVariantList productList;
-                     stream >> productList;
+                     auto productList
+                         = DataSourceController::productsDataForMimeData(data->data(MIME_TYPE_PRODUCT_LIST));
                      for (auto metaData : productList) {
                          emit requestVariable(metaData.toHash());

                  explicit TimeWidget(QWidget *parent = 0);
                  virtual ~TimeWidget();
+                 void setTimeRange(SqpRange time);
              signals:
                  /// Signal emitted when the time parameters has beed updated
                  void timeUpdated(SqpRange time);
                  /// slot called when time parameters update has ben requested
                  void onTimeUpdateRequested();
+             protected:
+                 void dragEnterEvent(QDragEnterEvent *event) override;
+                 void dragLeaveEvent(QDragLeaveEvent *event) override;
+                 void dropEvent(QDropEvent *event) override;
              private:
                  Ui::TimeWidget *ui;

              #include "ui_TimeWidget.h"
              #include <Common/DateUtils.h>
+             #include <Common/MimeTypesDef.h>
              #include <SqpApplication.h>
              #include <Time/TimeController.h>
+             #include <QDragEnterEvent>
+             #include <QDropEvent>
+             #include <QMimeData>
              TimeWidget::TimeWidget(QWidget *parent) : QWidget{parent}, ui{new Ui::TimeWidget}
              {
                  ui->setupUi(this);
                  delete ui;
              }
+             void TimeWidget::setTimeRange(SqpRange time)
+             {
+                 auto startDateTime = DateUtils::dateTime(time.m_TStart);
+                 auto endDateTime = DateUtils::dateTime(time.m_TEnd);
+                 ui->startDateTimeEdit->setDateTime(startDateTime);
+                 ui->endDateTimeEdit->setDateTime(endDateTime);
+             }
              void TimeWidget::onTimeUpdateRequested()
              {
                  auto dateTime = SqpRange{DateUtils::secondsSinceEpoch(ui->startDateTimeEdit->dateTime()),
                  emit timeUpdated(std::move(dateTime));
              }
+             void TimeWidget::dragEnterEvent(QDragEnterEvent *event)
+             {
+                 if (event->mimeData()->hasFormat(MIME_TYPE_TIME_RANGE)) {
+                     event->acceptProposedAction();
+                     setStyleSheet("QDateTimeEdit{background-color: #BBD5EE; border:2px solid #2A7FD4}");
+                 }
+                 else {
+                     event->ignore();
+                 }
+             }
+             void TimeWidget::dragLeaveEvent(QDragLeaveEvent *event)
+             {
+                 setStyleSheet(QString());
+             }
+             void TimeWidget::dropEvent(QDropEvent *event)
+             {
+                 if (event->mimeData()->hasFormat(MIME_TYPE_TIME_RANGE)) {
+                     auto mimeData = event->mimeData()->data(MIME_TYPE_TIME_RANGE);
+                     auto timeRange = TimeController::timeRangeForMimeData(mimeData);
+                     setTimeRange(timeRange);
+                 }
+                 else {
+                     event->ignore();
+                 }
+                 setStyleSheet(QString());
+             }

              #include <DragDropHelper.h>
              #include <Settings/SqpSettingsDefs.h>
              #include <SqpApplication.h>
+             #include <Time/TimeController.h>
              #include <Variable/Variable.h>
              #include <Variable/VariableController.h>
                  auto mimeData = new QMimeData;
                  mimeData->setData(MIME_TYPE_GRAPH, QByteArray{});
+                 auto timeRangeData = TimeController::mimeDataForTimeRange(graphRange());
+                 mimeData->setData(MIME_TYPE_TIME_RANGE, timeRangeData);
                  return mimeData;
              }

              #include "Common/VisualizationDef.h"
              #include <Data/SqpRange.h>
+             #include <Time/TimeController.h>
              #include <Variable/Variable.h>
              #include <Variable/VariableController.h>
                  QUuid m_SynchronisationGroupId;
                  std::unique_ptr<IGraphSynchronizer> m_Synchronizer;
+                 // Returns the first graph in the zone or nullptr if there is no graph inside
+                 VisualizationGraphWidget *firstGraph(const VisualizationZoneWidget *zoneWidget) const
+                 {
+                     VisualizationGraphWidget *firstGraph = nullptr;
+                     auto layout = zoneWidget->ui->dragDropContainer->layout();
+                     if (layout->count() > 0) {
+                         if (auto visualizationGraphWidget
+                             = qobject_cast<VisualizationGraphWidget *>(layout->itemAt(0)->widget())) {
+                             firstGraph = visualizationGraphWidget;
+                         }
+                     }
+                     return firstGraph;
+                 }
                  void dropGraph(int index, VisualizationZoneWidget *zoneWidget);
                  void dropVariables(const QList<std::shared_ptr<Variable> > &variables, int index,
                                     VisualizationZoneWidget *zoneWidget);
                          &VisualizationZoneWidget::onVariableAboutToBeRemoved);
                  auto range = SqpRange{};
-                 // Apply visitor to graph children
-                 auto layout = ui->dragDropContainer->layout();
-                 if (layout->count() > 0) {
+                 if (auto firstGraph = impl->firstGraph(this)) {
                      // Case of a new graph in a existant zone
-                     if (auto visualizationGraphWidget
-                         = dynamic_cast<VisualizationGraphWidget *>(layout->itemAt(0)->widget())) {
-                         range = visualizationGraphWidget->graphRange();
+                     }
+                     range = firstGraph->graphRange();
                  }
                  else {
                      // Case of a new graph as the first of the zone
                  auto mimeData = new QMimeData;
                  mimeData->setData(MIME_TYPE_ZONE, QByteArray{});
+                 if (const auto firstGraph = impl->firstGraph(this)) {
+                     auto timeRangeData = TimeController::mimeDataForTimeRange(firstGraph->graphRange());
+                     mimeData->setData(MIME_TYPE_TIME_RANGE, timeRangeData);
+                 }
                  return mimeData;
              }

                  <verstretch>0</verstretch>
                 </sizepolicy>
                </property>
+               <property name="acceptDrops">
+                <bool>true</bool>
+               </property>
                <property name="windowTitle">
                 <string>Form</string>
                </property>
+               <property name="styleSheet">
+                <string notr="true">b</string>
+               </property>
                <layout class="QHBoxLayout" name="horizontalLayout_2">
                 <item>
                  <widget class="QLabel" name="label">