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

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

    ui->colorSelector->setDisabled(true);

    // reset button

    resetMenu.addAction(&resetNamesAct);

    resetMenu.addAction(&resetColorsAct);

    resetMenu.addAction(&showAllAct);

    resetAct.setMenu(&resetMenu);

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

}

PlotControlPanel::~PlotControlPanel()

{

    delete ui;

}

unsigned PlotControlPanel::numOfSamples()

{

    return ui->spNumOfSamples->value();

}

void PlotControlPanel::onNumOfSamples(int value)

{

    if (warnNumOfSamples && value > NUMSAMPLES_CONFIRM_AT)

    {

        // ask confirmation

        if (!askNSConfirmation(value))

        {

            // revert to old value

            disconnect(ui->spNumOfSamples, SIGNAL(valueChanged(int)),

                       this, SLOT(onNumOfSamples(int)));

            ui->spNumOfSamples->setValue(_numOfSamples);

            connect(ui->spNumOfSamples, SIGNAL(valueChanged(int)),

                    this, SLOT(onNumOfSamples(int)));

            return;

        }

    }

    _numOfSamples = value;

    emit numOfSamplesChanged(value);

}

bool PlotControlPanel::askNSConfirmation(int value)

{

    auto text = tr("Setting number of samples to a too big value "

                   "(>%1) can seriously impact the performance of "

                   "the application and cause freezes. Are you sure you "

                   "want to change the number of samples to %2?")

        .arg(QString::number(NUMSAMPLES_CONFIRM_AT), QString::number(value));

    // TODO: parent the mainwindow

    QMessageBox mb(QMessageBox::Warning,

                   tr("Confirm Number of Samples"),

                   text,

                   QMessageBox::Apply | QMessageBox::Cancel,

                   this);

    auto cb = new QCheckBox("Don't show this again.");

    connect(cb, &QCheckBox::stateChanged, [this](int state)

            {

                warnNumOfSamples = (state == Qt::Unchecked);

            });

    mb.setCheckBox(cb);

    return mb.exec() == QMessageBox::Apply;

}

void PlotControlPanel::onAutoScaleChecked(bool checked)

{

    if (checked)

    {

        ui->lYmin->setEnabled(false);

        ui->lYmax->setEnabled(false);

        ui->spYmin->setEnabled(false);

        ui->spYmax->setEnabled(false);

        emit yScaleChanged(true); // autoscale

    }

    else

    {

        ui->lYmin->setEnabled(true);

        ui->lYmax->setEnabled(true);

        ui->spYmin->setEnabled(true);

        ui->spYmax->setEnabled(true);

        emit yScaleChanged(false, ui->spYmin->value(), ui->spYmax->value());

    }

}

void PlotControlPanel::onYScaleChanged()

{

}

bool PlotControlPanel::autoScale() const

{

    return ui->cbAutoScale->isChecked();

}

double PlotControlPanel::yMax() const

{

    return ui->spYmax->value();

}

double PlotControlPanel::yMin() const

{

    return ui->spYmin->value();

}

bool PlotControlPanel::xAxisAsIndex() const

{

    return ui->cbIndex->isChecked();

}

double PlotControlPanel::xMax() const

{

    return ui->spXmax->value();

}

double PlotControlPanel::xMin() const

{

    return ui->spXmin->value();

}

void PlotControlPanel::onRangeSelected()

{

    Range r = ui->cbRangePresets->currentData().value<Range>();

    ui->spYmin->setValue(r.rmin);

    ui->spYmax->setValue(r.rmax);

    ui->cbAutoScale->setChecked(false);

}

void PlotControlPanel::onIndexChecked(bool checked)

{

    if (checked)

    {

        ui->lXmin->setEnabled(false);

        ui->lXmax->setEnabled(false);

        ui->spXmin->setEnabled(false);

        ui->spXmax->setEnabled(false);

        emit xScaleChanged(true); // use index

    }

    else

    {

        ui->lXmin->setEnabled(true);

        ui->lXmax->setEnabled(true);

        ui->spXmin->setEnabled(true);

        ui->spXmax->setEnabled(true);

        emit xScaleChanged(false, ui->spXmin->value(), ui->spXmax->value());

    }

}

void PlotControlPanel::onXScaleChanged()

{

}

void PlotControlPanel::setChannelInfoModel(ChannelInfoModel* model)

{

    ui->tvChannelInfo->setModel(model);

    // channel color selector

    connect(ui->tvChannelInfo->selectionModel(), &QItemSelectionModel::currentRowChanged,

            [this](const QModelIndex &current, const QModelIndex &previous)

            {

                // TODO: duplicate with below lambda

                QColor color(0,0,0,0); // transparent

                if (current.isValid())

                {

                    ui->colorSelector->setEnabled(true);

                    auto model = ui->tvChannelInfo->model();

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

                }

                else

                {

                    ui->colorSelector->setDisabled(true);

                }

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

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

                ui->colorSelector->setColor(color);

                ui->colorSelector->blockSignals(wasBlocked);

            });

    connect(ui->tvChannelInfo->selectionModel(), &QItemSelectionModel::selectionChanged,

            [this](const QItemSelection & selected, const QItemSelection & deselected)

            {

                if (!selected.length())

                {

                    ui->colorSelector->setDisabled(true);

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

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

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

                    ui->colorSelector->blockSignals(wasBlocked);

                }

            });

    connect(ui->colorSelector, &color_widgets::ColorSelector::colorChanged,

            [this](QColor color)

            {

                auto index = ui->tvChannelInfo->selectionModel()->currentIndex();

                ui->tvChannelInfo->model()->setData(index, color, Qt::ForegroundRole);

            });

    connect(model, &QAbstractItemModel::dataChanged,

            [this](const QModelIndex & topLeft, const QModelIndex & bottomRight, const QVector<int> & roles = QVector<int> ())

            {

                auto current = ui->tvChannelInfo->selectionModel()->currentIndex();

                // no current selection

                if (!current.isValid()) return;

                auto mod = ui->tvChannelInfo->model();

                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, &ChannelInfoModel::resetVisibility);

}

void PlotControlPanel::saveSettings(QSettings* settings)

{

    settings->beginGroup(SettingGroup_Plot);

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

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

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

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

    settings->setValue(SG_Plot_AutoScale, autoScale());

    settings->setValue(SG_Plot_YMax, yMax());

    settings->setValue(SG_Plot_YMin, yMin());

    settings->endGroup();

}

void PlotControlPanel::loadSettings(QSettings* settings)

{

    settings->beginGroup(SettingGroup_Plot);

    ui->spNumOfSamples->setValue(

        settings->value(SG_Plot_NumOfSamples, numOfSamples()).toInt());

    ui->cbIndex->setChecked(

        settings->value(SG_Plot_IndexAsX, xAxisAsIndex()).toBool());

    ui->spXmax->setValue(settings->value(SG_Plot_XMax, xMax()).toDouble());