set(QWT_STATIC_LIBRARY "" CACHE FILEPATH "Path to the static Qwt library, libqwt.a.")

set(QWT_STATIC_INCLUDE "" CACHE PATH "Path to the Qwt include directory when building Qwt static.")

if (QWT_USE_STATIC)

  set(QWT_LIBRARY ${QWT_STATIC_LIBRARY})

  set(QWT_INCLUDE_DIR ${QWT_STATIC_INCLUDE})

else (QWT_USE_STATIC)

  find_package(Qwt 6.1 REQUIRED)

endif (QWT_USE_STATIC)

# includes

include_directories(${QWT_INCLUDE_DIR})

# wrap UI files

qt5_wrap_ui(UI_FILES mainwindow.ui portcontrol.ui about_dialog.ui)

add_executable(${PROGRAM_NAME} WIN32

  main.cpp

  mainwindow.cpp

  portcontrol.cpp

  plot.cpp

  zoomer.cpp

  hidabletabwidget.cpp

  framebuffer.cpp

  ${UI_FILES}

  misc/windows_icon.rc

  )

# Use the Widgets module from Qt 5.

target_link_libraries(${PROGRAM_NAME} ${QWT_LIBRARY})

qt5_use_modules(${PROGRAM_NAME} Widgets SerialPort Svg)

# set compiler flags

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")

# Enable C++11 support, fail if not supported

include(CheckCXXCompilerFlag)

CHECK_CXX_COMPILER_FLAG("-std=c++11" COMPILER_SUPPORTS_CXX11)

CHECK_CXX_COMPILER_FLAG("-std=c++0x" COMPILER_SUPPORTS_CXX0X)

if(COMPILER_SUPPORTS_CXX11)

  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")

elseif(COMPILER_SUPPORTS_CXX0X)

  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x")

else()

  message(STATUS "The compiler ${CMAKE_CXX_COMPILER} has no C++11 support. Please use a different C++ compiler.")

endif()

# version number

#include <QSerialPortInfo>

#include <QKeySequence>

#include <QtDebug>

#include "utils.h"

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

    QWidget(parent),

    ui(new Ui::PortControl),

    portToolBar("Port"),

    openAction("Open", this)

{

    ui->setupUi(this);

    serialPort = port;

    // setup the toolbar

    openAction.setCheckable(true);

    openAction.setShortcut(QKeySequence("F2"));

    openAction.setToolTip("Open Port (F2)");

    QObject::connect(&openAction, &QAction::triggered,

                     this, &PortControl::openActionTriggered);

    portToolBar.addAction(&openAction);

    // setup buttons

    QObject::connect(ui->pbReloadPorts, &QPushButton::clicked,

                     this, &PortControl::loadPortList);

    ui->pbOpenPort->setDefaultAction(&openAction);

    // TODO: port name coming from combobox is dirty, create a separate layer of signals

    //       that will sanitize this information

    QObject::connect(ui->cbPortList,

                     SELECT<const QString&>::OVERLOAD_OF(&QComboBox::activated),

                     this, &PortControl::selectPort);

    QObject::connect(ui->cbPortList,

                     SELECT<const QString&>::OVERLOAD_OF(&QComboBox::activated),

                     this, &PortControl::onPortNameChanged);

    QObject::connect(ui->cbBaudRate,

                     SELECT<const QString&>::OVERLOAD_OF(&QComboBox::activated),

                     this, &PortControl::selectBaudRate);

    // setup parity selection buttons

    parityButtons.addButton(ui->rbNoParity, (int) QSerialPort::NoParity);

    parityButtons.addButton(ui->rbEvenParity, (int) QSerialPort::EvenParity);

    parityButtons.addButton(ui->rbOddParity, (int) QSerialPort::OddParity);

  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 PORTCONTROL_H

#define PORTCONTROL_H

#include <QWidget>

#include <QButtonGroup>

#include <QSerialPort>

#include <QStringList>

#include <QToolBar>

#include <QAction>

namespace Ui {

class PortControl;

}

class PortControl : public QWidget

{

    Q_OBJECT

public:

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

    ~PortControl();

    QSerialPort* serialPort;

    QToolBar* toolBar();

private:

    Ui::PortControl *ui;

    QButtonGroup parityButtons;

    QButtonGroup dataBitsButtons;

    QButtonGroup stopBitsButtons;

    QButtonGroup flowControlButtons;

    QToolBar portToolBar;

    QAction openAction;

    QStringList discoveredPorts; // list of port names returned by availablePorts

    QStringList userEnteredPorts; // list of port names entered by user

    void keepPortName(QString portName); // if it's not already in userEn. or discv. list

public slots:

    void loadPortList();

    void loadBaudRateList();

    void togglePort();

    void selectPort(QString portName);

    void enableSkipByte(bool enabled = true);

    void selectBaudRate(QString baudRate);

    void selectParity(int parity); // parity must be one of QSerialPort::Parity

    void selectDataBits(int dataBits); // bits must be one of QSerialPort::DataBits

    void selectStopBits(int stopBits); // stopBits must be one of QSerialPort::StopBits

    void selectFlowControl(int flowControl); // flowControl must be one of QSerialPort::FlowControl

private slots:

    void onPortNameChanged(QString portName);

    void openActionTriggered(bool checked);

signals:

    void skipByteRequested();