/*

  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/>.

*/

#include "commandpanel.h"

#include "ui_commandpanel.h"

CommandPanel::CommandPanel(QSerialPort* port, QWidget *parent) :

    QWidget(parent),

    ui(new Ui::CommandPanel),

    _menu(trUtf8("Commands")), _newCommandAction(trUtf8("New Command"), this)

{

    serialPort = port;

    ui->setupUi(this);

    auto layout = new QVBoxLayout();

    layout->setSpacing(0);

    ui->scrollAreaWidgetContents->setLayout(layout);

#ifdef Q_OS_WIN

    ui->pbNew->setIcon(QIcon(":/icons/list-add"));

#endif // Q_OS_WIN

    connect(ui->pbNew, &QPushButton::clicked, this, &CommandPanel::newCommand);

    connect(&_newCommandAction, &QAction::triggered, this, &CommandPanel::newCommand);

    _menu.addAction(&_newCommandAction);

    _menu.addSeparator();

    command_name_counter = 0;

}

CommandPanel::~CommandPanel()

{

    delete ui;

}

{

    auto command = new CommandWidget();

    command_name_counter++;

    command->setName(trUtf8("Command ") + QString::number(command_name_counter));

    ui->scrollAreaWidgetContents->layout()->addWidget(command);

    command->setFocusToEdit();

    connect(command, &CommandWidget::sendCommand, this, &CommandPanel::sendCommand);

    connect(command, &CommandWidget::focusRequested, this, &CommandPanel::focusRequested);

    _menu.addAction(command->sendAction());

}

void CommandPanel::sendCommand(QByteArray command)

{

    if (!serialPort->isOpen())

    {

        qCritical() << "Port is not open!";

        return;

    }

    if (serialPort->write(command) < 0)

    {

        qCritical() << "Send command failed!";

    }

}

QMenu* CommandPanel::menu()

{

    return &_menu;

}

QAction* CommandPanel::newCommandAction()

{

    return &_newCommandAction;

}

/*

  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 COMMANDPANEL_H

#define COMMANDPANEL_H

#include <QWidget>

#include <QSerialPort>

#include <QByteArray>

#include <QMenu>

#include <QAction>

#include "commandwidget.h"

namespace Ui {

class CommandPanel;

}

class CommandPanel : public QWidget

{

    Q_OBJECT

public:

    explicit CommandPanel(QSerialPort* port, QWidget *parent = 0);

    ~CommandPanel();

    QMenu* menu();

    QAction* newCommandAction();

signals:

    // emitted when user tries to send an empty command

    void focusRequested();

private:

    Ui::CommandPanel *ui;

    QSerialPort* serialPort;

    QMenu _menu;

    QAction _newCommandAction;

    unsigned command_name_counter;

private slots:

    void sendCommand(QByteArray command);

};

#endif // COMMANDPANEL_H

/*

  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/>.

*/

#include "commandwidget.h"

#include "ui_commandwidget.h"

#include <QRegExp>

#include <QRegExpValidator>

#include <QtDebug>

#include <QIcon>

CommandWidget::CommandWidget(QWidget *parent) :

    QWidget(parent),

    ui(new Ui::CommandWidget),

    _sendAction(this)

{

    ui->setupUi(this);

#ifdef Q_OS_WIN

    ui->pbDelete->setIcon(QIcon(":/icons/list-remove"));

#endif // Q_OS_WIN

    connect(ui->pbDelete, &QPushButton::clicked, this, &CommandWidget::onDeleteClicked);

    connect(ui->pbSend, &QPushButton::clicked, this, &CommandWidget::onSendClicked);

    connect(ui->pbASCII, &QPushButton::toggled, this, &CommandWidget::onASCIIToggled);

    connect(ui->leName, &QLineEdit::textChanged, [this](QString text)

            {

                this->_sendAction.setText(text);

            });

    connect(&_sendAction, &QAction::triggered, this, &CommandWidget::onSendClicked);

}

CommandWidget::~CommandWidget()

{

    this->deleteLater();

}

void CommandWidget::onSendClicked()

{

    auto command = ui->leCommand->text();

    if (command.isEmpty())

    {

        qWarning() << "Enter a command to send!";

        ui->leCommand->setFocus(Qt::OtherFocusReason);

        emit focusRequested();

        return;

    }

    if (isASCIIMode())

    {

        qDebug() << "Sending " << name() << ":" << command;

        emit sendCommand(ui->leCommand->unEscapedText().toLatin1());

    }

    else // hex mode

    {

        command = command.remove(' ');

        // check if nibbles are missing

        if (command.size() % 2 == 1)

        {

            qWarning() << "HEX command is missing a nibble at the end!";

            ui->leCommand->setFocus(Qt::OtherFocusReason);

            // highlight the byte that is missing a nibble (last byte obviously)

            int textSize = ui->leCommand->text().size();

            ui->leCommand->setSelection(textSize-1, textSize);

            return;

        }

        qDebug() << "Sending HEX:" << command;

        emit sendCommand(QByteArray::fromHex(command.toLatin1()));

    }

}

void CommandWidget::onASCIIToggled(bool checked)

{

    ui->leCommand->setMode(checked);

}

bool CommandWidget::isASCIIMode()

{

    return ui->pbASCII->isChecked();

}

void CommandWidget::setName(QString name)

{

    ui->leName->setText(name);

}

QString CommandWidget::name()

{

    return ui->leName->text();

}

void CommandWidget::setFocusToEdit()

{

    ui->leCommand->setFocus(Qt::OtherFocusReason);

}

QAction* CommandWidget::sendAction()

{

    return &_sendAction;

}

/*

  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 COMMANDWIDGET_H

#define COMMANDWIDGET_H

#include <QWidget>

#include <QByteArray>

#include <QAction>

namespace Ui {

class CommandWidget;

}

class CommandWidget : public QWidget

{

    Q_OBJECT

public:

    explicit CommandWidget(QWidget *parent = 0);

    ~CommandWidget();

    void setName(QString name);

    QString name();

    void setFocusToEdit();

    QAction* sendAction();

signals:

    void sendCommand(QByteArray command);

    void focusRequested();

private:

    Ui::CommandWidget *ui;

    QAction _sendAction;

private slots:

    void onDeleteClicked();

    void onSendClicked();

    void onASCIIToggled(bool checked);

};

#endif // COMMANDWIDGET_H

                     &dataFormatPanel, &DataFormatPanel::pause);

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

    connect(&channelMan, &ChannelManager::channelNameChanged,

            this, &MainWindow::onChannelNameChanged);

    plotControlPanel.setChannelNamesModel(channelMan.channelNames());

    // init curve list

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

    {

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

    }

    // init auto scale

    plotMan->setAxis(plotControlPanel.autoScale(),

                     plotControlPanel.yMin(), plotControlPanel.yMax());

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

}

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::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 :

            break;

        case QSerialPort::ResourceError :

            qWarning() << "Port error: resource unavaliable; most likely device removed.";

        ui->actionPause->setChecked(wasPaused);

    }

    else

    {

        Snapshot* snapshot = snapshotMan.makeSnapshot();

        snapshot->save(fileName);

        delete snapshot;

    }

}

void MainWindow::messageHandler(QtMsgType type,

                                const QMessageLogContext &context,

                                const QString &msg)

{

    QString logString;

    switch (type)

    {

        case QtDebugMsg:

            logString = "[Debug] " + msg;

            break;

        case QtWarningMsg:

            logString = "[Warning] " + msg;

            break;

        case QtCriticalMsg:

            logString = "[Error] " + msg;

            break;

        case QtFatalMsg:

            logString = "[Fatal] " + msg;

            break;

    }

    if (ui != NULL) ui->ptLog->appendPlainText(logString);

    std::cerr << logString.toStdString() << std::endl;

    if (type != QtDebugMsg && ui != NULL)

    {

        ui->statusBar->showMessage(msg, 5000);

    }

}

void MainWindow::saveAllSettings(QSettings* settings)

{

    saveMWSettings(settings);

    portControl.saveSettings(settings);

    dataFormatPanel.saveSettings(settings);

    channelMan.saveSettings(settings);

    plotControlPanel.saveSettings(settings);

}

void MainWindow::loadAllSettings(QSettings* settings)

{

    loadMWSettings(settings);

    portControl.loadSettings(settings);

    dataFormatPanel.loadSettings(settings);

    channelMan.loadSettings(settings);

    plotControlPanel.loadSettings(settings);

}

void MainWindow::saveMWSettings(QSettings* settings)

{

    // save window geometry

    settings->beginGroup(SettingGroup_MainWindow);

    settings->setValue(SG_MainWindow_Size, size());

    settings->setValue(SG_MainWindow_Pos, pos());

    // save active panel

    settings->setValue(SG_MainWindow_ActivePanel,

                       panelSettingMap.value(ui->tabWidget->currentIndex()));

    // save panel minimization

    settings->setValue(SG_MainWindow_HidePanels,

                       ui->tabWidget->hideAction.isChecked());

    // save window maximized state

    settings->setValue(SG_MainWindow_Maximized,

                       bool(windowState() & Qt::WindowMaximized));

    settings->endGroup();

}

void MainWindow::loadMWSettings(QSettings* settings)

{

    settings->beginGroup(SettingGroup_MainWindow);

    // load window geometry

    resize(settings->value(SG_MainWindow_Size, size()).toSize());

    move(settings->value(SG_MainWindow_Pos, pos()).toPoint());

    // set active panel

    QString tabSetting =

        settings->value(SG_MainWindow_ActivePanel, QString()).toString();

    ui->tabWidget->setCurrentIndex(

        panelSettingMap.key(tabSetting, ui->tabWidget->currentIndex()));

    // hide panels

    ui->tabWidget->hideAction.setChecked(

        settings->value(SG_MainWindow_HidePanels,

                        ui->tabWidget->hideAction.isChecked()).toBool());

    // maximize window

    if (settings->value(SG_MainWindow_Maximized).toBool())

    {

        showMaximized();

    }

    settings->endGroup();

}

void MainWindow::onSaveSettings()

const char SettingGroup_Commands[] = "Commands";

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

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

// plot settings keys

const char SG_Plot_NumOfSamples[] = "numOfSamples";

const char SG_Plot_AutoScale[] = "autoScale";

const char SG_Plot_YMax[] = "yMax";

const char SG_Plot_YMin[] = "yMin";

#endif // SETTING_DEFINES_H