if (fileName.isNull())  // user canceled export

    {

        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)

    {

#if (QT_VERSION >= QT_VERSION_CHECK(5, 5, 0))

        case QtInfoMsg:

            logString = "[Info] " + msg;

            break;

namespace Ui {

class MainWindow;

}

class MainWindow : public QMainWindow

{

    Q_OBJECT

public:

    explicit MainWindow(QWidget *parent = 0);

    ~MainWindow();

    void messageHandler(QtMsgType type, const QMessageLogContext &context,

                        const QString &msg);

private:

    Ui::MainWindow *ui;

    QDialog aboutDialog;

    void setupAboutDialog();

    QSerialPort serialPort;

    PortControl portControl;

}

void PlotManager::setNumOfSamples(unsigned value)

{

    _numOfSamples = value;

    for (auto plot : plotWidgets)

    {

        plot->setNumOfSamples(value);

        if (_xAxisAsIndex) plot->setXAxis(0, 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());

    QString showSymbolsStr;

    if (showSymbols == Plot::ShowSymbolsAuto)

    {

#include <QScrollArea>

#include <QVBoxLayout>

#include <QList>

#include <QSettings>

#include <QAction>

#include <QMenu>

#include <qwt_plot_curve.h>

#include "plot.h"

#include "framebufferseries.h"

#include "channelinfomodel.h"

class PlotManager : public QObject

{

    Q_OBJECT

public:

    explicit PlotManager(QWidget* plotArea, ChannelInfoModel* infoModel = NULL, QObject *parent = 0);

    ~PlotManager();

    /// Add a new curve with title and buffer. A color is

    /// automatically chosen for curve.

    void addCurve(QString title, FrameBuffer* buffer);

    /// Alternative of `addCurve` for static curve data (snapshots).

    void addCurve(QString title, QVector<QPointF> data);

    /// Set the displayed title for a curve

    void setTitle(unsigned index, QString title);

    /// Removes curves from the end

    void removeCurves(unsigned number);

    /// Returns current number of curves known by plot manager

    unsigned numOfCurves();

    /// Returns the list of actions to be inserted into the `View` menu

    QList<QAction*> menuActions();

    /// Stores plot settings into a `QSettings`.

    void saveSettings(QSettings* settings);

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

    void loadSettings(QSettings* settings);

public slots:

    /// Enable/Disable multiple plot display

    void setMulti(bool enabled);

    /// Update all plot widgets

    void replot();

    /// Enable display of a "DEMO" label on each plot

    void showDemoIndicator(bool show = true);

/*

  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 <stddef.h>

#include <QSaveFile>

#include <QTextStream>

#include "snapshot.h"

#include "snapshotview.h"

    QObject(parent),

    cInfoModel(infoModel),

    _showAction(this),

    _deleteAction("&Delete", this)

{

    _name = name;

    _saved = false;

    view = NULL;

    mainWindow = parent;

    _showAction.setText(displayName());

    connect(&_showAction, &QAction::triggered, this, &Snapshot::show);

/*

  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 SNAPSHOT_H

#define SNAPSHOT_H

#include <QObject>

#include <QAction>

#include <QVector>

#include <QString>

#include <QStringList>

#include "channelinfomodel.h"

class SnapshotView;

class Snapshot : public QObject

{

    Q_OBJECT

public:

    ~Snapshot();

    QVector<QVector<QPointF>> data;

    QAction* showAction();

    QAction* deleteAction();

    QString name();

    QString displayName(); ///< `name()` plus '*' if snapshot is not saved

    ChannelInfoModel* infoModel();

    void setName(QString name);

    QString channelName(unsigned channel);

    void save(QString fileName); ///< save snapshot data as CSV

    bool isSaved(); ///< snapshot has been saved at least once

signals:

    void deleteRequested(Snapshot*);

    void nameChanged(Snapshot*);

private:

    QString _name;

    ChannelInfoModel cInfoModel;

    QAction _showAction;

    QAction _deleteAction;

    SnapshotView* view;

    bool _saved;

private slots:

    void show();

    void viewClosed();

    void onDeleteTriggered();

};

#endif /* SNAPSHOT_H */

*/

#include <QTime>

#include <QMenuBar>

#include <QKeySequence>

#include <QFileDialog>

#include <QFile>

#include <QVector>

#include <QPointF>

#include <QIcon>

#include <QtDebug>

#include "snapshotmanager.h"

                                 ChannelManager* channelMan) :

    _menu("&Snapshots"),

    _takeSnapshotAction("&Take Snapshot", this),

    loadSnapshotAction("&Load Snapshots", this),

    clearAction("&Clear Snapshots", this)

{

    _mainWindow = mainWindow;

    _channelMan = channelMan;

    _takeSnapshotAction.setToolTip("Take a snapshot of current plot");

    _takeSnapshotAction.setShortcut(QKeySequence("F5"));

    _takeSnapshotAction.setIcon(QIcon::fromTheme("camera"));

/*

  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.

#ifndef SNAPSHOTMANAGER_H

#define SNAPSHOTMANAGER_H

#include <QObject>

#include <QAction>

#include <QMenu>

#include "framebuffer.h"

#include "channelmanager.h"

#include "snapshot.h"

class SnapshotManager : public QObject

{

    Q_OBJECT

public:

    ~SnapshotManager();

    QMenu* menu();

    QAction* takeSnapshotAction();

    /// Creates a dynamically allocated snapshot object but doesn't record it in snapshots list.

    /// @note Caller is responsible for deletion of the returned `Snapshot` object.

    Snapshot* makeSnapshot();

    bool isAllSaved(); ///< returns `true` if all snapshots are saved to a file

private:

    ChannelManager* _channelMan;

    QList<Snapshot*> snapshots;

    QMenu _menu;

    QAction _takeSnapshotAction;

    QAction loadSnapshotAction;

    QAction clearAction;

    void addSnapshot(Snapshot* snapshot, bool update_menu=true);

    void updateMenu();

  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 "snapshotview.h"

#include "ui_snapshotview.h"

    QMainWindow(parent),

    ui(new Ui::SnapshotView),

    renameDialog(this)

{

    _snapshot = snapshot;

    ui->setupUi(this);

    plotMan = new PlotManager(ui->plotArea, snapshot->infoModel(), this);

    ui->menuSnapshot->insertAction(ui->actionClose, snapshot->deleteAction());

    this->setWindowTitle(snapshot->displayName());

    // initialize curves

    unsigned numOfChannels = snapshot->data.size();

    unsigned numOfSamples = snapshot->data[0].size();

    for (unsigned ci = 0; ci < numOfChannels; ci++)

    {

        plotMan->addCurve(snapshot->channelName(ci), snapshot->data[ci]);

    }

    plotMan->setNumOfSamples(numOfSamples);

/*

  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.

#ifndef SNAPSHOTVIEW_H

#define SNAPSHOTVIEW_H

#include <QMainWindow>

#include <QInputDialog>

#include <QFileDialog>

#include <QVector>

#include <QPointF>

#include <QPen>

#include <QCloseEvent>

#include <qwt_plot_curve.h>

#include "plotmanager.h"

#include "snapshot.h"

namespace Ui {

class SnapshotView;

}

class SnapshotView : public QMainWindow

{

    Q_OBJECT

public:

    ~SnapshotView();

signals:

    void closed();

private:

    Ui::SnapshotView *ui;

    QList<QwtPlotCurve*> curves;

    Snapshot* _snapshot;

    QInputDialog renameDialog;

    PlotManager* plotMan;