}

void ChannelInfoModel::resetInfos()

{

    beginResetModel();

    for (unsigned ci = 0; (int) ci < infos.length(); ci++)

    {

        infos[ci] = ChannelInfo(ci);

    }

    endResetModel();

}

void ChannelInfoModel::resetNames()

{

    beginResetModel();

    for (unsigned ci = 0; (int) ci < infos.length(); ci++)

    {

        infos[ci].name = ChannelInfo(ci).name;

    }

    endResetModel();

}

void ChannelInfoModel::resetColors()

{

}

void ChannelInfoModel::resetVisibility(bool visible)

{

    beginResetModel();

    for (unsigned ci = 0; (int) ci < infos.length(); ci++)

    {

        infos[ci].visibility = visible;

    }

    endResetModel();

}

void ChannelInfoModel::saveSettings(QSettings* settings) const

{

    settings->beginGroup(SettingGroup_Channels);

    settings->beginWriteArray(SG_Channels_Channel);

    // save all channel information regardless of current number of channels

    for (unsigned ci = 0; (int) ci < infos.length(); ci++)

    {

        settings->setArrayIndex(ci);

        settings->setValue(SG_Channels_Name, infos[ci].name);

        settings->setValue(SG_Channels_Color, infos[ci].color);

        settings->setValue(SG_Channels_Visible, infos[ci].visibility);

    /// Stores all channel info into a `QSettings`

    void saveSettings(QSettings* settings) const;

    /// Loads all channel info from a `QSettings`.

    void loadSettings(QSettings* settings);

public slots:

    /// reset all channel info (names, color etc.)

    void resetInfos();

    /// reset all channel names

    void resetNames();

    /// reset all channel colors

    void resetColors();

    /// reset visibility

    void resetVisibility(bool visible);

private:

    struct ChannelInfo

    {

        explicit ChannelInfo(unsigned index);

        QString name;

        bool visibility;

        QColor color;

        double gain, offset;

            return w;

        }

};

PlotControlPanel::PlotControlPanel(QWidget *parent) :

    QWidget(parent),

    ui(new Ui::PlotControlPanel),

    resetAct(tr("Reset"), this),

    resetNamesAct(tr("Reset Names"), this),

    resetColorsAct(tr("Reset Colors"), this),

    showAllAct(tr("Show All"), this),

    hideAllAct(tr("Hide All"), this),

    resetMenu(tr("Reset Menu"), this)

{

    ui->setupUi(this);

    delegate = new SpinBoxDelegate();

    ui->tvChannelInfo->setItemDelegate(delegate);

    warnNumOfSamples = true;    // TODO: load from settings

    _numOfSamples = ui->spNumOfSamples->value();

    // set limits for axis limit boxes

    ui->spYmin->setRange((-1) * std::numeric_limits<double>::max(),

    QObject::connect(ui->cbRangePresets, SIGNAL(activated(int)),

                     this, SLOT(onRangeSelected()));

    // color selector starts disabled until a channel is selected

    ui->colorSelector->setColor(QColor(0,0,0,0));

    ui->colorSelector->setDisplayMode(color_widgets::ColorPreview::AllAlpha);

    ui->colorSelector->setDisabled(true);

    // reset buttons

    resetAct.setToolTip(tr("Reset channel names and colors"));

    resetMenu.addAction(&resetNamesAct);

    resetMenu.addAction(&resetColorsAct);

    resetAct.setMenu(&resetMenu);

    ui->tbReset->setDefaultAction(&resetAct);

    showAllAct.setToolTip(tr("Show all channels"));

    hideAllAct.setToolTip(tr("Hide all channels"));

    ui->tbShowAll->setDefaultAction(&showAllAct);

    ui->tbHideAll->setDefaultAction(&hideAllAct);

}

PlotControlPanel::~PlotControlPanel()

{

    delete ui;

                QColor color = mod->data(current, Qt::ForegroundRole).value<QColor>();

                // temporarily block signals because `setColor` emits `colorChanged`

                bool wasBlocked = ui->colorSelector->blockSignals(true);

                ui->colorSelector->setColor(color);

                ui->colorSelector->blockSignals(wasBlocked);

            });

    // reset actions

    connect(&resetAct, &QAction::triggered, model, &ChannelInfoModel::resetInfos);

    connect(&resetNamesAct, &QAction::triggered, model, &ChannelInfoModel::resetNames);

    connect(&resetColorsAct, &QAction::triggered, model, &ChannelInfoModel::resetColors);

    connect(&showAllAct, &QAction::triggered, [model]{model->resetVisibility(true);});

    connect(&hideAllAct, &QAction::triggered, [model]{model->resetVisibility(false);});

}

void PlotControlPanel::saveSettings(QSettings* settings)

{

    settings->beginGroup(SettingGroup_Plot);

    settings->setValue(SG_Plot_NumOfSamples, numOfSamples());

    settings->setValue(SG_Plot_PlotWidth, ui->spPlotWidth->value());

    settings->setValue(SG_Plot_IndexAsX, xAxisAsIndex());

    settings->setValue(SG_Plot_XMax, xMax());

    settings->setValue(SG_Plot_XMin, xMin());

    void yScaleChanged(bool autoScaled, double yMin = 0, double yMax = 1);

    void xScaleChanged(bool asIndex, double xMin = 0, double xMax = 1);

    void plotWidthChanged(double width);

private:

    Ui::PlotControlPanel *ui;

    /// Holds 'number of samples' after the confirmation

    unsigned _numOfSamples;

    /// User can disable this setting in the checkbox

    bool warnNumOfSamples;

    QMenu resetMenu;

    QStyledItemDelegate* delegate;

    /// Show a confirmation dialog before setting #samples to a big value

    bool askNSConfirmation(int value);

private slots:

    void onNumOfSamples(int value);

    void onAutoScaleChecked(bool checked);

    void onYScaleChanged();

    void onRangeSelected();

    void onIndexChecked(bool checked);