GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r1325:87a145505c37

Corrects the problem of refreshing synchronized graphs from TimeWidget (1)...

Alexandre Leroux -

r1325:87a145505c37

parent child

Context file:

r1325:87a145505c37

Collapse all files

gui/include/Visualization/VisualizationGraphWidget.h +16 -2

             class VisualizationGraphWidget;
             } // namespace Ui
+            /// Defines options that can be associated with the graph
+            enum GraphFlag {
+                DisableAll = 0x0,        ///< Disables acquisition and synchronization
+                EnableAcquisition = 0x1, ///< When this flag is set, the change of the graph's range leads to
+                                         /// the acquisition of data
+                EnableSynchronization = 0x2, ///< When this flag is set, the change of the graph's range causes
+                                             /// the call to the synchronization of the graphs contained in the
+                /// same zone of this graph
+                EnableAll = ~DisableAll ///< Enables acquisition and synchronization
+            };
+            Q_DECLARE_FLAGS(GraphFlags, GraphFlag)
+            Q_DECLARE_OPERATORS_FOR_FLAGS(GraphFlags)
             class VisualizationGraphWidget : public VisualizationDragWidget, public IVisualizationWidget {
                 Q_OBJECT
                 /// Returns the main VisualizationWidget which contains the graph or nullptr
                 VisualizationWidget *parentVisualizationWidget() const;
-                /// If acquisition isn't enable, requestDataLoading signal cannot be emit
+                /// Sets graph options
-                void enableAcquisition(bool enable);
+                void setFlags(GraphFlags flags);
                 void addVariable(std::shared_ptr<Variable> variable, SqpRange range);

gui/src/Visualization/VisualizationGraphWidget.cpp +8 -8

                 explicit VisualizationGraphWidgetPrivate(const QString &name)
                         : m_Name{name},
-                          m_DoAcquisition{true},
+                          m_Flags{GraphFlag::EnableAll},
                           m_IsCalibration{false},
                           m_RenderingDelegate{nullptr}
                 {
                 QString m_Name;
                 // 1 variable -> n qcpplot
                 std::map<std::shared_ptr<Variable>, PlottablesMap> m_VariableToPlotMultiMap;
-                bool m_DoAcquisition;
+                GraphFlags m_Flags;
                 bool m_IsCalibration;
                 /// Delegate used to attach rendering features to the plot
                 std::unique_ptr<VisualizationGraphRenderingDelegate> m_RenderingDelegate;
                 return qobject_cast<VisualizationWidget *>(parent);
             }
-            void VisualizationGraphWidget::enableAcquisition(bool enable)
+            void VisualizationGraphWidget::setFlags(GraphFlags flags)
             {
-                impl->m_DoAcquisition = enable;
+                impl->m_Flags = std::move(flags);
             }
             void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable> variable, SqpRange range)
                 connect(variable.get(), SIGNAL(updated()), this, SLOT(onDataCacheVariableUpdated()));
-                this->enableAcquisition(false);
+                this->setFlags(GraphFlag::DisableAll);
                 this->setGraphRange(range);
-                this->enableAcquisition(true);
+                this->setFlags(GraphFlag::EnableAll);
                 emit requestDataLoading(QVector<std::shared_ptr<Variable> >() << variable, range, false);
             {
                 qCDebug(LOG_VisualizationGraphWidget()) << tr("TORM: VisualizationGraphWidget::onRangeChanged")
                                                         << QThread::currentThread()->objectName() << "DoAcqui"
-                                                        << impl->m_DoAcquisition;
+                                                        << impl->m_Flags.testFlag(GraphFlag::EnableAcquisition);
                 auto graphRange = SqpRange{t1.lower, t1.upper};
                 auto oldGraphRange = SqpRange{t2.lower, t2.upper};
-                if (impl->m_DoAcquisition) {
+                if (impl->m_Flags.testFlag(GraphFlag::EnableAcquisition)) {
                     QVector<std::shared_ptr<Variable> > variableUnderGraphVector;
                     for (auto it = impl->m_VariableToPlotMultiMap.begin(),

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

                                     // No action
                                     break;
                             }
-                            graphChild->enableAcquisition(false);
+                            graphChild->setFlags(GraphFlag::DisableAll);
-                            qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: Range before: ")
+                            qCDebug(LOG_VisualizationZoneWidget())
-                                                                   << graphChild->graphRange();
+                                << tr("TORM: Range before: ") << graphChild->graphRange();
-                            qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: Range after : ")
+                            qCDebug(LOG_VisualizationZoneWidget())
-                                                                   << graphChildRange;
+                                << tr("TORM: Range after : ") << graphChildRange;
                             qCDebug(LOG_VisualizationZoneWidget())
                                 << tr("TORM: child dt") << graphChildRange.m_TEnd - graphChildRange.m_TStart;
                             graphChild->setGraphRange(graphChildRange);
-                            graphChild->enableAcquisition(true);
+                            graphChild->setFlags(GraphFlag::EnableAll);
                         }
                     }
                 };

gui/src/Visualization/operations/RescaleAxeOperation.cpp +2 -2

                 if (graphWidget) {
                     // If the widget contains the variable, rescale it
                     if (impl->m_Variable && graphWidget->contains(*impl->m_Variable)) {
-                        graphWidget->enableAcquisition(false);
+                        graphWidget->setFlags(GraphFlag::DisableAll);
                         graphWidget->setGraphRange(impl->m_Range);
-                        graphWidget->enableAcquisition(true);
+                        graphWidget->setFlags(GraphFlag::EnableAll);
                     }
                 }
                 else {

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