HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r932:16999d8139e2

Merge pull request from SciQLop-fork develop...

leroux -

r932:16999d8139e2

parent child

Context file:

r932:16999d8139e2

Collapse all files

gui/include/Visualization/MacScrollBarStyle.h created 644 +18 0

@@ -0,0 +1,18
	1	#ifndef SCIQLOP_MACSCROLLBARSTYLE_H
	2	#define SCIQLOP_MACSCROLLBARSTYLE_H
	3
	4	#include <QProxyStyle>
	5
	6	/**
	7	* @brief Special style to always display the scrollbars on MAC.
	8	*/
	9	class MacScrollBarStyle : public QProxyStyle {
	10
	11	public:
	12	int styleHint(StyleHint hint, const QStyleOption option, const QWidget widget,
	13	QStyleHintReturn *returnData) const;
	14
	15	void selfInstallOn(QWidget *widget, bool installOnSubWidgets);
	16	};
	17
	18	#endif // SCIQLOP_MACSCROLLBARSTYLE_H

gui/src/Visualization/MacScrollBarStyle.cpp created 644 +40 0

@@ -0,0 +1,40
	1	#include "Visualization/MacScrollBarStyle.h"
	2
	3	#include <QWidget>
	4
	5	int MacScrollBarStyle::styleHint(QStyle::StyleHint hint, const QStyleOption *option,
	6	const QWidget widget, QStyleHintReturn returnData) const
	7	{
	8	switch (hint) {
	9	case SH_ScrollBar_Transient:
	10	return false; // Makes the scrollbar always visible
	11	case SH_ScrollView_FrameOnlyAroundContents:
	12	return true; // Avoid that the scrollbar is drawn on top of the widget
	13	default:
	14	break;
	15	}
	16
	17	return QProxyStyle::styleHint(hint, option, widget, returnData);
	18	}
	19
	20	void MacScrollBarStyle::selfInstallOn(QWidget *widget, bool installOnSubWidgets)
	21	{
	22	// Note: a style can be installed on a particular widget but it is not automatically applied its
	23	// children widgets.
	24
	25	QList<QWidget *> widgetsToStyle{widget};
	26	while (!widgetsToStyle.isEmpty()) {
	27
	28	auto widget = widgetsToStyle.takeFirst();
	29	widget->setStyle(this);
	30
	31	if (installOnSubWidgets) {
	32	for (auto child : widget->children()) {
	33	auto childWidget = qobject_cast<QWidget *>(child);
	34	if (childWidget) {
	35	widgetsToStyle << childWidget;
	36	}
	37	}
	38	}
	39	}
	40	}

gui/include/Visualization/AxisRenderingUtils.h +3 0

             #ifndef SCIQLOP_AXISRENDERINGUTILS_H
             #define SCIQLOP_AXISRENDERINGUTILS_H
             #include <memory>
+            #include <QtCore/QLoggingCategory>
             #include <QtCore/QString>
+            Q_DECLARE_LOGGING_CATEGORY(LOG_AxisRenderingUtils)
             class IDataSeries;
             class QCPAxis;
             class QCPColorScale;
             class QCustomPlot;
             /// Formats a data value according to the axis on which it is present
             QString formatValue(double value, const QCPAxis &axis);
             /**
              * Helper used to handle axes rendering
              */
             struct IAxisHelper {
                 virtual ~IAxisHelper() noexcept = default;
                 /// Set properties of the plot's axes and the color scale associated to plot passed as
                 /// parameters
                 /// @param plot the plot for which to set axe properties
                 /// @param colorScale the color scale for which to set properties
                 virtual void setProperties(QCustomPlot &plot, QCPColorScale &colorScale) = 0;
             };
             struct IAxisHelperFactory {
                 /// Creates IAxisHelper according to a data series
                 static std::unique_ptr<IAxisHelper> create(std::shared_ptr<IDataSeries> dataSeries) noexcept;
             };
             #endif // SCIQLOP_AXISRENDERINGUTILS_H

gui/include/Visualization/PlottablesRenderingUtils.h +4 0

             #ifndef SCIQLOP_PLOTTABLESRENDERINGUTILS_H
             #define SCIQLOP_PLOTTABLESRENDERINGUTILS_H
             #include <Visualization/VisualizationDefs.h>
             #include <memory>
+            #include <QtCore/QLoggingCategory>
+            Q_DECLARE_LOGGING_CATEGORY(LOG_PlottablesRenderingUtils)
             class IDataSeries;
             class QCPColorScale;
             class QCustomPlot;
             /**
              * Helper used to handle plottables rendering
              */
             struct IPlottablesHelper {
                 virtual ~IPlottablesHelper() noexcept = default;
                 /// Set properties of the plottables passed as parameter
                 /// @param plottables the plottables for which to set properties
                 virtual void setProperties(PlottablesMap &plottables) = 0;
             };
             struct IPlottablesHelperFactory {
                 /// Creates IPlottablesHelper according to a data series
                 static std::unique_ptr<IPlottablesHelper>
                 create(std::shared_ptr<IDataSeries> dataSeries) noexcept;
             };
             #endif // SCIQLOP_PLOTTABLESRENDERINGUTILS_H

gui/meson.build +3 -2

             gui_moc_headers = [
               'include/DataSource/DataSourceWidget.h',
               'include/DataSource/DataSourceTreeWidget.h',
               'include/Settings/SqpSettingsDialog.h',
               'include/Settings/SqpSettingsGeneralWidget.h',
               'include/SidePane/SqpSidePane.h',
               'include/SqpApplication.h',
               'include/DragAndDrop/DragDropHelper.h',
               'include/DragAndDrop/DragDropScroller.h',
               'include/DragAndDrop/DragDropTabSwitcher.h',
               'include/TimeWidget/TimeWidget.h',
               'include/Variable/VariableInspectorWidget.h',
               'include/Variable/VariableInspectorTableView.h',
               'include/Variable/RenameVariableDialog.h',
               'include/Visualization/qcustomplot.h',
               'include/Visualization/VisualizationGraphWidget.h',
               'include/Visualization/VisualizationTabWidget.h',
               'include/Visualization/VisualizationWidget.h',
               'include/Visualization/VisualizationZoneWidget.h',
               'include/Visualization/VisualizationDragDropContainer.h',
               'include/Visualization/VisualizationDragWidget.h'
             ]
             gui_ui_files = [
               'ui/DataSource/DataSourceWidget.ui',
               'ui/Settings/SqpSettingsDialog.ui',
               'ui/Settings/SqpSettingsGeneralWidget.ui',
               'ui/SidePane/SqpSidePane.ui',
               'ui/TimeWidget/TimeWidget.ui',
               'ui/Variable/VariableInspectorWidget.ui',
               'ui/Variable/RenameVariableDialog.ui',
               'ui/Variable/VariableMenuHeaderWidget.ui',
               'ui/Visualization/VisualizationGraphWidget.ui',
               'ui/Visualization/VisualizationTabWidget.ui',
               'ui/Visualization/VisualizationWidget.ui',
               'ui/Visualization/VisualizationZoneWidget.ui'
             ]
             gui_qresources = ['resources/sqpguiresources.qrc']
             gui_moc_files = qt5.preprocess(moc_headers : gui_moc_headers,
                                            ui_files : gui_ui_files,
                                            qresources : gui_qresources)
             gui_sources = [
               'src/SqpApplication.cpp',
               'src/DragAndDrop/DragDropHelper.cpp',
               'src/DragAndDrop/DragDropScroller.cpp',
               'src/DragAndDrop/DragDropTabSwitcher.cpp',
               'src/Common/ColorUtils.cpp',
               'src/Common/VisualizationDef.cpp',
               'src/DataSource/DataSourceTreeWidgetItem.cpp',
               'src/DataSource/DataSourceTreeWidgetHelper.cpp',
               'src/DataSource/DataSourceWidget.cpp',
               'src/DataSource/DataSourceTreeWidget.cpp',
               'src/Settings/SqpSettingsDialog.cpp',
               'src/Settings/SqpSettingsGeneralWidget.cpp',
               'src/SidePane/SqpSidePane.cpp',
               'src/TimeWidget/TimeWidget.cpp',
               'src/Variable/VariableInspectorWidget.cpp',
               'src/Variable/VariableInspectorTableView.cpp',
               'src/Variable/VariableMenuHeaderWidget.cpp',
               'src/Variable/RenameVariableDialog.cpp',
               'src/Visualization/VisualizationGraphHelper.cpp',
               'src/Visualization/VisualizationGraphRenderingDelegate.cpp',
               'src/Visualization/VisualizationGraphWidget.cpp',
               'src/Visualization/VisualizationTabWidget.cpp',
               'src/Visualization/VisualizationWidget.cpp',
               'src/Visualization/VisualizationZoneWidget.cpp',
               'src/Visualization/qcustomplot.cpp',
               'src/Visualization/QCustomPlotSynchronizer.cpp',
               'src/Visualization/operations/FindVariableOperation.cpp',
               'src/Visualization/operations/GenerateVariableMenuOperation.cpp',
               'src/Visualization/operations/MenuBuilder.cpp',
               'src/Visualization/operations/RemoveVariableOperation.cpp',
               'src/Visualization/operations/RescaleAxeOperation.cpp',
               'src/Visualization/VisualizationDragDropContainer.cpp',
-              'src/Visualization/VisualizationDragWidget.cpp'
+              'src/Visualization/VisualizationDragWidget.cpp',
               'src/Visualization/AxisRenderingUtils.cpp',
-              'src/Visualization/PlottablesRenderingUtils.cpp'
+              'src/Visualization/PlottablesRenderingUtils.cpp',
+              'src/Visualization/MacScrollBarStyle.cpp'
             ]
             gui_inc = include_directories(['include'])
             sciqlop_gui_lib = library('sciqlopgui',
                                    gui_sources,
                                    gui_moc_files,
                                    include_directories : [gui_inc],
                                    dependencies : [ qt5printsupport, qt5gui, qt5widgets, qt5svg, sciqlop_core],
                                    install : true
                                    )
             sciqlop_gui = declare_dependency(link_with : sciqlop_gui_lib,
                                             include_directories : gui_inc,
                                             dependencies : [qt5printsupport, qt5gui, qt5widgets, qt5svg, sciqlop_core])

gui/src/Visualization/AxisRenderingUtils.cpp +15 -5

             #include "Visualization/AxisRenderingUtils.h"
             #include <Data/ScalarSeries.h>
             #include <Data/SpectrogramSeries.h>
             #include <Data/VectorSeries.h>
             #include <Visualization/qcustomplot.h>
+            Q_LOGGING_CATEGORY(LOG_AxisRenderingUtils, "AxisRenderingUtils")
             namespace {
             const auto DATETIME_FORMAT = QStringLiteral("yyyy/MM/dd hh:mm:ss:zzz");
             /// Format for datetimes on a axis
             const auto DATETIME_TICKER_FORMAT = QStringLiteral("yyyy/MM/dd \nhh:mm:ss");
             /// Generates the appropriate ticker for an axis, depending on whether the axis displays time or
             /// non-time data
-            QSharedPointer<QCPAxisTicker> axisTicker(bool isTimeAxis)
+            QSharedPointer<QCPAxisTicker> axisTicker(bool isTimeAxis, QCPAxis::ScaleType scaleType)
             {
                 if (isTimeAxis) {
                     auto dateTicker = QSharedPointer<QCPAxisTickerDateTime>::create();
                     dateTicker->setDateTimeFormat(DATETIME_TICKER_FORMAT);
                     dateTicker->setDateTimeSpec(Qt::UTC);
                     return dateTicker;
                 }
+                else if (scaleType == QCPAxis::stLogarithmic) {
+                    return QSharedPointer<QCPAxisTickerLog>::create();
+                }
                 else {
                     // default ticker
                     return QSharedPointer<QCPAxisTicker>::create();
                 }
             }
             /**
              * Sets properties of the axis passed as parameter
              * @param axis the axis to set
              * @param unit the unit to set for the axis
              * @param scaleType the scale type to set for the axis
              */
             void setAxisProperties(QCPAxis &axis, const Unit &unit,
                                    QCPAxis::ScaleType scaleType = QCPAxis::stLinear)
             {
                 // label (unit name)
                 axis.setLabel(unit.m_Name);
                 // scale type
                 axis.setScaleType(scaleType);
+                if (scaleType == QCPAxis::stLogarithmic) {
+                    // Scientific notation
+                    axis.setNumberPrecision(0);
+                    axis.setNumberFormat("eb");
+                }
                 // ticker (depending on the type of unit)
-                axis.setTicker(axisTicker(unit.m_TimeUnit));
+                axis.setTicker(axisTicker(unit.m_TimeUnit, scaleType));
             }
             /**
              * Delegate used to set axes properties
              */
             template <typename T, typename Enabled = void>
             struct AxisSetter {
                 static void setProperties(T &, QCustomPlot &, QCPColorScale &)
                 {
                     // Default implementation does nothing
+                    qCCritical(LOG_AxisRenderingUtils()) << "Can't set axis properties: unmanaged type of data";
                 }
             };
             /**
              * Specialization of AxisSetter for scalars and vectors
              * @sa ScalarSeries
              * @sa VectorSeries
              */
             template <typename T>
             struct AxisSetter<T, typename std::enable_if_t<std::is_base_of<ScalarSeries, T>::value
                                                            or std::is_base_of<VectorSeries, T>::value> > {
                 static void setProperties(T &dataSeries, QCustomPlot &plot, QCPColorScale &)
                 {
                     dataSeries.lockRead();
                     auto xAxisUnit = dataSeries.xAxisUnit();
                     auto valuesUnit = dataSeries.valuesUnit();
                     dataSeries.unlock();
                     setAxisProperties(*plot.xAxis, xAxisUnit);
                     setAxisProperties(*plot.yAxis, valuesUnit);
                 }
             };
             /**
              * Specialization of AxisSetter for spectrograms
              * @sa SpectrogramSeries
              */
             template <typename T>
             struct AxisSetter<T, typename std::enable_if_t<std::is_base_of<SpectrogramSeries, T>::value> > {
                 static void setProperties(T &dataSeries, QCustomPlot &plot, QCPColorScale &colorScale)
                 {
                     dataSeries.lockRead();
                     auto xAxisUnit = dataSeries.xAxisUnit();
                     /// @todo ALX: use iterators here
                     auto yAxisUnit = dataSeries.yAxis().unit();
                     auto valuesUnit = dataSeries.valuesUnit();
                     dataSeries.unlock();
                     setAxisProperties(*plot.xAxis, xAxisUnit);
-                    setAxisProperties(*plot.yAxis, yAxisUnit);
+                    setAxisProperties(*plot.yAxis, yAxisUnit, QCPAxis::stLogarithmic);
                     // Displays color scale in plot
                     plot.plotLayout()->insertRow(0);
                     plot.plotLayout()->addElement(0, 0, &colorScale);
                     colorScale.setType(QCPAxis::atTop);
                     colorScale.setMinimumMargins(QMargins{0, 0, 0, 0});
                     // Aligns color scale with axes
                     auto marginGroups = plot.axisRect()->marginGroups();
                     for (auto it = marginGroups.begin(), end = marginGroups.end(); it != end; ++it) {
                         colorScale.setMarginGroup(it.key(), it.value());
                     }
                     // Set color scale properties
-                    colorScale.setLabel(valuesUnit.m_Name);
+                    setAxisProperties(*colorScale.axis(), valuesUnit, QCPAxis::stLogarithmic);
-                    colorScale.setDataScaleType(QCPAxis::stLogarithmic); // Logarithmic scale
                 }
             };
             /**
              * Default implementation of IAxisHelper, which takes data series to set axes properties
              * @tparam T the data series' type
              */
             template <typename T>
             struct AxisHelper : public IAxisHelper {
                 explicit AxisHelper(T &dataSeries) : m_DataSeries{dataSeries} {}
                 void setProperties(QCustomPlot &plot, QCPColorScale &colorScale) override
                 {
                     AxisSetter<T>::setProperties(m_DataSeries, plot, colorScale);
                 }
                 T &m_DataSeries;
             };
             } // namespace
             QString formatValue(double value, const QCPAxis &axis)
             {
                 // If the axis is a time axis, formats the value as a date
                 if (auto axisTicker = qSharedPointerDynamicCast<QCPAxisTickerDateTime>(axis.ticker())) {
                     return DateUtils::dateTime(value, axisTicker->dateTimeSpec()).toString(DATETIME_FORMAT);
                 }
                 else {
                     return QString::number(value);
                 }
             }
             std::unique_ptr<IAxisHelper>
             IAxisHelperFactory::create(std::shared_ptr<IDataSeries> dataSeries) noexcept
             {
                 if (auto scalarSeries = std::dynamic_pointer_cast<ScalarSeries>(dataSeries)) {
                     return std::make_unique<AxisHelper<ScalarSeries> >(*scalarSeries);
                 }
                 else if (auto spectrogramSeries = std::dynamic_pointer_cast<SpectrogramSeries>(dataSeries)) {
                     return std::make_unique<AxisHelper<SpectrogramSeries> >(*spectrogramSeries);
                 }
                 else if (auto vectorSeries = std::dynamic_pointer_cast<VectorSeries>(dataSeries)) {
                     return std::make_unique<AxisHelper<VectorSeries> >(*vectorSeries);
                 }
                 else {
                     return std::make_unique<AxisHelper<IDataSeries> >(*dataSeries);
                 }
             }

gui/src/Visualization/PlottablesRenderingUtils.cpp +7 0

             #include "Visualization/PlottablesRenderingUtils.h"
             #include <Common/ColorUtils.h>
             #include <Data/ScalarSeries.h>
             #include <Data/SpectrogramSeries.h>
             #include <Data/VectorSeries.h>
             #include <Visualization/qcustomplot.h>
+            Q_LOGGING_CATEGORY(LOG_PlottablesRenderingUtils, "PlottablesRenderingUtils")
             namespace {
             /// Default gradient used for colormap
             const auto DEFAULT_COLORMAP_GRADIENT = QCPColorGradient::gpJet;
             /**
              * Delegate used to set plottables properties
              */
             template <typename T, typename Enabled = void>
             struct PlottablesSetter {
                 static void setProperties(T &, PlottablesMap &)
                 {
                     // Default implementation does nothing
+                    qCCritical(LOG_PlottablesRenderingUtils())
+                        << "Can't set plottables properties: unmanaged type of data";
                 }
             };
             /**
              * Specialization of PlottablesSetter for scalars and vectors
              * @sa ScalarSeries
              * @sa VectorSeries
              */
             template <typename T>
             struct PlottablesSetter<T, typename std::enable_if_t<std::is_base_of<ScalarSeries, T>::value
                                                                  or std::is_base_of<VectorSeries, T>::value> > {
                 static void setProperties(T &dataSeries, PlottablesMap &plottables)
                 {
                     // Gets the number of components of the data series
                     dataSeries.lockRead();
                     auto componentCount = dataSeries.valuesData()->componentCount();
                     dataSeries.unlock();
                     // Generates colors for each component
                     auto colors = ColorUtils::colors(Qt::blue, Qt::red, componentCount);
                     // For each component of the data series, creates a QCPGraph to add to the plot
                     for (auto i = 0; i < componentCount; ++i) {
                         auto graph = plottables.at(i);
                         graph->setPen(QPen{colors.at(i)});
                     }
                 }
             };
             /**
              * Specialization of PlottablesSetter for spectrograms
              * @sa SpectrogramSeries
              */
             template <typename T>
             struct PlottablesSetter<T,
                                     typename std::enable_if_t<std::is_base_of<SpectrogramSeries, T>::value> > {
                 static void setProperties(T &, PlottablesMap &plottables)
                 {
                     // Checks that for a spectrogram there is only one plottable, that is a colormap
                     if (plottables.size() != 1) {
                         return;
                     }
                     if (auto colormap = dynamic_cast<QCPColorMap *>(plottables.begin()->second)) {
                         colormap->setInterpolate(false); // No value interpolation
                         colormap->setTightBoundary(true);
                         // Finds color scale in the colormap's plot to associate with it
                         auto plot = colormap->parentPlot();
                         auto plotElements = plot->plotLayout()->elements(false);
                         for (auto plotElement : plotElements) {
                             if (auto colorScale = dynamic_cast<QCPColorScale *>(plotElement)) {
                                 colormap->setColorScale(colorScale);
                             }
                         }
                         // Sets gradient used for color scale
                         colormap->setGradient(DEFAULT_COLORMAP_GRADIENT);
                         colormap->rescaleDataRange();
                     }
+                    else {
+                        qCCritical(LOG_PlottablesRenderingUtils()) << "Can't get colormap of the spectrogram";
+                    }
                 }
             };
             /**
              * Default implementation of IPlottablesHelper, which takes data series to set plottables properties
              * @tparam T the data series' type
              */
             template <typename T>
             struct PlottablesHelper : public IPlottablesHelper {
                 explicit PlottablesHelper(T &dataSeries) : m_DataSeries{dataSeries} {}
                 void setProperties(PlottablesMap &plottables) override
                 {
                     PlottablesSetter<T>::setProperties(m_DataSeries, plottables);
                 }
                 T &m_DataSeries;
             };
             } // namespace
             std::unique_ptr<IPlottablesHelper>
             IPlottablesHelperFactory::create(std::shared_ptr<IDataSeries> dataSeries) noexcept
             {
                 if (auto scalarSeries = std::dynamic_pointer_cast<ScalarSeries>(dataSeries)) {
                     return std::make_unique<PlottablesHelper<ScalarSeries> >(*scalarSeries);
                 }
                 else if (auto spectrogramSeries = std::dynamic_pointer_cast<SpectrogramSeries>(dataSeries)) {
                     return std::make_unique<PlottablesHelper<SpectrogramSeries> >(*spectrogramSeries);
                 }
                 else if (auto vectorSeries = std::dynamic_pointer_cast<VectorSeries>(dataSeries)) {
                     return std::make_unique<PlottablesHelper<VectorSeries> >(*vectorSeries);
                 }
                 else {
                     return std::make_unique<PlottablesHelper<IDataSeries> >(*dataSeries);
                 }
             }

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

             #include "Visualization/VisualizationTabWidget.h"
             #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "ui_VisualizationTabWidget.h"
             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/VisualizationZoneWidget.h"
+            #include "Visualization/MacScrollBarStyle.h"
             #include "Variable/VariableController.h"
             #include "Common/MimeTypesDef.h"
             #include "DragAndDrop/DragDropHelper.h"
             #include "SqpApplication.h"
             Q_LOGGING_CATEGORY(LOG_VisualizationTabWidget, "VisualizationTabWidget")
             namespace {
             /// Generates a default name for a new zone, according to the number of zones already displayed in
             /// the tab
             QString defaultZoneName(const QLayout &layout)
             {
                 auto count = 0;
                 for (auto i = 0; i < layout.count(); ++i) {
                     if (dynamic_cast<VisualizationZoneWidget *>(layout.itemAt(i)->widget())) {
                         count++;
                     }
                 }
                 return QObject::tr("Zone %1").arg(count + 1);
             }
             /**
              * Applies a function to all zones of the tab represented by its layout
              * @param layout the layout that contains zones
              * @param fun the function to apply to each zone
              */
             template <typename Fun>
             void processZones(QLayout &layout, Fun fun)
             {
                 for (auto i = 0; i < layout.count(); ++i) {
                     if (auto item = layout.itemAt(i)) {
                         if (auto visualizationZoneWidget
                             = dynamic_cast<VisualizationZoneWidget *>(item->widget())) {
                             fun(*visualizationZoneWidget);
                         }
                     }
                 }
             }
             } // namespace
             struct VisualizationTabWidget::VisualizationTabWidgetPrivate {
                 explicit VisualizationTabWidgetPrivate(const QString &name) : m_Name{name} {}
                 QString m_Name;
+            #ifdef Q_OS_MAC
+                std::unique_ptr<MacScrollBarStyle> m_MacScrollBarStyle = std::make_unique<MacScrollBarStyle>();
+            #endif
                 void dropGraph(int index, VisualizationTabWidget *tabWidget);
                 void dropZone(int index, VisualizationTabWidget *tabWidget);
                 void dropVariables(const QList<std::shared_ptr<Variable> > &variables, int index,
                                    VisualizationTabWidget *tabWidget);
             };
             VisualizationTabWidget::VisualizationTabWidget(const QString &name, QWidget *parent)
                     : QWidget{parent},
                       ui{new Ui::VisualizationTabWidget},
                       impl{spimpl::make_unique_impl<VisualizationTabWidgetPrivate>(name)}
             {
                 ui->setupUi(this);
+            #ifdef Q_OS_MAC
+                impl->m_MacScrollBarStyle->selfInstallOn(ui->scrollArea, true);
+            #endif
                 ui->dragDropContainer->setPlaceHolderType(DragDropHelper::PlaceHolderType::Zone, "Zone");
                 ui->dragDropContainer->layout()->setContentsMargins(0, 0, 0, 5);
                 ui->dragDropContainer->addAcceptedMimeType(
                     MIME_TYPE_GRAPH, VisualizationDragDropContainer::DropBehavior::Inserted);
                 ui->dragDropContainer->addAcceptedMimeType(
                     MIME_TYPE_ZONE, VisualizationDragDropContainer::DropBehavior::Inserted);
                 ui->dragDropContainer->addAcceptedMimeType(
                     MIME_TYPE_VARIABLE_LIST, VisualizationDragDropContainer::DropBehavior::Inserted);
                 ui->dragDropContainer->setAcceptMimeDataFunction([this](auto mimeData) {
                     return sqpApp->dragDropHelper().checkMimeDataForVisualization(mimeData,
                                                                                   ui->dragDropContainer);
                 });
                 connect(ui->dragDropContainer, &VisualizationDragDropContainer::dropOccuredInContainer, this,
                         &VisualizationTabWidget::dropMimeData);
                 sqpApp->dragDropHelper().addDragDropScrollArea(ui->scrollArea);
                 // Widget is deleted when closed
                 setAttribute(Qt::WA_DeleteOnClose);
             }
             VisualizationTabWidget::~VisualizationTabWidget()
             {
                 sqpApp->dragDropHelper().removeDragDropScrollArea(ui->scrollArea);
                 delete ui;
             }
             void VisualizationTabWidget::addZone(VisualizationZoneWidget *zoneWidget)
             {
                 ui->dragDropContainer->addDragWidget(zoneWidget);
             }
             void VisualizationTabWidget::insertZone(int index, VisualizationZoneWidget *zoneWidget)
             {
                 ui->dragDropContainer->insertDragWidget(index, zoneWidget);
             }
             VisualizationZoneWidget *VisualizationTabWidget::createZone(std::shared_ptr<Variable> variable)
             {
                 return createZone({variable}, -1);
             }
             VisualizationZoneWidget *
             VisualizationTabWidget::createZone(const QList<std::shared_ptr<Variable> > &variables, int index)
             {
                 auto zoneWidget = createEmptyZone(index);
                 // Creates a new graph into the zone
                 zoneWidget->createGraph(variables, index);
                 return zoneWidget;
             }
             VisualizationZoneWidget *VisualizationTabWidget::createEmptyZone(int index)
             {
                 auto zoneWidget
                     = new VisualizationZoneWidget{defaultZoneName(*ui->dragDropContainer->layout()), this};
                 this->insertZone(index, zoneWidget);
                 return zoneWidget;
             }
             void VisualizationTabWidget::accept(IVisualizationWidgetVisitor *visitor)
             {
                 if (visitor) {
                     visitor->visitEnter(this);
                     // Apply visitor to zone children: widgets different from zones are not visited (no action)
                     processZones(tabLayout(), [visitor](VisualizationZoneWidget &zoneWidget) {
                         zoneWidget.accept(visitor);
                     });
                     visitor->visitLeave(this);
                 }
                 else {
                     qCCritical(LOG_VisualizationTabWidget()) << tr("Can't visit widget : the visitor is null");
                 }
             }
             bool VisualizationTabWidget::canDrop(const Variable &variable) const
             {
                 // A tab can always accomodate a variable
                 Q_UNUSED(variable);
                 return true;
             }
             bool VisualizationTabWidget::contains(const Variable &variable) const
             {
                 Q_UNUSED(variable);
                 return false;
             }
             QString VisualizationTabWidget::name() const
             {
                 return impl->m_Name;
             }
             void VisualizationTabWidget::closeEvent(QCloseEvent *event)
             {
                 // Closes zones in the tab
                 processZones(tabLayout(), [](VisualizationZoneWidget &zoneWidget) { zoneWidget.close(); });
                 QWidget::closeEvent(event);
             }
             QLayout &VisualizationTabWidget::tabLayout() const noexcept
             {
                 return *ui->dragDropContainer->layout();
             }
             void VisualizationTabWidget::dropMimeData(int index, const QMimeData *mimeData)
             {
                 if (mimeData->hasFormat(MIME_TYPE_GRAPH)) {
                     impl->dropGraph(index, this);
                 }
                 else if (mimeData->hasFormat(MIME_TYPE_ZONE)) {
                     impl->dropZone(index, this);
                 }
                 else if (mimeData->hasFormat(MIME_TYPE_VARIABLE_LIST)) {
                     auto variables = sqpApp->variableController().variablesForMimeData(
                         mimeData->data(MIME_TYPE_VARIABLE_LIST));
                     impl->dropVariables(variables, index, this);
                 }
                 else {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationTabWidget::dropMimeData, unknown MIME data received.");
                 }
             }
             void VisualizationTabWidget::VisualizationTabWidgetPrivate::dropGraph(
                 int index, VisualizationTabWidget *tabWidget)
             {
                 auto &helper = sqpApp->dragDropHelper();
                 auto graphWidget = qobject_cast<VisualizationGraphWidget *>(helper.getCurrentDragWidget());
                 if (!graphWidget) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationTabWidget::dropGraph, drop aborted, the dropped graph is not "
                               "found or invalid.");
                     Q_ASSERT(false);
                     return;
                 }
                 auto parentDragDropContainer
                     = qobject_cast<VisualizationDragDropContainer *>(graphWidget->parentWidget());
                 if (!parentDragDropContainer) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationTabWidget::dropGraph, drop aborted, the parent container of "
                               "the dropped graph is not found.");
                     Q_ASSERT(false);
                     return;
                 }
                 auto nbGraph = parentDragDropContainer->countDragWidget();
                 const auto &variables = graphWidget->variables();
                 if (!variables.isEmpty()) {
                     // Abort the requests for the variables (if any)
                     // Commented, because it's not sure if it's needed or not
                     // for (const auto& var : variables)
                     //{
                     //    sqpApp->variableController().onAbortProgressRequested(var);
                     //}
                     if (nbGraph == 1) {
                         // This is the only graph in the previous zone, close the zone
                         helper.delayedCloseWidget(graphWidget->parentZoneWidget());
                     }
                     else {
                         // Close the graph
                         helper.delayedCloseWidget(graphWidget);
                     }
                     tabWidget->createZone(variables, index);
                 }
                 else {
                     // The graph is empty, create an empty zone and move the graph inside
                     auto parentZoneWidget = graphWidget->parentZoneWidget();
                     parentDragDropContainer->layout()->removeWidget(graphWidget);
                     auto zoneWidget = tabWidget->createEmptyZone(index);
                     zoneWidget->addGraph(graphWidget);
                     // Close the old zone if it was the only graph inside
                     if (nbGraph == 1) {
                         helper.delayedCloseWidget(parentZoneWidget);
                     }
                 }
             }
             void VisualizationTabWidget::VisualizationTabWidgetPrivate::dropZone(
                 int index, VisualizationTabWidget *tabWidget)
             {
                 auto &helper = sqpApp->dragDropHelper();
                 auto zoneWidget = qobject_cast<VisualizationZoneWidget *>(helper.getCurrentDragWidget());
                 if (!zoneWidget) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationTabWidget::dropZone, drop aborted, the dropped zone is not "
                               "found or invalid.");
                     Q_ASSERT(false);
                     return;
                 }
                 auto parentDragDropContainer
                     = qobject_cast<VisualizationDragDropContainer *>(zoneWidget->parentWidget());
                 if (!parentDragDropContainer) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationTabWidget::dropZone, drop aborted, the parent container of "
                               "the dropped zone is not found.");
                     Q_ASSERT(false);
                     return;
                 }
                 // Simple move of the zone, no variable operation associated
                 parentDragDropContainer->layout()->removeWidget(zoneWidget);
                 tabWidget->ui->dragDropContainer->insertDragWidget(index, zoneWidget);
             }
             void VisualizationTabWidget::VisualizationTabWidgetPrivate::dropVariables(
                 const QList<std::shared_ptr<Variable> > &variables, int index,
                 VisualizationTabWidget *tabWidget)
             {
                 // Note: the AcceptMimeDataFunction (set on the drop container) ensure there is a single and
                 // compatible variable here
                 if (variables.count() > 1) {
                     qCWarning(LOG_VisualizationZoneWidget())
                         << tr("VisualizationTabWidget::dropVariables, dropping multiple variables, operation "
                               "aborted.");
                     return;
                 }
                 tabWidget->createZone(variables, index);
             }

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