GIT_REPOSITORIES/LPP/Users/mperrinel/SCIQLOP-Initialisation Commit - r612:fc066ad3e5c7

Fixed menus position

Alexandre Leroux -

r612:fc066ad3e5c7

parent child

Context file:

r612:fc066ad3e5c7

Collapse all files

gui/src/DataSource/DataSourceWidget.cpp +1 -1

             #include <DataSource/DataSourceWidget.h>
             #include <ui_DataSourceWidget.h>
             #include <DataSource/DataSourceItem.h>
             #include <DataSource/DataSourceTreeWidgetHelper.h>
             #include <DataSource/DataSourceTreeWidgetItem.h>
             #include <QMenu>
             namespace {
             /// Number of columns displayed in the tree
             const auto TREE_NB_COLUMNS = 1;
             /// Header labels for the tree
             const auto TREE_HEADER_LABELS = QStringList{QObject::tr("Name")};
             /**
              * Creates the item associated to a data source
              * @param dataSource the data source for which to create the item
              * @return the new item
              */
             DataSourceTreeWidgetItem *createTreeWidgetItem(DataSourceItem *dataSource)
             {
                 // Creates item for the data source
                 auto item = new DataSourceTreeWidgetItem{dataSource};
                 // Generates items for the children of the data source
                 for (auto i = 0; i < dataSource->childCount(); ++i) {
                     item->addChild(createTreeWidgetItem(dataSource->child(i)));
                 }
                 return item;
             }
             } // namespace
             DataSourceWidget::DataSourceWidget(QWidget *parent) : QWidget{parent}, ui{new Ui::DataSourceWidget}
             {
                 ui->setupUi(this);
                 // Set tree properties
                 ui->treeWidget->setColumnCount(TREE_NB_COLUMNS);
                 ui->treeWidget->setHeaderLabels(TREE_HEADER_LABELS);
                 ui->treeWidget->setContextMenuPolicy(Qt::CustomContextMenu);
                 // Connection to show a menu when right clicking on the tree
                 connect(ui->treeWidget, &QTreeWidget::customContextMenuRequested, this,
                         &DataSourceWidget::onTreeMenuRequested);
                 // Connection to filter tree
                 connect(ui->filterLineEdit, &QLineEdit::textChanged, this, &DataSourceWidget::filterChanged);
             }
             DataSourceWidget::~DataSourceWidget() noexcept
             {
                 delete ui;
             }
             void DataSourceWidget::addDataSource(DataSourceItem *dataSource) noexcept
             {
                 // Creates the item associated to the source and adds it to the tree widget. The tree widget
                 // takes the ownership of the item
                 if (dataSource) {
                     ui->treeWidget->addTopLevelItem(createTreeWidgetItem(dataSource));
                 }
             }
             void DataSourceWidget::filterChanged(const QString &text) noexcept
             {
                 auto validateItem = [&text](const DataSourceTreeWidgetItem &item) {
                     auto regExp = QRegExp{text, Qt::CaseInsensitive, QRegExp::Wildcard};
                     // An item is valid if any of its metadata validates the text filter
                     auto itemMetadata = item.data()->data();
                     auto itemMetadataEnd = itemMetadata.cend();
                     auto acceptFilter
                         = [&regExp](const auto &variant) { return variant.toString().contains(regExp); };
                     return std::find_if(itemMetadata.cbegin(), itemMetadataEnd, acceptFilter)
                            != itemMetadataEnd;
                 };
                 // Applies filter on tree widget
                 DataSourceTreeWidgetHelper::filter(*ui->treeWidget, validateItem);
             }
             void DataSourceWidget::onTreeMenuRequested(const QPoint &pos) noexcept
             {
                 // Retrieves the selected item in the tree, and build the menu from its actions
                 if (auto selectedItem = dynamic_cast<DataSourceTreeWidgetItem *>(ui->treeWidget->itemAt(pos))) {
                     QMenu treeMenu{};
                     treeMenu.addActions(selectedItem->actions());
                     if (!treeMenu.isEmpty()) {
-                        treeMenu.exec(mapToGlobal(pos));
+                        treeMenu.exec(QCursor::pos());
                     }
                 }
             }

gui/src/Variable/VariableInspectorWidget.cpp +1 -1

             #include <Variable/VariableController.h>
             #include <Variable/VariableInspectorWidget.h>
             #include <Variable/VariableMenuHeaderWidget.h>
             #include <Variable/VariableModel.h>
             #include <ui_VariableInspectorWidget.h>
             #include <QMouseEvent>
             #include <QSortFilterProxyModel>
             #include <QStyledItemDelegate>
             #include <QWidgetAction>
             #include <SqpApplication.h>
             Q_LOGGING_CATEGORY(LOG_VariableInspectorWidget, "VariableInspectorWidget")
             class QProgressBarItemDelegate : public QStyledItemDelegate {
             public:
                 QProgressBarItemDelegate(QObject *parent) : QStyledItemDelegate{parent} {}
                 void paint(QPainter *painter, const QStyleOptionViewItem &option,
                            const QModelIndex &index) const
                 {
                     auto data = index.data(Qt::DisplayRole);
                     auto progressData = index.data(VariableRoles::ProgressRole);
                     if (data.isValid() && progressData.isValid()) {
                         auto name = data.value<QString>();
                         auto progress = progressData.value<double>();
                         if (progress > 0) {
                             auto cancelButtonWidth = 20;
                             auto progressBarOption = QStyleOptionProgressBar{};
                             auto progressRect = option.rect;
                             progressRect.setWidth(progressRect.width() - cancelButtonWidth);
                             progressBarOption.rect = progressRect;
                             progressBarOption.minimum = 0;
                             progressBarOption.maximum = 100;
                             progressBarOption.progress = progress;
                             progressBarOption.text
                                 = QString("%1 %2").arg(name).arg(QString::number(progress, 'f', 2) + "%");
                             progressBarOption.textVisible = true;
                             progressBarOption.textAlignment = Qt::AlignCenter;
                             QApplication::style()->drawControl(QStyle::CE_ProgressBar, &progressBarOption,
                                                                painter);
                             // Cancel button
                             auto buttonRect = QRect(progressRect.right(), option.rect.top(), cancelButtonWidth,
                                                     option.rect.height());
                             auto buttonOption = QStyleOptionButton{};
                             buttonOption.rect = buttonRect;
                             buttonOption.text = "X";
                             QApplication::style()->drawControl(QStyle::CE_PushButton, &buttonOption, painter);
                         }
                         else {
                             QStyledItemDelegate::paint(painter, option, index);
                         }
                     }
                     else {
                         QStyledItemDelegate::paint(painter, option, index);
                     }
                 }
                 bool editorEvent(QEvent *event, QAbstractItemModel *model, const QStyleOptionViewItem &option,
                                  const QModelIndex &index)
                 {
                     if (event->type() == QEvent::MouseButtonRelease) {
                         auto data = index.data(Qt::DisplayRole);
                         auto progressData = index.data(VariableRoles::ProgressRole);
                         if (data.isValid() && progressData.isValid()) {
                             auto cancelButtonWidth = 20;
                             auto progressRect = option.rect;
                             progressRect.setWidth(progressRect.width() - cancelButtonWidth);
                             // Cancel button
                             auto buttonRect = QRect(progressRect.right(), option.rect.top(), cancelButtonWidth,
                                                     option.rect.height());
                             auto e = (QMouseEvent *)event;
                             auto clickX = e->x();
                             auto clickY = e->y();
                             auto x = buttonRect.left();   // the X coordinate
                             auto y = buttonRect.top();    // the Y coordinate
                             auto w = buttonRect.width();  // button width
                             auto h = buttonRect.height(); // button height
                             if (clickX > x && clickX < x + w) {
                                 if (clickY > y && clickY < y + h) {
                                     auto variableModel = sqpApp->variableController().variableModel();
                                     variableModel->abortProgress(index);
                                 }
                             }
                             else {
                                 QStyledItemDelegate::editorEvent(event, model, option, index);
                             }
                         }
                         else {
                             QStyledItemDelegate::editorEvent(event, model, option, index);
                         }
                     }
                     else {
                         QStyledItemDelegate::editorEvent(event, model, option, index);
                     }
                 }
             };
             VariableInspectorWidget::VariableInspectorWidget(QWidget *parent)
                     : QWidget{parent},
                       ui{new Ui::VariableInspectorWidget},
                       m_ProgressBarItemDelegate{new QProgressBarItemDelegate{this}}
             {
                 ui->setupUi(this);
                 // Sets model for table
                 //    auto sortFilterModel = new QSortFilterProxyModel{this};
                 //    sortFilterModel->setSourceModel(sqpApp->variableController().variableModel());
                 auto variableModel = sqpApp->variableController().variableModel();
                 ui->tableView->setModel(variableModel);
                 // Adds extra signal/slot between view and model, so the view can be updated instantly when
                 // there is a change of data in the model
                 connect(variableModel, SIGNAL(dataChanged(const QModelIndex &, const QModelIndex &)), this,
                         SLOT(refresh()));
                 ui->tableView->setSelectionModel(sqpApp->variableController().variableSelectionModel());
                 ui->tableView->setItemDelegateForColumn(0, m_ProgressBarItemDelegate);
                 // Fixes column sizes
                 auto model = ui->tableView->model();
                 const auto count = model->columnCount();
                 for (auto i = 0; i < count; ++i) {
                     ui->tableView->setColumnWidth(
                         i, model->headerData(i, Qt::Horizontal, Qt::SizeHintRole).toSize().width());
                 }
                 // Sets selection options
                 ui->tableView->setSelectionBehavior(QTableView::SelectRows);
                 ui->tableView->setSelectionMode(QTableView::ExtendedSelection);
                 // Connection to show a menu when right clicking on the tree
                 ui->tableView->setContextMenuPolicy(Qt::CustomContextMenu);
                 connect(ui->tableView, &QTableView::customContextMenuRequested, this,
                         &VariableInspectorWidget::onTableMenuRequested);
             }
             VariableInspectorWidget::~VariableInspectorWidget()
             {
                 delete ui;
             }
             void VariableInspectorWidget::onTableMenuRequested(const QPoint &pos) noexcept
             {
                 auto selectedRows = ui->tableView->selectionModel()->selectedRows();
                 // Gets the model to retrieve the underlying selected variables
                 auto model = sqpApp->variableController().variableModel();
                 auto selectedVariables = QVector<std::shared_ptr<Variable> >{};
                 for (const auto &selectedRow : qAsConst(selectedRows)) {
                     if (auto selectedVariable = model->variable(selectedRow.row())) {
                         selectedVariables.push_back(selectedVariable);
                     }
                 }
                 QMenu tableMenu{};
                 // Emits a signal so that potential receivers can populate the menu before displaying it
                 emit tableMenuAboutToBeDisplayed(&tableMenu, selectedVariables);
                 // Adds menu-specific actions
                 if (!selectedVariables.isEmpty()) {
                     // 'Delete' action
                     auto deleteFun = [&selectedVariables]() {
                         sqpApp->variableController().deleteVariables(selectedVariables);
                     };
                     tableMenu.addSeparator();
                     tableMenu.addAction(QIcon{":/icones/delete.png"}, tr("Delete"), deleteFun);
                 }
                 if (!tableMenu.isEmpty()) {
                     // Generates menu header (inserted before first action)
                     auto firstAction = tableMenu.actions().first();
                     auto headerAction = new QWidgetAction{&tableMenu};
                     headerAction->setDefaultWidget(new VariableMenuHeaderWidget{selectedVariables, &tableMenu});
                     tableMenu.insertAction(firstAction, headerAction);
                     // Displays menu
-                    tableMenu.exec(mapToGlobal(pos));
+                    tableMenu.exec(QCursor::pos());
                 }
             }
             void VariableInspectorWidget::refresh() noexcept
             {
                 ui->tableView->viewport()->update();
             }

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

             #include "Visualization/VisualizationGraphWidget.h"
             #include "Visualization/IVisualizationWidgetVisitor.h"
             #include "Visualization/VisualizationDefs.h"
             #include "Visualization/VisualizationGraphHelper.h"
             #include "Visualization/VisualizationGraphRenderingDelegate.h"
             #include "ui_VisualizationGraphWidget.h"
             #include <Data/ArrayData.h>
             #include <Data/IDataSeries.h>
             #include <Settings/SqpSettingsDefs.h>
             #include <SqpApplication.h>
             #include <Variable/Variable.h>
             #include <Variable/VariableController.h>
             #include <unordered_map>
             Q_LOGGING_CATEGORY(LOG_VisualizationGraphWidget, "VisualizationGraphWidget")
             namespace {
             /// Key pressed to enable zoom on horizontal axis
             const auto HORIZONTAL_ZOOM_MODIFIER = Qt::NoModifier;
             /// Key pressed to enable zoom on vertical axis
             const auto VERTICAL_ZOOM_MODIFIER = Qt::ControlModifier;
             } // namespace
             struct VisualizationGraphWidget::VisualizationGraphWidgetPrivate {
                 explicit VisualizationGraphWidgetPrivate()
                         : m_DoAcquisition{true}, m_IsCalibration{false}, m_RenderingDelegate{nullptr}
                 {
                 }
                 // 1 variable -> n qcpplot
                 std::map<std::shared_ptr<Variable>, PlottablesMap> m_VariableToPlotMultiMap;
                 bool m_DoAcquisition;
                 bool m_IsCalibration;
                 QCPItemTracer *m_TextTracer;
                 /// Delegate used to attach rendering features to the plot
                 std::unique_ptr<VisualizationGraphRenderingDelegate> m_RenderingDelegate;
             };
             VisualizationGraphWidget::VisualizationGraphWidget(const QString &name, QWidget *parent)
                     : QWidget{parent},
                       ui{new Ui::VisualizationGraphWidget},
                       impl{spimpl::make_unique_impl<VisualizationGraphWidgetPrivate>()}
             {
                 ui->setupUi(this);
                 // The delegate must be initialized after the ui as it uses the plot
                 impl->m_RenderingDelegate = std::make_unique<VisualizationGraphRenderingDelegate>(*ui->widget);
                 ui->graphNameLabel->setText(name);
                 // 'Close' options : widget is deleted when closed
                 setAttribute(Qt::WA_DeleteOnClose);
                 connect(ui->closeButton, &QToolButton::clicked, this, &VisualizationGraphWidget::close);
                 ui->closeButton->setIcon(sqpApp->style()->standardIcon(QStyle::SP_TitleBarCloseButton));
                 // Set qcpplot properties :
                 // - Drag (on x-axis) and zoom are enabled
                 // - Mouse wheel on qcpplot is intercepted to determine the zoom orientation
                 ui->widget->setInteractions(QCP::iRangeDrag | QCP::iRangeZoom);
                 ui->widget->axisRect()->setRangeDrag(Qt::Horizontal);
                 connect(ui->widget, &QCustomPlot::mousePress, this, &VisualizationGraphWidget::onMousePress);
                 connect(ui->widget, &QCustomPlot::mouseRelease, this,
                         &VisualizationGraphWidget::onMouseRelease);
                 connect(ui->widget, &QCustomPlot::mouseMove, this, &VisualizationGraphWidget::onMouseMove);
                 connect(ui->widget, &QCustomPlot::mouseWheel, this, &VisualizationGraphWidget::onMouseWheel);
                 connect(ui->widget->xAxis, 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);
                 connect(ui->widget, &QCustomPlot::customContextMenuRequested, this,
                         &VisualizationGraphWidget::onGraphMenuRequested);
                 connect(this, &VisualizationGraphWidget::requestDataLoading, &sqpApp->variableController(),
                         &VariableController::onRequestDataLoading);
                 connect(&sqpApp->variableController(), &VariableController::updateVarDisplaying, this,
                         &VisualizationGraphWidget::onUpdateVarDisplaying);
             }
             VisualizationGraphWidget::~VisualizationGraphWidget()
             {
                 delete ui;
             }
             void VisualizationGraphWidget::enableAcquisition(bool enable)
             {
                 impl->m_DoAcquisition = enable;
             }
             void VisualizationGraphWidget::addVariable(std::shared_ptr<Variable> variable, SqpRange range)
             {
                 // Uses delegate to create the qcpplot components according to the variable
                 auto createdPlottables = VisualizationGraphHelper::create(variable, *ui->widget);
                 impl->m_VariableToPlotMultiMap.insert({variable, std::move(createdPlottables)});
                 connect(variable.get(), SIGNAL(updated()), this, SLOT(onDataCacheVariableUpdated()));
                 auto varRange = variable->range();
                 this->enableAcquisition(false);
                 this->setGraphRange(range);
                 this->enableAcquisition(true);
                 emit requestDataLoading(QVector<std::shared_ptr<Variable> >() << variable, range, varRange,
                                         false);
                 emit variableAdded(variable);
             }
             void VisualizationGraphWidget::removeVariable(std::shared_ptr<Variable> variable) noexcept
             {
                 // Each component associated to the variable :
                 // - is removed from qcpplot (which deletes it)
                 // - is no longer referenced in the map
                 auto variableIt = impl->m_VariableToPlotMultiMap.find(variable);
                 if (variableIt != impl->m_VariableToPlotMultiMap.cend()) {
                     auto &plottablesMap = variableIt->second;
                     for (auto plottableIt = plottablesMap.cbegin(), plottableEnd = plottablesMap.cend();
                          plottableIt != plottableEnd;) {
                         ui->widget->removePlottable(plottableIt->second);
                         plottableIt = plottablesMap.erase(plottableIt);
                     }
                     impl->m_VariableToPlotMultiMap.erase(variableIt);
                 }
                 // Updates graph
                 ui->widget->replot();
             }
             void VisualizationGraphWidget::setRange(std::shared_ptr<Variable> variable, const SqpRange &range)
             {
                 // Note: in case of different axes that depends on variable, we could start with a code like
                 // that:
                 //    auto componentsIt = impl->m_VariableToPlotMultiMap.equal_range(variable);
                 //    for (auto it = componentsIt.first; it != componentsIt.second;) {
                 //    }
                 ui->widget->xAxis->setRange(range.m_TStart, range.m_TEnd);
                 ui->widget->replot();
             }
             void VisualizationGraphWidget::setYRange(const SqpRange &range)
             {
                 ui->widget->yAxis->setRange(range.m_TStart, range.m_TEnd);
             }
             SqpRange VisualizationGraphWidget::graphRange() const noexcept
             {
                 auto graphRange = ui->widget->xAxis->range();
                 return SqpRange{graphRange.lower, graphRange.upper};
             }
             void VisualizationGraphWidget::setGraphRange(const SqpRange &range)
             {
                 qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::setGraphRange START");
                 ui->widget->xAxis->setRange(range.m_TStart, range.m_TEnd);
                 ui->widget->replot();
                 qCDebug(LOG_VisualizationGraphWidget()) << tr("VisualizationGraphWidget::setGraphRange END");
             }
             void VisualizationGraphWidget::accept(IVisualizationWidgetVisitor *visitor)
             {
                 if (visitor) {
                     visitor->visit(this);
                 }
                 else {
                     qCCritical(LOG_VisualizationGraphWidget())
                         << tr("Can't visit widget : the visitor is null");
                 }
             }
             bool VisualizationGraphWidget::canDrop(const Variable &variable) const
             {
                 /// @todo : for the moment, a graph can always accomodate a variable
                 Q_UNUSED(variable);
                 return true;
             }
             bool VisualizationGraphWidget::contains(const Variable &variable) const
             {
                 // Finds the variable among the keys of the map
                 auto variablePtr = &variable;
                 auto findVariable
                     = [variablePtr](const auto &entry) { return variablePtr == entry.first.get(); };
                 auto end = impl->m_VariableToPlotMultiMap.cend();
                 auto it = std::find_if(impl->m_VariableToPlotMultiMap.cbegin(), end, findVariable);
                 return it != end;
             }
             QString VisualizationGraphWidget::name() const
             {
                 return ui->graphNameLabel->text();
             }
             void VisualizationGraphWidget::onGraphMenuRequested(const QPoint &pos) noexcept
             {
                 QMenu graphMenu{};
                 // Iterates on variables (unique keys)
                 for (auto it = impl->m_VariableToPlotMultiMap.cbegin(),
                           end = impl->m_VariableToPlotMultiMap.cend();
                      it != end; it = impl->m_VariableToPlotMultiMap.upper_bound(it->first)) {
                     // 'Remove variable' action
                     graphMenu.addAction(tr("Remove variable %1").arg(it->first->name()),
                                         [ this, var = it->first ]() { removeVariable(var); });
                 }
                 if (!graphMenu.isEmpty()) {
-                    graphMenu.exec(mapToGlobal(pos));
+                    graphMenu.exec(QCursor::pos());
                 }
             }
             void VisualizationGraphWidget::onRangeChanged(const QCPRange &t1, const QCPRange &t2)
             {
                 qCDebug(LOG_VisualizationGraphWidget()) << tr("TORM: VisualizationGraphWidget::onRangeChanged")
                                                         << QThread::currentThread()->objectName() << "DoAcqui"
                                                         << impl->m_DoAcquisition;
                 auto graphRange = SqpRange{t1.lower, t1.upper};
                 auto oldGraphRange = SqpRange{t2.lower, t2.upper};
                 if (impl->m_DoAcquisition) {
                     QVector<std::shared_ptr<Variable> > variableUnderGraphVector;
                     for (auto it = impl->m_VariableToPlotMultiMap.begin(),
                               end = impl->m_VariableToPlotMultiMap.end();
                          it != end; it = impl->m_VariableToPlotMultiMap.upper_bound(it->first)) {
                         variableUnderGraphVector.push_back(it->first);
                     }
                     emit requestDataLoading(std::move(variableUnderGraphVector), graphRange, oldGraphRange,
                                             !impl->m_IsCalibration);
                     if (!impl->m_IsCalibration) {
                         qCDebug(LOG_VisualizationGraphWidget())
                             << tr("TORM: VisualizationGraphWidget::Synchronize notify !!")
                             << QThread::currentThread()->objectName() << graphRange << oldGraphRange;
                         emit synchronize(graphRange, oldGraphRange);
                     }
                 }
             }
             void VisualizationGraphWidget::onMouseMove(QMouseEvent *event) noexcept
             {
                 // Handles plot rendering when mouse is moving
                 impl->m_RenderingDelegate->onMouseMove(event);
             }
             void VisualizationGraphWidget::onMouseWheel(QWheelEvent *event) noexcept
             {
                 auto zoomOrientations = QFlags<Qt::Orientation>{};
                 // Lambda that enables a zoom orientation if the key modifier related to this orientation
                 // has
                 // been pressed
                 auto enableOrientation
                     = [&zoomOrientations, event](const auto &orientation, const auto &modifier) {
                           auto orientationEnabled = event->modifiers().testFlag(modifier);
                           zoomOrientations.setFlag(orientation, orientationEnabled);
                       };
                 enableOrientation(Qt::Vertical, VERTICAL_ZOOM_MODIFIER);
                 enableOrientation(Qt::Horizontal, HORIZONTAL_ZOOM_MODIFIER);
                 ui->widget->axisRect()->setRangeZoom(zoomOrientations);
             }
             void VisualizationGraphWidget::onMousePress(QMouseEvent *event) noexcept
             {
                 impl->m_IsCalibration = event->modifiers().testFlag(Qt::ControlModifier);
             }
             void VisualizationGraphWidget::onMouseRelease(QMouseEvent *event) noexcept
             {
                 impl->m_IsCalibration = false;
             }
             void VisualizationGraphWidget::onDataCacheVariableUpdated()
             {
                 auto graphRange = ui->widget->xAxis->range();
                 auto dateTime = SqpRange{graphRange.lower, graphRange.upper};
                 for (auto &variableEntry : impl->m_VariableToPlotMultiMap) {
                     auto variable = variableEntry.first;
                     qCDebug(LOG_VisualizationGraphWidget())
                         << "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated S" << variable->range();
                     qCDebug(LOG_VisualizationGraphWidget())
                         << "TORM: VisualizationGraphWidget::onDataCacheVariableUpdated E" << dateTime;
                     if (dateTime.contains(variable->range()) || dateTime.intersect(variable->range())) {
                         VisualizationGraphHelper::updateData(variableEntry.second, variable->dataSeries(),
                                                              variable->range());
                     }
                 }
             }
             void VisualizationGraphWidget::onUpdateVarDisplaying(std::shared_ptr<Variable> variable,
                                                                  const SqpRange &range)
             {
                 auto it = impl->m_VariableToPlotMultiMap.find(variable);
                 if (it != impl->m_VariableToPlotMultiMap.end()) {
                     VisualizationGraphHelper::updateData(it->second, variable->dataSeries(), range);
                 }
             }

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