/*

  Copyright © 2016 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/>.

*/

#include "dataformatpanel.h"

#include "ui_dataformatpanel.h"

#include <QRadioButton>

#include <QtEndian>

#include <QMap>

#include <QtDebug>

#include "utils.h"

#include "setting_defines.h"

#include "floatswap.h"

DataFormatPanel::DataFormatPanel(QSerialPort* port,

                                 ChannelManager* channelMan,

                                 QWidget *parent) :

    QWidget(parent),

    ui(new Ui::DataFormatPanel),

    bsReader(port, channelMan, this),

    asciiReader(port, channelMan, this),

    framedReader(port, channelMan, this),

    demoReader(port, channelMan, this)

{

    ui->setupUi(this);

    serialPort = port;

    _channelMan = channelMan;

    paused = false;

    // initalize default reader

    currentReader = &bsReader;

    bsReader.enable();

    ui->rbBinary->setChecked(true);

    ui->horizontalLayout->addWidget(bsReader.settingsWidget(), 1);

    connect(&bsReader, SIGNAL(dataAdded()), this, SIGNAL(dataAdded()));

    connect(&bsReader, SIGNAL(numOfChannelsChanged(unsigned)),

            this, SIGNAL(numOfChannelsChanged(unsigned)));

    connect(&bsReader, SIGNAL(samplesPerSecondChanged(unsigned)),

            this, SIGNAL(samplesPerSecondChanged(unsigned)));

    // initalize reader selection buttons

    connect(ui->rbBinary, &QRadioButton::toggled, [this](bool checked)

            {

                if (checked) selectReader(&bsReader);

            });

    connect(ui->rbAscii, &QRadioButton::toggled, [this](bool checked)

            {

                if (checked) selectReader(&asciiReader);

            });

    connect(ui->rbFramed, &QRadioButton::toggled, [this](bool checked)

            {

                if (checked) selectReader(&framedReader);

            });

    // re-purpose numofchannels settings from actual reader settings to demo reader

    connect(this, &DataFormatPanel::numOfChannelsChanged,

            &demoReader, &DemoReader::setNumOfChannels);

}

DataFormatPanel::~DataFormatPanel()

{

    delete ui;

}

unsigned DataFormatPanel::numOfChannels()

{

    return currentReader->numOfChannels();

}

void DataFormatPanel::pause(bool enabled)

{

    paused = enabled;

    currentReader->pause(enabled);

    demoReader.pause(enabled);

}

void DataFormatPanel::enableDemo(bool enabled)

{

    if (enabled)

    {

        demoReader.enable();

        connect(&demoReader, &DemoReader::dataAdded,

                this, &DataFormatPanel::dataAdded);

        connect(&demoReader, &DemoReader::samplesPerSecondChanged,

                this, &DataFormatPanel::samplesPerSecondChanged);

    }

    else

    {

        demoReader.enable(false);

        disconnect(&demoReader, 0, this, 0);

    }

}

void DataFormatPanel::selectReader(AbstractReader* reader)

{

    currentReader->enable(false);

    reader->enable();

    // re-connect signals

    disconnect(currentReader, 0, this, 0);

    connect(reader, SIGNAL(dataAdded()), this, SIGNAL(dataAdded()));

    connect(reader, SIGNAL(numOfChannelsChanged(unsigned)),

            this, SIGNAL(numOfChannelsChanged(unsigned)));

    connect(reader, SIGNAL(samplesPerSecondChanged(unsigned)),

            this, SIGNAL(samplesPerSecondChanged(unsigned)));

    // switch the settings widget

    ui->horizontalLayout->removeWidget(currentReader->settingsWidget());

    currentReader->settingsWidget()->hide();

    ui->horizontalLayout->addWidget(reader->settingsWidget(), 1);

    reader->settingsWidget()->show();

    // notify if number of channels is different

    if (currentReader->numOfChannels() != reader->numOfChannels())

    {

        emit numOfChannelsChanged(reader->numOfChannels());

    }

    // pause

    reader->pause(paused);

    currentReader = reader;

}

void DataFormatPanel::saveSettings(QSettings* settings)

{

    settings->beginGroup(SettingGroup_DataFormat);

    // save selected format

    QString format;

    if (currentReader == &bsReader)

    {

        format = "binary";

    }

    else if (currentReader == &asciiReader)

    {

        format = "ascii";

    }

    else // framed reader

    {

        format = "custom";

    }

    settings->setValue(SG_DataFormat_Format, format);

    settings->endGroup();

    // save reader settings

    bsReader.saveSettings(settings);

    asciiReader.saveSettings(settings);

    framedReader.saveSettings(settings);

}

void DataFormatPanel::loadSettings(QSettings* settings)

{

    settings->beginGroup(SettingGroup_DataFormat);

    // load selected format

    QString format = settings->value(

        SG_DataFormat_Format, QString()).toString();

    if (format == "binary")

    {

        selectReader(&bsReader);

        ui->rbBinary->setChecked(true);

    }

    else if (format == "ascii")

    {

        selectReader(&asciiReader);

        ui->rbAscii->setChecked(true);

    }

    else if (format == "custom")

    {

        selectReader(&framedReader);

        ui->rbFramed->setChecked(true);

    } // else current selection stays

    settings->endGroup();

    // load reader settings

    bsReader.loadSettings(settings);

    asciiReader.loadSettings(settings);

    framedReader.loadSettings(settings);

}

/*

  Copyright © 2016 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 DATAFORMATPANEL_H

#define DATAFORMATPANEL_H

#include <QWidget>

#include <QButtonGroup>

#include <QTimer>

#include <QSerialPort>

#include <QList>

#include <QSettings>

#include <QtGlobal>

#include "framebuffer.h"

#include "channelmanager.h"

#include "binarystreamreader.h"

#include "asciireader.h"

#include "demoreader.h"

#include "framedreader.h"

namespace Ui {

class DataFormatPanel;

}

class DataFormatPanel : public QWidget

{

    Q_OBJECT

public:

    explicit DataFormatPanel(QSerialPort* port,

                             ChannelManager* channelMan,

                             QWidget *parent = 0);

    ~DataFormatPanel();

    /// Returns currently selected number of channels

    unsigned numOfChannels();

    /// Stores data format panel settings into a `QSettings`

    void saveSettings(QSettings* settings);

    /// Loads data format panel settings from a `QSettings`.

    void loadSettings(QSettings* settings);

public slots:

    void pause(bool);

    void enableDemo(bool); // demo shouldn't be enabled when port is open

signals:

    void numOfChannelsChanged(unsigned);

    void samplesPerSecondChanged(unsigned);

    void dataAdded();

private:

    Ui::DataFormatPanel *ui;

    QSerialPort* serialPort;

    ChannelManager* _channelMan;

    BinaryStreamReader bsReader;

    AsciiReader asciiReader;

    FramedReader framedReader;

    /// Currently selected reader

    AbstractReader* currentReader;

    /// Disable current reader and enable a another one

    void selectReader(AbstractReader* reader);

    bool paused;

    DemoReader demoReader;

};

#endif // DATAFORMATPANEL_H

/*

  Copyright © 2016 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 FRAMEDREADER_H

#define FRAMEDREADER_H

#include <QSettings>

#include "abstractreader.h"

#include "framedreadersettings.h"

/**

 * Reads data in a customizable framed format.

 */

class FramedReader : public AbstractReader

{

    Q_OBJECT

public:

    explicit FramedReader(QIODevice* device, ChannelManager* channelMan, QObject *parent = 0);

    QWidget* settingsWidget();

    unsigned numOfChannels();

    void enable(bool enabled = true);

    /// Stores settings into a `QSettings`

    void saveSettings(QSettings* settings);

    /// Loads settings from a `QSettings`.

    void loadSettings(QSettings* settings);

public slots:

    void pause(bool);

private:

    /// bit wise fields for `settingsValid` member

    enum SettingInvalidFlag

    {

        SYNCWORD_INVALID = 1,

        FRAMESIZE_INVALID = 2

    };

    // settings related members

    FramedReaderSettings _settingsWidget;

    unsigned _numOfChannels;

    unsigned sampleSize;

    bool paused;

    unsigned settingsInvalid;   /// settings are all valid if this is 0, if not no reading is done

    QByteArray syncWord;

    bool checksumEnabled;

    bool hasSizeByte;

    unsigned frameSize;

    bool debugModeEnabled;

    /// Checks the validity of syncWord and frameSize then shows an

    /// error message. Also updates `settingsInvalid`. If settings are

    /// valid `settingsInvalid` should be `0`.

    void checkSettings();

    // read state related members

    unsigned sync_i; /// sync byte index to be read next

    bool gotSync;    /// indicates if sync word is captured

    bool gotSize;    /// indicates if size is captured, ignored if size byte is disabled (fixed size)

    unsigned calcChecksum;

    void reset();    /// Resets the reading state. Used in case of error or setting change.

    /// points to the readSampleAs function for currently selected number format

    double (FramedReader::*readSample)();

    template<typename T> double readSampleAs();

    /// reads payload portion of the frame, calculates checksum and commits data

    /// @note should be called only if there are enough bytes on device

    void readFrameDataAndCheck();

private slots:

    void onDataReady();

    void onNumberFormatChanged(NumberFormat numberFormat);

    void onNumOfChannelsChanged(unsigned value);

    void onSyncWordChanged(QByteArray);

    void onFrameSizeChanged(unsigned);

};

#endif // FRAMEDREADER_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/>.

*/

#include "mainwindow.h"

#include "ui_mainwindow.h"

#include <QByteArray>

#include <QApplication>

#include <QFileDialog>

#include <QMessageBox>

#include <QFile>

#include <QTextStream>

#include <QMenu>

#include <QDesktopServices>

#include <QMap>

#include <QtDebug>

#include <qwt_plot.h>

#include <limits.h>

#include <cmath>

#include <iostream>

#include <plot.h>

#include "framebufferseries.h"

#include "utils.h"

#include "defines.h"

#include "version.h"

#include "setting_defines.h"

#if defined(Q_OS_WIN) && defined(QT_STATIC)

#include <QtPlugin>

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)

{

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

    auto tbPortControl = portControl.toolBar();

    addToolBar(tbPortControl);

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

            plotMan, &PlotManager::setAxis);

    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(&dataFormatPanel, &DataFormatPanel::dataAdded,

                     plotMan, &PlotManager::replot);

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

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

    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

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

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

            break;

        case QSerialPort::ResourceError :

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

            if (serialPort.isOpen())

            {

                qWarning() << "Closing port on resource error: " << serialPort.portName();

                portControl.togglePort();

            }

            portControl.loadPortList();

            break;

        case QSerialPort::DeviceNotFoundError:

            qCritical() << "Device doesn't exists: " << serialPort.portName();

            break;

        case QSerialPort::PermissionError:

            qCritical() << "Permission denied. Either you don't have \

required privileges or device is already opened by another process.";

            break;

        case QSerialPort::OpenError:

            qWarning() << "Device is already opened!";

            break;

        case QSerialPort::NotOpenError:

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

            break;

        case QSerialPort::ParityError:

            qCritical() << "Parity error detected.";

            break;

        case QSerialPort::FramingError:

            qCritical() << "Framing error detected.";

            break;

        case QSerialPort::BreakConditionError:

            qCritical() << "Break condition is detected.";

            break;

        case QSerialPort::WriteError:

            qCritical() << "An error occurred while writing data.";

            break;

        case QSerialPort::ReadError:

            qCritical() << "An error occurred while reading data.";

            break;

        case QSerialPort::UnsupportedOperationError:

            qCritical() << "Operation is not supported.";

            break;

        case QSerialPort::TimeoutError:

            qCritical() << "A timeout error occurred.";

            break;

        case QSerialPort::UnknownError:

            qCritical() << "Unknown error! Error: " << serialPort.errorString();

            break;

        default:

            qCritical() << "Unhandled port error: " << error;

            break;

    }

}

void MainWindow::clearPlot()

{

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

    {

        channelMan.channelBuffer(ci)->clear();

    }

    plotMan->replot();

}

void MainWindow::onNumOfSamplesChanged(int value)

{

    numOfSamples = value;

    channelMan.setNumOfSamples(value);

    plotMan->replot();

}

void MainWindow::onNumOfChannelsChanged(unsigned value)

{

    unsigned int oldNum = plotMan->numOfCurves();

    unsigned numOfChannels = value;

    if (numOfChannels > oldNum)

    {

        // add new channels

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

        {

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

        }

    }

    else if(numOfChannels < oldNum)

    {

        plotMan->removeCurves(oldNum - numOfChannels);

    }

    plotMan->replot();

}

void MainWindow::onSpsChanged(unsigned sps)

{

    spsLabel.setText(QString::number(sps) + "sps");

}

bool MainWindow::isDemoRunning()

{

    return ui->actionDemoMode->isChecked();

}

void MainWindow::enableDemo(bool enabled)

{

    if (enabled)

    {

        if (!serialPort.isOpen())

        {

            dataFormatPanel.enableDemo(true);

        }

        else

        {

            ui->actionDemoMode->setChecked(false);

        }

    }

    else

    {

        dataFormatPanel.enableDemo(false);

        ui->actionDemoMode->setChecked(false);

    }

}

void MainWindow::onExportCsv()

{

    bool wasPaused = ui->actionPause->isChecked();

    ui->actionPause->setChecked(true); // pause plotting

    QString fileName = QFileDialog::getSaveFileName(this, tr("Export CSV File"));

    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;

#endif

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

    }

    if (type == QtFatalMsg)

    {