Q_IMPORT_PLUGIN(QWindowsIntegrationPlugin)

#endif

const QMap<int, QString> panelSettingMap({

        {0, "Port"},

        {1, "DataFormat"},

        {2, "Plot"},

        {3, "Commands"}

    });

MainWindow::MainWindow(QWidget *parent) :

    QMainWindow(parent),

    ui(new Ui::MainWindow),

    aboutDialog(this),

    portControl(&serialPort),

    channelMan(1, 1, this),

    snapshotMan(this, &channelMan),

    commandPanel(&serialPort),

    dataFormatPanel(&serialPort, &channelMan, &recorder),

    recordPanel(&recorder, &channelMan)

{

    ui->setupUi(this);

    plotMan = new PlotManager(ui->plotArea, channelMan.infoModel());

    ui->tabWidget->insertTab(0, &portControl, "Port");

    ui->tabWidget->insertTab(1, &dataFormatPanel, "Data Format");

    ui->tabWidget->insertTab(2, &plotControlPanel, "Plot");

    ui->tabWidget->insertTab(3, &commandPanel, "Commands");

    ui->tabWidget->insertTab(4, &recordPanel, "Record");

    ui->tabWidget->setCurrentIndex(0);

    auto tbPortControl = portControl.toolBar();

    addToolBar(tbPortControl);

    addToolBar(recordPanel.toolbar());

    ui->plotToolBar->addAction(snapshotMan.takeSnapshotAction());

    ui->menuBar->insertMenu(ui->menuHelp->menuAction(), snapshotMan.menu());

    ui->menuBar->insertMenu(ui->menuHelp->menuAction(), commandPanel.menu());

    connect(&commandPanel, &CommandPanel::focusRequested, [this]()

            {

                this->ui->tabWidget->setCurrentWidget(&commandPanel);

            });

    tbPortControl->setObjectName("tbPortControl");

    ui->plotToolBar->setObjectName("tbPlot");

    setupAboutDialog();

    // init view menu

    for (auto a : plotMan->menuActions())

    {

        ui->menuView->addAction(a);

    }

    ui->menuView->addSeparator();

    QMenu* tbMenu = ui->menuView->addMenu("Toolbars");

    tbMenu->addAction(ui->plotToolBar->toggleViewAction());

    tbMenu->addAction(portControl.toolBar()->toggleViewAction());

    // init UI signals

    // Help menu signals

    QObject::connect(ui->actionHelpAbout, &QAction::triggered,

              &aboutDialog, &QWidget::show);

    QObject::connect(ui->actionReportBug, &QAction::triggered,

                     [](){QDesktopServices::openUrl(QUrl(BUG_REPORT_URL));});

    // File menu signals

    QObject::connect(ui->actionExportCsv, &QAction::triggered,

                     this, &MainWindow::onExportCsv);

    QObject::connect(ui->actionSaveSettings, &QAction::triggered,

                     this, &MainWindow::onSaveSettings);

    QObject::connect(ui->actionLoadSettings, &QAction::triggered,

                     this, &MainWindow::onLoadSettings);

    ui->actionQuit->setShortcutContext(Qt::ApplicationShortcut);

    QObject::connect(ui->actionQuit, &QAction::triggered,

                     this, &MainWindow::close);

    // port control signals

    QObject::connect(&portControl, &PortControl::portToggled,

                     this, &MainWindow::onPortToggled);

    connect(&plotControlPanel, &PlotControlPanel::numOfSamplesChanged,

            this, &MainWindow::onNumOfSamplesChanged);

    connect(&plotControlPanel, &PlotControlPanel::numOfSamplesChanged,

            plotMan, &PlotManager::onNumOfSamplesChanged);

    connect(&plotControlPanel, &PlotControlPanel::yScaleChanged,

    QObject::connect(ui->actionClear, SIGNAL(triggered(bool)),

                     this, SLOT(clearPlot()));

    QObject::connect(snapshotMan.takeSnapshotAction(), &QAction::triggered,

                     plotMan, &PlotManager::flashSnapshotOverlay);

    // init port signals

    QObject::connect(&(this->serialPort), SIGNAL(error(QSerialPort::SerialPortError)),

                     this, SLOT(onPortError(QSerialPort::SerialPortError)));

    // init data format and reader

    QObject::connect(&channelMan, &ChannelManager::dataAdded,

                     plotMan, &PlotManager::replot);

    QObject::connect(ui->actionPause, &QAction::triggered,

                     &channelMan, &ChannelManager::pause);

    QObject::connect(&recordPanel, &RecordPanel::recordStarted,

                     &dataFormatPanel, &DataFormatPanel::startRecording);

    QObject::connect(&recordPanel, &RecordPanel::recordStopped,

                     &dataFormatPanel, &DataFormatPanel::stopRecording);

    QObject::connect(ui->actionPause, &QAction::triggered,

                     [this](bool enabled)

                     {

                         if (enabled && !recordPanel.recordPaused())

                         {

                             dataFormatPanel.pause(true);

                         }

                         else

                         {

                             dataFormatPanel.pause(false);

                         }

                     });

    QObject::connect(&recordPanel, &RecordPanel::recordPausedChanged,

                     [this](bool enabled)

                     {

                         if (ui->actionPause->isChecked() && enabled)

                         {

                             dataFormatPanel.pause(false);

                         }

                     });

    connect(&serialPort, &QIODevice::aboutToClose,

            &recordPanel, &RecordPanel::onPortClose);

    // init data arrays and plot

    numOfSamples = plotControlPanel.numOfSamples();

    unsigned numOfChannels = dataFormatPanel.numOfChannels();

    channelMan.setNumOfSamples(numOfSamples);

    channelMan.setNumOfChannels(dataFormatPanel.numOfChannels());

    connect(&dataFormatPanel, &DataFormatPanel::numOfChannelsChanged,

            &channelMan, &ChannelManager::setNumOfChannels);

    connect(&channelMan, &ChannelManager::numOfChannelsChanged,

            this, &MainWindow::onNumOfChannelsChanged);

    plotControlPanel.setChannelInfoModel(channelMan.infoModel());

    // init curve list

    for (unsigned int i = 0; i < numOfChannels; i++)

    {

        plotMan->addCurve(channelMan.channelName(i), channelMan.channelBuffer(i));

    }

    // init auto scale

    // Init sps (sample per second) counter

    spsLabel.setText("0sps");

    spsLabel.setToolTip("samples per second (per channel)");

    ui->statusBar->addPermanentWidget(&spsLabel);

    QObject::connect(&dataFormatPanel,

                     &DataFormatPanel::samplesPerSecondChanged,

                     this, &MainWindow::onSpsChanged);

    // init demo

    QObject::connect(ui->actionDemoMode, &QAction::toggled,

                     this, &MainWindow::enableDemo);

    QObject::connect(ui->actionDemoMode, &QAction::toggled,

                     plotMan, &PlotManager::showDemoIndicator);

    // load default settings

    QSettings settings("serialplot", "serialplot");

    loadAllSettings(&settings);

    // ensure command panel has 1 command if none loaded

    if (!commandPanel.numOfCommands())

    {

        commandPanel.newCommandAction()->trigger();

    }

    // Important: This should be after newCommandAction is triggered

    // (above) we don't want user to be greeted with command panel on

    // the very first run.

    connect(commandPanel.newCommandAction(), &QAction::triggered, [this]()

            {

                this->ui->tabWidget->setCurrentWidget(&commandPanel);

            });

}

MainWindow::~MainWindow()

{

    // save settings

    QSettings settings("serialplot", "serialplot");

    saveAllSettings(&settings);

    if (serialPort.isOpen())

    {

        serialPort.close();

    }

    delete plotMan;

    delete ui;

    ui = NULL; // we check if ui is deleted in messageHandler

}

void MainWindow::closeEvent(QCloseEvent * event)

{

    if (!snapshotMan.isAllSaved())

    {

        auto clickedButton = QMessageBox::warning(

            this, "Closing SerialPlot",

            "There are un-saved snapshots. If you close you will loose the data.",

            QMessageBox::Discard | QMessageBox::Discard,

            QMessageBox::Cancel);

        if (clickedButton == QMessageBox::Cancel)

        {

            event->ignore();

            return;

        }

    }

    QMainWindow::closeEvent(event);

}

void MainWindow::setupAboutDialog()

{

    Ui_AboutDialog uiAboutDialog;

    uiAboutDialog.setupUi(&aboutDialog);

    QObject::connect(uiAboutDialog.pbAboutQt, &QPushButton::clicked,

                     [](){ QApplication::aboutQt();});

    QString aboutText = uiAboutDialog.lbAbout->text();

    aboutText.replace("$VERSION_STRING$", VERSION_STRING);

    aboutText.replace("$VERSION_REVISION$", VERSION_REVISION);

    uiAboutDialog.lbAbout->setText(aboutText);

}

void MainWindow::onPortToggled(bool open)

{

    // make sure demo mode is disabled

    if (open && isDemoRunning()) enableDemo(false);

    ui->actionDemoMode->setEnabled(!open);

}

void MainWindow::onPortError(QSerialPort::SerialPortError error)

{

    switch(error)

    {

        case QSerialPort::NoError :

    }

}

unsigned PlotManager::numOfCurves()

{

    return curves.size();

}

void PlotManager::setTitle(unsigned index, QString title)

{

    curves[index]->setTitle(title);

    plotWidget(index)->replot();

}

Plot* PlotManager::plotWidget(unsigned curveIndex)

{

    if (isMulti)

    {

        return plotWidgets[curveIndex];

    }

    else

    {

        return plotWidgets[0];

    }

}

void PlotManager::replot()

{

    for (auto plot : plotWidgets)

    {

        plot->replot();

    }

}

QList<QAction*> PlotManager::menuActions()

{

    QList<QAction*> actions;

    actions << &showGridAction;

    actions << &showMinorGridAction;

    actions << &unzoomAction;

    actions << &darkBackgroundAction;

    actions << &showLegendAction;

    actions << &showMultiAction;

    return actions;

}

void PlotManager::showGrid(bool show)

{

    for (auto plot : plotWidgets)

    {

        plot->showGrid(show);

    }

}

void PlotManager::showMinorGrid(bool show)

{

    for (auto plot : plotWidgets)

    {

        plot->showMinorGrid(show);

    }

}

void PlotManager::showLegend(bool show)

{

    for (auto plot : plotWidgets)

    {

        plot->showLegend(show);

    }

}

void PlotManager::showDemoIndicator(bool show)

{

    isDemoShown = show;

    for (auto plot : plotWidgets)

    {

        plot->showDemoIndicator(show);

    }

}

void PlotManager::unzoom()

{

    for (auto plot : plotWidgets)

    {

        plot->unzoom();

    }

}

void PlotManager::darkBackground(bool enabled)

{

    for (auto plot : plotWidgets)

    {

        plot->darkBackground(enabled);

    }

}

{

    _autoScaled = autoScaled;

    _yMin = yAxisMin;

    _yMax = yAxisMax;

    for (auto plot : plotWidgets)

    {

        plot->setAxis(autoScaled, yAxisMin, yAxisMax);

    }

}

void PlotManager::flashSnapshotOverlay()

{

    for (auto plot : plotWidgets)

    {

        plot->flashSnapshotOverlay(darkBackgroundAction.isChecked());

    }

}

void PlotManager::onNumOfSamplesChanged(unsigned value)

{

    for (auto plot : plotWidgets)

    {

        plot->onNumOfSamplesChanged(value);

    }

}

void PlotManager::saveSettings(QSettings* settings)

{

    settings->beginGroup(SettingGroup_Plot);

    settings->setValue(SG_Plot_DarkBackground, darkBackgroundAction.isChecked());

    settings->setValue(SG_Plot_Grid, showGridAction.isChecked());

    settings->setValue(SG_Plot_MinorGrid, showMinorGridAction.isChecked());

    settings->setValue(SG_Plot_Legend, showLegendAction.isChecked());

    settings->setValue(SG_Plot_MultiPlot, showMultiAction.isChecked());

    settings->endGroup();

}

void PlotManager::loadSettings(QSettings* settings)

{

    settings->beginGroup(SettingGroup_Plot);

    darkBackgroundAction.setChecked(

        settings->value(SG_Plot_DarkBackground, darkBackgroundAction.isChecked()).toBool());

    darkBackground(darkBackgroundAction.isChecked());

    showGridAction.setChecked(

        settings->value(SG_Plot_Grid, showGridAction.isChecked()).toBool());

    showGrid(showGridAction.isChecked());

    showMinorGridAction.setChecked(

        settings->value(SG_Plot_MinorGrid, showMinorGridAction.isChecked()).toBool());

    showMinorGridAction.setEnabled(showGridAction.isChecked());

    showMinorGrid(showMinorGridAction.isChecked());

    showLegendAction.setChecked(

        settings->value(SG_Plot_Legend, showLegendAction.isChecked()).toBool());

    showLegend(showLegendAction.isChecked());

    showMultiAction.setChecked(

        settings->value(SG_Plot_MultiPlot, showMultiAction.isChecked()).toBool());

    setMulti(showMultiAction.isChecked());

    settings->endGroup();

}