double PlotControlPanel::plotWidth() const

{

    double value = ui->spPlotWidth->value();

    if (!xAxisAsIndex())

    {

        // scale by xmin and xmax

        auto xmax = ui->spXmax->value();

        auto xmin = ui->spXmin->value();

        double scale = (xmax - xmin) / _numOfSamples;

        value *= scale;

    }

    return value;

}

void PlotControlPanel::onPlotWidthChanged()

{

    emit plotWidthChanged(plotWidth());

}

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());

    ui->spXmin->setValue(settings->value(SG_Plot_XMin, xMin()).toDouble());

    ui->cbAutoScale->setChecked(

        settings->value(SG_Plot_AutoScale, autoScale()).toBool());

    ui->spYmax->setValue(settings->value(SG_Plot_YMax, yMax()).toDouble());

    ui->spYmin->setValue(settings->value(SG_Plot_YMin, yMin()).toDouble());

    settings->endGroup();

}

/*

  Copyright © 2017 Hasan Yavuz Özderya

  This file is part of serialplot.

  serialplot is free software: you can redistribute it and/or modify

  it under the terms of the GNU General Public License as published by

  the Free Software Foundation, either version 3 of the License, or

  (at your option) any later version.

  serialplot is distributed in the hope that it will be useful,

  but WITHOUT ANY WARRANTY; without even the implied warranty of

  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License

  along with serialplot.  If not, see <http://www.gnu.org/licenses/>.

*/

#ifndef PLOTCONTROLPANEL_H

#define PLOTCONTROLPANEL_H

#include <QWidget>

#include <QSettings>

#include <QAction>

#include <QMenu>

#include "channelinfomodel.h"

namespace Ui {

class PlotControlPanel;

}

class PlotControlPanel : public QWidget

{

    Q_OBJECT

public:

    explicit PlotControlPanel(QWidget *parent = 0);

    ~PlotControlPanel();

    unsigned numOfSamples();

    bool   autoScale() const;

    double yMax() const;

    double yMin() const;

    bool   xAxisAsIndex() const;

    double xMax() const;

    double xMin() const;

    double plotWidth() const;

    void setChannelInfoModel(ChannelInfoModel* model);

    /// Stores plot settings into a `QSettings`

    void saveSettings(QSettings* settings);

    /// Loads plot settings from a `QSettings`.

    void loadSettings(QSettings* settings);

signals:

    void numOfSamplesChanged(int value);

    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;

    QAction resetAct, resetNamesAct, resetColorsAct, showAllAct;

    QMenu resetMenu;

    /// 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);

    void onXScaleChanged();

    void onPlotWidthChanged();

};

#endif // PLOTCONTROLPANEL_H

/*

  Copyright © 2017 Hasan Yavuz Özderya

  This file is part of serialplot.

  serialplot is free software: you can redistribute it and/or modify

  it under the terms of the GNU General Public License as published by

  the Free Software Foundation, either version 3 of the License, or

  (at your option) any later version.

  serialplot is distributed in the hope that it will be useful,

  but WITHOUT ANY WARRANTY; without even the implied warranty of

  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License

  along with serialplot.  If not, see <http://www.gnu.org/licenses/>.

*/

#ifndef SETTING_DEFINES_H

#define SETTING_DEFINES_H

const char SettingGroup_MainWindow[] = "MainWindow";

const char SettingGroup_Port[] = "Port";

const char SettingGroup_DataFormat[] = "DataFormat";

const char SettingGroup_Binary[] = "DataFormat_Binary";

const char SettingGroup_ASCII[] = "DataFormat_ASCII";

const char SettingGroup_CustomFrame[] = "DataFormat_CustomFrame";

const char SettingGroup_Channels[] = "Channels";

const char SettingGroup_Plot[] = "Plot";

const char SettingGroup_Commands[] = "Commands";

const char SettingGroup_Record[] = "Record";

// mainwindow setting keys

const char SG_MainWindow_Size[] = "size";

const char SG_MainWindow_Pos[] = "pos";

const char SG_MainWindow_ActivePanel[] = "activePanel";

const char SG_MainWindow_HidePanels[] = "hidePanels";

const char SG_MainWindow_Maximized[] = "maximized";

const char SG_MainWindow_State[] = "state";

// port setting keys

const char SG_Port_SelectedPort[] = "selectedPort";

const char SG_Port_BaudRate[] = "baudRate";

const char SG_Port_Parity[] = "parity";

const char SG_Port_DataBits[] = "dataBits";

const char SG_Port_StopBits[] = "stopBits";

const char SG_Port_FlowControl[] = "flowControl";

// data format panel keys

const char SG_DataFormat_Format[] = "format";

// binary stream reader keys

const char SG_Binary_NumOfChannels[] = "numOfChannels";

const char SG_Binary_NumberFormat[] = "numberFormat";

const char SG_Binary_Endianness[] = "endianness";

// ascii reader keys

const char SG_ASCII_NumOfChannels[] = "numOfChannels";

// framed reader keys

const char SG_CustomFrame_NumOfChannels[] = "numOfChannels";

const char SG_CustomFrame_FrameStart[] = "frameStart";

const char SG_CustomFrame_FixedSize[] = "fixedSize";

const char SG_CustomFrame_FrameSize[] = "frameSize";

const char SG_CustomFrame_NumberFormat[] = "numberFormat";

const char SG_CustomFrame_Endianness[] = "endianness";

const char SG_CustomFrame_Checksum[] = "checksum";

const char SG_CustomFrame_DebugMode[] = "debugMode";

// channel manager keys

const char SG_Channels_Channel[] = "channel";

const char SG_Channels_Name[] = "name";

const char SG_Channels_Color[] = "color";

const char SG_Channels_Visible[] = "visible";

// plot settings keys

const char SG_Plot_NumOfSamples[] = "numOfSamples";

const char SG_Plot_IndexAsX[] = "indexAsX";

const char SG_Plot_XMax[] = "xMax";

const char SG_Plot_XMin[] = "xMin";

const char SG_Plot_AutoScale[] = "autoScale";

const char SG_Plot_YMax[] = "yMax";

const char SG_Plot_YMin[] = "yMin";

const char SG_Plot_DarkBackground[] = "darkBackground";

const char SG_Plot_Grid[] = "grid";

const char SG_Plot_MinorGrid[] = "minorGrid";

const char SG_Plot_Legend[] = "legend";

const char SG_Plot_MultiPlot[] = "multiPlot";

const char SG_Plot_Symbols[] = "symbols";

// command setting keys

const char SG_Commands_Command[] = "command";

const char SG_Commands_Name[] = "name";

const char SG_Commands_Type[] = "type";

const char SG_Commands_Data[] = "data";

// record panel settings keys

const char SG_Record_AutoIncrement[]    = "autoIncrement";

const char SG_Record_RecordPaused[]     = "recordPaused";

const char SG_Record_StopOnClose[]      = "stopOnClose";

const char SG_Record_Header[]           = "header";

const char SG_Record_Separator[]        = "separator";

const char SG_Record_DisableBuffering[] = "disableBuffering";

#endif // SETTING_DEFINES_H