HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r1049:ead367adcd3d

multi selection of zones

trabillard -

r1049:ead367adcd3d

parent child

Context file:

r1049:ead367adcd3d

gui/include/Visualization/VisualizationSelectionZoneManager.h created 644 +26 0

@@ -0,0 +1,26
	1	#ifndef SCIQLOP_VISUALIZATIONSELECTIONZONEMANAGER_H
	2	#define SCIQLOP_VISUALIZATIONSELECTIONZONEMANAGER_H
	3
	4	#include <Common/spimpl.h>
	5
	6	#include <QVector>
	7
	8	class VisualizationSelectionZoneItem;
	9
	10	class VisualizationSelectionZoneManager {
	11	public:
	12	VisualizationSelectionZoneManager();
	13
	14	void select(const QVector<VisualizationSelectionZoneItem *> &items);
	15	void setSelected(VisualizationSelectionZoneItem *item, bool value);
	16
	17	void clearSelection();
	18
	19	QVector<VisualizationSelectionZoneItem *> selectedItems() const;
	20
	21	private:
	22	class VisualizationSelectionZoneManagerPrivate;
	23	spimpl::unique_impl_ptr<VisualizationSelectionZoneManagerPrivate> impl;
	24	};
	25
	26	#endif // SCIQLOP_VISUALIZATIONSELECTIONZONEMANAGER_H

gui/src/Visualization/VisualizationSelectionZoneManager.cpp created 644 +51 0

@@ -0,0 +1,51
	1	#include "Visualization/VisualizationSelectionZoneManager.h"
	2	#include "Visualization/VisualizationSelectionZoneItem.h"
	3
	4	struct VisualizationSelectionZoneManager::VisualizationSelectionZoneManagerPrivate {
	5	QVector<VisualizationSelectionZoneItem *> m_SelectedItems;
	6	};
	7
	8	VisualizationSelectionZoneManager::VisualizationSelectionZoneManager()
	9	: impl{spimpl::make_unique_impl<VisualizationSelectionZoneManagerPrivate>()}
	10	{
	11	}
	12
	13	void VisualizationSelectionZoneManager::select(
	14	const QVector<VisualizationSelectionZoneItem *> &items)
	15	{
	16	clearSelection();
	17	for (auto item : items) {
	18	setSelected(item, true);
	19	}
	20	}
	21
	22	void VisualizationSelectionZoneManager::setSelected(VisualizationSelectionZoneItem *item,
	23	bool value)
	24	{
	25	if (value != item->selected()) {
	26	item->setSelected(value);
	27	item->parentPlot()->replot();
	28	}
	29
	30	if (!value && impl->m_SelectedItems.contains(item)) {
	31	impl->m_SelectedItems.removeAll(item);
	32	}
	33	else if (value) {
	34	impl->m_SelectedItems << item;
	35	}
	36	}
	37
	38	void VisualizationSelectionZoneManager::clearSelection()
	39	{
	40	for (auto item : impl->m_SelectedItems) {
	41	item->setSelected(false);
	42	item->parentPlot()->replot();
	43	}
	44
	45	impl->m_SelectedItems.clear();
	46	}
	47
	48	QVector<VisualizationSelectionZoneItem *> VisualizationSelectionZoneManager::selectedItems() const
	49	{
	50	return impl->m_SelectedItems;
	51	}

gui/include/Visualization/VisualizationGraphWidget.h +5 0

             class QCustomPlot;
             class SqpRange;
             class Variable;
+            class VisualizationWidget;
             class VisualizationZoneWidget;
             namespace Ui {
                 explicit VisualizationGraphWidget(const QString &name = {}, QWidget *parent = 0);
                 virtual ~VisualizationGraphWidget();
+                /// Returns the VisualizationZoneWidget which contains the graph or nullptr
                 VisualizationZoneWidget *parentZoneWidget() const noexcept;
+                /// Returns the main VisualizationWidget which contains the graph or nullptr
+                VisualizationWidget *parentVisualizationWidget() const;
                 /// If acquisition isn't enable, requestDataLoading signal cannot be emit
                 void enableAcquisition(bool enable);

gui/include/Visualization/VisualizationSelectionZoneItem.h +1 0

             #include <Visualization/qcustomplot.h>
             class VisualizationSelectionZoneItem : public QCPItemRect {
             public:
                 VisualizationSelectionZoneItem(QCustomPlot *plot);
                 virtual ~VisualizationSelectionZoneItem();

gui/include/Visualization/VisualizationWidget.h +9 0

             #include <QLoggingCategory>
             #include <QWidget>
+            #include <Common/spimpl.h>
             Q_DECLARE_LOGGING_CATEGORY(LOG_VisualizationWidget)
             class QMenu;
             class Variable;
             class VisualizationTabWidget;
+            class VisualizationSelectionZoneManager;
             namespace Ui {
             class VisualizationWidget;
                 explicit VisualizationWidget(QWidget *parent = 0);
                 virtual ~VisualizationWidget();
+                /// Returns the class which manage the selection of selection zone across the visualization
+                VisualizationSelectionZoneManager &selectionZoneManager() const;
                 // IVisualizationWidget interface
                 void accept(IVisualizationWidgetVisitor *visitor) override;
                 bool canDrop(const Variable &variable) const override;
             private:
                 Ui::VisualizationWidget *ui;
+                class VisualizationWidgetPrivate;
+                spimpl::unique_impl_ptr<VisualizationWidgetPrivate> impl;
             };
             #endif // VISUALIZATIONWIDGET_H

gui/meson.build +2 -1

               'src/Visualization/ColorScaleEditor.cpp',
               'src/Visualization/SqpColorScale.cpp',
               'src/Visualization/QCPColorMapIterator.cpp',
-              'src/Visualization/VisualizationSelectionZoneItem.cpp'
+              'src/Visualization/VisualizationSelectionZoneItem.cpp',
+              'src/Visualization/VisualizationSelectionZoneManager.cpp'
             ]
             gui_inc = include_directories(['include'])

gui/src/Visualization/VisualizationGraphWidget.cpp +65 -25

             #include "Visualization/VisualizationGraphHelper.h"
             #include "Visualization/VisualizationGraphRenderingDelegate.h"
             #include "Visualization/VisualizationSelectionZoneItem.h"
+            #include "Visualization/VisualizationSelectionZoneManager.h"
+            #include "Visualization/VisualizationWidget.h"
             #include "Visualization/VisualizationZoneWidget.h"
             #include "ui_VisualizationGraphWidget.h"
             /// Key pressed to enable a calibration pan
             const auto VERTICAL_PAN_MODIFIER = Qt::AltModifier;
+            /// Key pressed to enable multi selection of selection zones
+            const auto MULTI_ZONE_SELECTION_MODIFIER = Qt::ControlModifier;
             /// Minimum size for the zoom box, in percentage of the axis range
             const auto ZOOM_BOX_MIN_SIZE = 0.8;
                     }
                 }
-                void startDrawingZone(const QPoint &pos, QCustomPlot &plot)
+                void startDrawingZone(const QPoint &pos, VisualizationGraphWidget *graph)
                 {
-                    endDrawingZone(plot);
+                    endDrawingZone(graph);
-                    auto axisPos = posToAxisPos(pos, plot);
+                    auto axisPos = posToAxisPos(pos, graph->plot());
-                    m_DrawingZone = new VisualizationSelectionZoneItem{&plot};
+                    m_DrawingZone = new VisualizationSelectionZoneItem{&graph->plot()};
                     m_DrawingZone->setRange(axisPos.x(), axisPos.x());
                     m_DrawingZone->setEditionEnabled(false);
                 }
-                void endDrawingZone(QCustomPlot &plot)
+                void endDrawingZone(VisualizationGraphWidget *graph)
                 {
                     if (m_DrawingZone) {
                         auto drawingZoneRange = m_DrawingZone->range();
                         if (qAbs(drawingZoneRange.m_TEnd - drawingZoneRange.m_TStart) > 0) {
                             m_DrawingZone->setEditionEnabled(true);
-                            m_SelectionZones.append(m_DrawingZone);
+                            addSelectionZone(m_DrawingZone);
                         }
                         else {
-                            plot.removeItem(m_DrawingZone); // the item is deleted by QCustomPlot
+                            graph->plot().removeItem(m_DrawingZone); // the item is deleted by QCustomPlot
                         }
-                        plot.replot(QCustomPlot::rpQueuedReplot);
+                        graph->plot().replot(QCustomPlot::rpQueuedReplot);
                         m_DrawingZone = nullptr;
                     }
                 }
                     }
                 }
+                void addSelectionZone(VisualizationSelectionZoneItem *zone) { m_SelectionZones << zone; }
                 VisualizationSelectionZoneItem *selectionZoneAt(const QPoint &pos,
                                                                 const QCustomPlot &plot) const
                 {
                 // Set qcpplot properties :
                 // - zoom is enabled
                 // - Mouse wheel on qcpplot is intercepted to determine the zoom orientation
-                ui->widget->setInteractions(QCP::iRangeZoom | QCP::iSelectItems);
+                ui->widget->setInteractions(QCP::iRangeZoom);
                 ui->widget->axisRect()->setRangeDrag(Qt::Horizontal | Qt::Vertical);
                 // The delegate must be initialized after the ui as it uses the plot
                 connect(ui->widget, &QCustomPlot::mouseWheel, this, &VisualizationGraphWidget::onMouseWheel);
                 connect(ui->widget, &QCustomPlot::mouseDoubleClick, this,
                         &VisualizationGraphWidget::onMouseDoubleClick);
-                connect(ui->widget->xAxis, static_cast<void (QCPAxis::*)(const QCPRange &, const QCPRange &)>(
+                connect(
-                                               &QCPAxis::rangeChanged),
+                    ui->widget->xAxis,
-                        this, &VisualizationGraphWidget::onRangeChanged, Qt::DirectConnection);
+                    static_cast<void (QCPAxis::*)(const QCPRange &, const QCPRange &)>(&QCPAxis::rangeChanged),
+                    this, &VisualizationGraphWidget::onRangeChanged, Qt::DirectConnection);
                 // Activates menu when right clicking on the graph
                 ui->widget->setContextMenuPolicy(Qt::CustomContextMenu);
                 return qobject_cast<VisualizationZoneWidget *>(parent);
             }
+            VisualizationWidget *VisualizationGraphWidget::parentVisualizationWidget() const
+            {
+                auto parent = parentWidget();
+                while (parent != nullptr && !qobject_cast<VisualizationWidget *>(parent)) {
+                    parent = parent->parentWidget();
+                }
+                return qobject_cast<VisualizationWidget *>(parent);
+            }
             void VisualizationGraphWidget::enableAcquisition(bool enable)
             {
                 impl->m_DoAcquisition = enable;
             void VisualizationGraphWidget::addSelectionZones(const QVector<SqpRange> &ranges)
             {
                 for (const auto &range : ranges) {
+                    // note: ownership is transfered to QCustomPlot
                     auto zone = new VisualizationSelectionZoneItem(&plot());
                     zone->setRange(range.m_TStart, range.m_TEnd);
-                    impl->m_SelectionZones << zone;
+                    impl->addSelectionZone(zone);
                 }
                 plot().replot(QCustomPlot::rpQueuedReplot);
             void VisualizationGraphWidget::onRangeChanged(const QCPRange &t1, const QCPRange &t2)
             {
-                qCDebug(LOG_VisualizationGraphWidget()) << tr("TORM: VisualizationGraphWidget::onRangeChanged")
+                qCDebug(LOG_VisualizationGraphWidget())
-                                                        << QThread::currentThread()->objectName() << "DoAcqui"
+                    << tr("TORM: VisualizationGraphWidget::onRangeChanged")
-                                                        << impl->m_DoAcquisition;
+                    << QThread::currentThread()->objectName() << "DoAcqui" << impl->m_DoAcquisition;
                 auto graphRange = SqpRange{t1.lower, t1.upper};
                 auto oldGraphRange = SqpRange{t2.lower, t2.upper};
             void VisualizationGraphWidget::onMousePress(QMouseEvent *event) noexcept
             {
                 bool isDragDropClick = event->modifiers().testFlag(DRAG_DROP_MODIFIER);
+                auto isSelectionZoneMode
+                    = sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones;
                 if (!isDragDropClick) {
                     if (sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::ZoomBox) {
                         // Starts a zoom box
                         impl->startDrawingRect(event->pos(), plot());
                     }
-                    else if (sqpApp->plotsInteractionMode()
+                    else if (isSelectionZoneMode && impl->m_DrawingZone == nullptr) {
-                                 == SqpApplication::PlotsInteractionMode::SelectionZones
-                             && impl->m_DrawingZone == nullptr) {
                         // Starts a new selection zone
                         auto zoneAtPos = impl->selectionZoneAt(event->pos(), plot());
                         if (!zoneAtPos) {
-                            impl->startDrawingZone(event->pos(), plot());
+                            impl->startDrawingZone(event->pos(), this);
                         }
                     }
                 }
                                                                == SqpApplication::PlotsInteractionMode::None
                                                            && !isDragDropClick);
-                // Allows zone edition only in selection zone mode without ALT pressed (ALT is for drag&drop)
+                // Allows zone edition only in selection zone mode without drag&drop
-                impl->setSelectionZonesEditionEnabled(
+                impl->setSelectionZonesEditionEnabled(isSelectionZoneMode && !isDragDropClick);
-                    sqpApp->plotsInteractionMode() == SqpApplication::PlotsInteractionMode::SelectionZones
-                    && !isDragDropClick);
+                // Selection
+                if (isSelectionZoneMode) {
+                    auto isMultiSelectionClick = event->modifiers().testFlag(MULTI_ZONE_SELECTION_MODIFIER);
+                    auto selectionZoneItemUnderCursor = impl->selectionZoneAt(event->pos(), plot());
+                    if (selectionZoneItemUnderCursor && event->button() == Qt::LeftButton) {
+                        if (!isMultiSelectionClick) {
+                            parentVisualizationWidget()->selectionZoneManager().select(
+                                {selectionZoneItemUnderCursor});
+                        }
+                        else {
+                            parentVisualizationWidget()->selectionZoneManager().setSelected(
+                                selectionZoneItemUnderCursor, !selectionZoneItemUnderCursor->selected()
+                                                                  || event->button() == Qt::RightButton);
+                        }
+                    }
+                    else if (!isMultiSelectionClick && event->button() == Qt::LeftButton) {
+                        parentVisualizationWidget()->selectionZoneManager().clearSelection();
+                    }
+                    else {
+                        // No selection change
+                    }
+                }
                 VisualizationDragWidget::mousePressEvent(event);
             }
                     }
                 }
-                impl->endDrawingZone(plot());
+                impl->endDrawingZone(this);
                 impl->m_IsCalibration = false;
             }

gui/src/Visualization/VisualizationSelectionZoneItem.cpp +9 -11

             #include "Visualization/VisualizationSelectionZoneItem.h"
+            const QString &DEFAULT_COLOR = QStringLiteral("#E79D41");
             struct VisualizationSelectionZoneItem::VisualizationSelectionZoneItemPrivate {
                 QCustomPlot *m_Plot;
                 topLeft->setTypeY(QCPItemPosition::ptAxisRectRatio);
                 bottomRight->setTypeX(QCPItemPosition::ptPlotCoords);
                 bottomRight->setTypeY(QCPItemPosition::ptAxisRectRatio);
+                setSelectable(false);
                 impl->m_RightLine = new QCPItemStraightLine(plot);
                 impl->m_RightLine->point1->setParentAnchor(topRight);
                 impl->m_RightLine->point1->setTypeY(QCPItemPosition::ptAbsolute);
                 impl->m_RightLine->point2->setTypeX(QCPItemPosition::ptAbsolute);
                 impl->m_RightLine->point2->setTypeY(QCPItemPosition::ptAbsolute);
+                impl->m_RightLine->setSelectable(false);
                 impl->m_LeftLine = new QCPItemStraightLine(plot);
                 impl->m_LeftLine->point1->setParentAnchor(topLeft);
                 impl->m_LeftLine->point1->setTypeY(QCPItemPosition::ptAbsolute);
                 impl->m_LeftLine->point2->setTypeX(QCPItemPosition::ptAbsolute);
                 impl->m_LeftLine->point2->setTypeY(QCPItemPosition::ptAbsolute);
-                impl->m_RightLine->setSelectable(false);
                 impl->m_LeftLine->setSelectable(false);
-                //    connect(this, &VisualizationSelectionZoneItem::selectionChanged, impl->m_RightLine,
+                setColor(QColor(DEFAULT_COLOR));
-                //            &QCPItemStraightLine::setSelected);
-                //    connect(this, &VisualizationSelectionZoneItem::selectionChanged, impl->m_LeftLine,
-                //            &QCPItemStraightLine::setSelected);
-                setColor(QColor("#E79D41"));
             }
             VisualizationSelectionZoneItem::~VisualizationSelectionZoneItem()
             void VisualizationSelectionZoneItem::mousePressEvent(QMouseEvent *event, const QVariant &details)
             {
-                if (isEditionEnabled()) {
+                if (isEditionEnabled() && event->button() == Qt::LeftButton) {
                     impl->m_CurrentEditionMode = impl->getEditionMode(event->pos(), this);
                     impl->m_MovedOrinalT1 = impl->m_T1;
                     impl->m_MovedOrinalT2 = impl->m_T2;
                 }
                 else {
+                    impl->m_CurrentEditionMode = VisualizationSelectionZoneItemPrivate::EditionMode::NoEdition;
                     event->ignore();
                 }
             }
                         case VisualizationSelectionZoneItemPrivate::EditionMode::ResizeRight:
                             setEnd(impl->m_MovedOrinalT2 + diff);
                             break;
-                            // default:
+                        default:
-                            // unknown edition mode
+                            break;
                     }
                 }
                 else {

gui/src/Visualization/VisualizationWidget.cpp +20 -1

             #include "Visualization/VisualizationWidget.h"
             #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "Visualization/VisualizationGraphWidget.h"
+            #include "Visualization/VisualizationSelectionZoneManager.h"
             #include "Visualization/VisualizationTabWidget.h"
             #include "Visualization/VisualizationZoneWidget.h"
             #include "Visualization/operations/FindVariableOperation.h"
             #include <QToolButton>
+            #include <memory>
             Q_LOGGING_CATEGORY(LOG_VisualizationWidget, "VisualizationWidget")
+            struct VisualizationWidget::VisualizationWidgetPrivate {
+                std::unique_ptr<VisualizationSelectionZoneManager> m_ZoneSelectionManager = nullptr;
+                VisualizationWidgetPrivate()
+                        : m_ZoneSelectionManager(std::make_unique<VisualizationSelectionZoneManager>())
+                {
+                }
+            };
             VisualizationWidget::VisualizationWidget(QWidget *parent)
-                    : QWidget{parent}, ui{new Ui::VisualizationWidget}
+                    : QWidget{parent},
+                      ui{new Ui::VisualizationWidget},
+                      impl{spimpl::make_unique_impl<VisualizationWidgetPrivate>()}
             {
                 ui->setupUi(this);
                 delete ui;
             }
+            VisualizationSelectionZoneManager &VisualizationWidget::selectionZoneManager() const
+            {
+                return *impl->m_ZoneSelectionManager.get();
+            }
             void VisualizationWidget::accept(IVisualizationWidgetVisitor *visitor)
             {
                 if (visitor) {

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