Changeset - 663b8d9925e5
Parent rev.
Child rev.
[Not reviewed]
portlist
0 3 2
Hasan Yavuz ÖZDERYA - 10 years ago 2015-09-03 13:41:19
hy@ozderya.net
added PortList model and combobox to port toolbar
5 files changed with 141 insertions and 0 deletions:
CMakeLists.txt
1
portcontrol.cpp
3
portcontrol.h
5
portlist.cpp
80
portlist.h
52
0 comments (0 inline, 0 general)
CMakeLists.txt
➞
Show inline comments
 
#
 
# Copyright © 2015 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/>.
 
#
 

			




	
	
	
		
 
cmake_minimum_required(VERSION 2.8.11)

			




	
	
	
		
 

			




	
	
	
		
 
project(serialplot)

			




	
	
	
		
 

			




	
	
	
		
 
set(PROGRAM_NAME ${CMAKE_PROJECT_NAME} CACHE STRING "Output program name")

			




	
	
	
		
 
set(PROGRAM_DISPLAY_NAME "SerialPlot" CACHE STRING "Display name (menus etc) of the program")

			




	
	
	
		
 

			




	
	
	
		
 
# Find includes in corresponding build directories

			




	
	
	
		
 
set(CMAKE_INCLUDE_CURRENT_DIR ON)

			




	
	
	
		
 

			




	
	
	
		
 
# Instruct CMake to run moc automatically when needed.

			




	
	
	
		
 
set(CMAKE_AUTOMOC ON)

			




	
	
	
		
 

			




	
	
	
		
 
# add local path for cmake modules

			




	
	
	
		
 
set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/modules/")

			




	
	
	
		
 

			




	
	
	
		
 
# Find the QtWidgets library

			




	
	
	
		
 
find_package(Qt5Widgets)

			




	
	
	
		
 

			




	
	
	
		
 
# Find QWT or use static

			




	
	
	
		
 
set(QWT_USE_STATIC false CACHE BOOL "Use a static version of Qwt provided by user.")

			




	
	
	
		
 
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

			




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

			




	
	
	
		
 
set(MAJOR_VERSION 0)

			




	
	
	
		
 
set(MINOR_VERSION 4)

			




	
	
	
		
 
set(PATCH_VERSION 0)

			




	
	
	
		
 
set(VERSION_STRING "${MAJOR_VERSION}.${MINOR_VERSION}.${PATCH_VERSION}")

			




	
	
	
		
 

			




	
	
	
		
 
# get revision number from mercurial

			




	
	
	
		
 
find_program(MERCURIAL hg)

			




	
	
	
		
 

			




	
	
	
		
 
if (MERCURIAL)

			




	
	
	
		
 
  execute_process(COMMAND ${MERCURIAL} id -i

			




	
	
	
		
 
    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}

			




	
	
	
		
 
    RESULT_VARIABLE MERCURIAL_RESULT

			




	
	
	
		
 
    OUTPUT_VARIABLE VERSION_REVISION

			




	
	
	
		
 
    OUTPUT_STRIP_TRAILING_WHITESPACE)

			




	
	
	
		
 
  if(NOT MERCURIAL_RESULT EQUAL 0)

			




	
	
	
		
 
    set(VERSION_SCM_REVISION false)

			




	
	
	
		
 
  endif(NOT MERCURIAL_RESULT EQUAL 0)

			




	
	
	
		
 
endif (MERCURIAL)

			




	
	
	
		
 

			




	
	
	
		
 
if (NOT VERSION_REVISION)

			




	
	
	
		
 
  set(VERSION_REVISION "0")

			




	
	
	
		
 
endif (NOT VERSION_REVISION)

			




	
	
	
		
 

			




	
	
	
		
 
message("SCM revision: ${VERSION_REVISION}")

			




	
	
	
		
 

			




	
	
	
		
 
# configure version file

			




	
	
	
		
 
configure_file("${CMAKE_CURRENT_SOURCE_DIR}/version.h.in" "${CMAKE_CURRENT_BINARY_DIR}/version.h")

			




	
	
	
		
 

			




	
	
	
		
 
# add make run target

			




	
	
	
		
 
add_custom_target(run

			




	
	
	
		
 
    COMMAND ${PROGRAM_NAME}

			




	
	
	
		
 
    DEPENDS ${PROGRAM_NAME}

			




	
	
	
		
 
    WORKING_DIRECTORY ${CMAKE_PROJECT_DIR}

			




	
	
	
		
 
)

			




	
	
	
		
 

			




	
	
	
		
 
# installing

			




	
	
	
		
 
install(TARGETS ${PROGRAM_NAME} DESTINATION bin)

			




	
	
	
		
 

			




	
	
	
		
 
# for windows put libraries to install directory

			




	
	
	
		
 
if (WIN32)

			




	
	
	
		
 
  file(GLOB WINDOWS_INSTALL_LIBRARIES

			




	
	
	
		
 
    "${CMAKE_BINARY_DIR}/windows_install_libraries/*.*")

			




	
	
	
		
 
  install(FILES ${WINDOWS_INSTALL_LIBRARIES} DESTINATION bin)

			




	
	
	
		
 
endif (WIN32)

			




	
	
	
		
 

			




	
	
	
		
 
# install menu item and icon

			




	
	
	
		
 
configure_file("${CMAKE_CURRENT_SOURCE_DIR}/misc/program_name.desktop.in"

			




	
	
	
		
 
  "${CMAKE_BINARY_DIR}/${PROGRAM_NAME}.desktop")

			




	
	
	
		
 
configure_file("${CMAKE_CURRENT_SOURCE_DIR}/misc/program_name.png"

			




	
	
	
		
 
  "${CMAKE_BINARY_DIR}/${PROGRAM_NAME}.png" COPYONLY)

			




	
	
	
		
 

			




	
	
	
		
 
find_program(XDG-DESKTOP-MENU xdg-desktop-menu)

			




	
	
	
		
 
find_program(XDG-ICON-RESOURCE xdg-icon-resource)

			




	
	
	
		
 

			




	
	
	
		
 
if (UNIX)

			




	
	
	
		
 
  # first copy files to share/serialplot/

			




	
	
	
		
 
  install(FILES

			




	
	
	
		
 
    ${CMAKE_BINARY_DIR}/${PROGRAM_NAME}.desktop

			




	
	
	
		
 
    ${CMAKE_BINARY_DIR}/${PROGRAM_NAME}.png

			




	
	
	
		
 
    DESTINATION share/${PROGRAM_NAME})

			




	
	
	
		
 

			




	
	
	
		
 
  # install copyright file (in debian format)

			




	
	
	
		
 
  install(FILES

			




	
	
	
		
 
    ${CMAKE_SOURCE_DIR}/debian/copyright

			




	
	
	
		
 
    DESTINATION share/doc/${PROGRAM_NAME}/)

			




	
	
	
		
 

			




	
	
	
		
 
  install(CODE "

			




	
	
	
		
 
  execute_process(COMMAND ${XDG-DESKTOP-MENU} install --novendor ${CMAKE_INSTALL_PREFIX}/share/${PROGRAM_NAME}/${PROGRAM_NAME}.desktop)

			




	
	
	
		
 
  execute_process(COMMAND ${XDG-ICON-RESOURCE} install --novendor --size 256 ${CMAKE_INSTALL_PREFIX}/share/${PROGRAM_NAME}/${PROGRAM_NAME}.png)

			




	
	
	
		
 
")

			




	
	
	
		
 
endif (UNIX)

			




	
	
	
		
 

			




	
	
	
		
 
# uninstalling

			




	
	
	
		
 
configure_file(

			




	
	
	
		
 
  "${CMAKE_CURRENT_SOURCE_DIR}/cmake/cmake_uninstall.cmake.in"

			




	
	
	
		
 
  "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake"

			




	
	
	
		
 
  @ONLY)

			




	
	
	
		
 

			




	
	
	
		
 
if (UNIX)

			




	
	
	
		
 
  add_custom_target(uninstall

			




	
	
	
		
 
    COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake

			




	
	
	
		
 
    COMMAND ${XDG-DESKTOP-MENU} uninstall --novendor ${PROGRAM_NAME}.desktop

			




	
	
	
		
 
    COMMAND ${XDG-ICON-RESOURCE} uninstall --novendor --size 256 ${PROGRAM_NAME})

			




	
	
	
		
 
endif (UNIX)

			




	
	
	
		
 

			




	
	
	
		
 
# packaging

			




	
	
	
		
 
if (UNIX)

			




	
	
	
		
 
  set(CPACK_GENERATOR "DEB")

			




	
	
	
		
 
elseif (WIN32)

			




	
	
	
		
 
  set(CPACK_GENERATOR "NSIS")

			




	
	
	
		
 
endif (UNIX)

			




	
	
	
		
 

			




	
	
	
		
 
include(InstallRequiredSystemLibraries)

			




	
	
	
		
 

			




	
	
	
		
 
# configure debian scripts

			




	
	
	
		
 
configure_file(${CMAKE_SOURCE_DIR}/debian/postinst.in ${CMAKE_BINARY_DIR}/debian/postinst)

			




	
	
	
		
 
configure_file(${CMAKE_SOURCE_DIR}/debian/postrm.in ${CMAKE_BINARY_DIR}/debian/postrm)

			




	
	
	
		
 

			




	
	
	
		
 
set(CPACK_PACKAGE_NAME "${PROGRAM_NAME}")

			




	
	
	
		
 
set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Small and simple software for plotting data from serial port")

			




	
	
	
		
 
set(CPACK_PACKAGE_CONTACT "Hasan Yavuz Özderya <hy@ozderya.net>")

			




	
	
	
		
 
set(CPACK_PACKAGE_VERSION_MAJOR ${MAJOR_VERSION})

			




	
	
	
		
 
set(CPACK_PACKAGE_VERSION_MINOR ${MINOR_VERSION})

			




	
	
	
		
 
set(CPACK_PACKAGE_VERSION_PATCH ${PATCH_VERSION})

			




	
	
	
		
 
set(CPACK_STRIP_FILES TRUE)

			




	
	
	
		
 
set(CPACK_DEBIAN_PACKAGE_DEPENDS "libqt5widgets5 (>= 5.2.1), libqt5serialport5 (>= 5.2.1), libc6 (>= 2.19)")

			




	
	
	
		
 
if (NOT QWT_USE_STATIC)

			




	
	
	
		
 
  set(CPACK_DEBIAN_PACKAGE_DEPENDS "${CPACK_DEBIAN_PACKAGE_DEPENDS}, libqwt6-qt5 (>= 6.1.1)")

			




	
	
	
		
 
endif (NOT QWT_USE_STATIC)

			




	
	
	
		
 
set(CPACK_DEBIAN_PACKAGE_CONTROL_EXTRA

			




	
	
	
		
 
  "${CMAKE_BINARY_DIR}/debian/postinst"

			




	
	
	
		
 
  "${CMAKE_BINARY_DIR}/debian/postrm")

			




	
	
	
		
 

			




	
	
	
		
 
if (UNIX)

			




	
	
	
		
 
  set(CPACK_PACKAGE_EXECUTABLES "${PROGRAM_NAME}")

			




	
	
	
		
 
elseif (WIN32)

			




	
	
	
		
 
  set(CPACK_PACKAGE_EXECUTABLES "${PROGRAM_NAME};${PROGRAM_DISPLAY_NAME}")

			




	
	
	
		
 
  set(CPACK_CREATE_DESKTOP_LINKS "${PROGRAM_NAME}")

			




	
	
	
		
 
  set(CPACK_NSIS_MODIFY_PATH "ON")

			




	
	
	
		
 
  set(CPACK_PACKAGE_ICON "${CMAKE_SOURCE_DIR}/misc/serialplot.bmp")

			




	
	
	
		
 
  string(REPLACE "/" "\\\\" CPACK_PACKAGE_ICON ${CPACK_PACKAGE_ICON})

			




	
	
	
		
 
  set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_SOURCE_DIR}/COPYING")

			




	
	
	
		
 
  set(CPACK_NSIS_MENU_LINKS

			




	
	
	
		
 
    "https://bitbucket.org/hyOzd/serialplot" "SerialPlot source code on bitbucket.org")

			




	
	
	
		
 
endif (UNIX)

			




	
	
	
		
 

			




	
	
	
		
 
if (UNIX)

			




	
	
	
		
 
  # set debian package name

			




	
	
	
		
 
  string(TOLOWER "${CPACK_PACKAGE_NAME}" CPACK_PACKAGE_NAME_LOWERCASE)

			




	
	
	
		
 
  find_program(DPKG_PROGRAM dpkg DOC "dpkg program of Debian-based systems")

			




	
	
	
		
 
  if(DPKG_PROGRAM)

			




	
	
	
		
 
    execute_process(

			




	
	
	
		
 
      COMMAND ${DPKG_PROGRAM} --print-architecture

			




	
	
	
		
 
      OUTPUT_VARIABLE CPACK_DEBIAN_PACKAGE_ARCHITECTURE

			




	
	
	
		
 
      OUTPUT_STRIP_TRAILING_WHITESPACE)

			




	
	
	
		
 
    set(CPACK_PACKAGE_FILE_NAME

			




	
	
	
		
 
      "${CPACK_PACKAGE_NAME_LOWERCASE}_${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.${CPACK_PACKAGE_VERSION_PATCH}_${CPACK_DEBIAN_PACKAGE_ARCHITECTURE}")

			




	
	
	
		
 
  else(DPKG_PROGRAM)

			




	
	
	
		
 
    set(CPACK_PACKAGE_FILE_NAME

			




	
	
	
		
 
      "${CPACK_PACKAGE_NAME_LOWERCASE}_${PROJECT_VERSION}-${PROJECT_VERSION_REVISION}_${CMAKE_SYSTEM_NAME}")

			




	
	
	
		
 
  endif(DPKG_PROGRAM)

			




	
	
	
		
 
endif (UNIX)

			




	
	
	
		
 

			




	
	
	
		
 
include(CPack)

			




        

    


    
    

    

        

                

                    portcontrol.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
/*

			




	
	
	
		
 
  Copyright © 2015 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 "portcontrol.h"

			




	
	
	
		
 
#include "ui_portcontrol.h"

			




	
	
	
		
 

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    portToolBar.addWidget(&tbPortListBox);

			




	
	
	
		
 
    tbPortListBox.setModel(&portList);

			




	
	
	
		
 

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    QObject::connect(&parityButtons,

			




	
	
	
		
 
                     SELECT<int>::OVERLOAD_OF(&QButtonGroup::buttonClicked),

			




	
	
	
		
 
                     this, &PortControl::selectParity);

			




	
	
	
		
 

			




	
	
	
		
 
    // setup data bits selection buttons

			




	
	
	
		
 
    dataBitsButtons.addButton(ui->rb8Bits, (int) QSerialPort::Data8);

			




	
	
	
		
 
    dataBitsButtons.addButton(ui->rb7Bits, (int) QSerialPort::Data7);

			




	
	
	
		
 
    dataBitsButtons.addButton(ui->rb6Bits, (int) QSerialPort::Data6);

			




	
	
	
		
 
    dataBitsButtons.addButton(ui->rb5Bits, (int) QSerialPort::Data5);

			




	
	
	
		
 

			




	
	
	
		
 
    QObject::connect(&dataBitsButtons,

			




	
	
	
		
 
                     SELECT<int>::OVERLOAD_OF(&QButtonGroup::buttonClicked),

			




	
	
	
		
 
                     this, &PortControl::selectDataBits);

			




	
	
	
		
 

			




	
	
	
		
 
    // setup stop bits selection buttons

			




	
	
	
		
 
    stopBitsButtons.addButton(ui->rb1StopBit, (int) QSerialPort::OneStop);

			




	
	
	
		
 
    stopBitsButtons.addButton(ui->rb2StopBit, (int) QSerialPort::TwoStop);

			




	
	
	
		
 

			




	
	
	
		
 
    QObject::connect(&stopBitsButtons,

			




	
	
	
		
 
                     SELECT<int>::OVERLOAD_OF(&QButtonGroup::buttonClicked),

			




	
	
	
		
 
                     this, &PortControl::selectStopBits);

			




	
	
	
		
 

			




	
	
	
		
 
    // setup flow control selection buttons

			




	
	
	
		
 
    flowControlButtons.addButton(ui->rbNoFlowControl,

			




	
	
	
		
 
                                 (int) QSerialPort::NoFlowControl);

			




	
	
	
		
 
    flowControlButtons.addButton(ui->rbHardwareControl,

			




	
	
	
		
 
                                 (int) QSerialPort::HardwareControl);

			




	
	
	
		
 
    flowControlButtons.addButton(ui->rbSoftwareControl,

			




	
	
	
		
 
                                 (int) QSerialPort::SoftwareControl);

			




	
	
	
		
 

			




	
	
	
		
 
    QObject::connect(&flowControlButtons,

			




	
	
	
		
 
                     SELECT<int>::OVERLOAD_OF(&QButtonGroup::buttonClicked),

			




	
	
	
		
 
                     this, &PortControl::selectFlowControl);

			




	
	
	
		
 

			




	
	
	
		
 
    // init skip byte button

			




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

			




	
	
	
		
 
                     [this](){emit skipByteRequested();});

			




	
	
	
		
 

			




	
	
	
		
 
    loadPortList();

			




	
	
	
		
 
    loadBaudRateList();

			




	
	
	
		
 
    ui->cbBaudRate->setCurrentIndex(ui->cbBaudRate->findText("9600"));

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
PortControl::~PortControl()

			




	
	
	
		
 
{

			




	
	
	
		
 
    delete ui;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void PortControl::loadPortList()

			




	
	
	
		
 
{

			




	
	
	
		
 
    QString currentSelection = ui->cbPortList->currentText();

			




	
	
	
		
 

			




	
	
	
		
 
    ui->cbPortList->clear();

			




	
	
	
		
 

			




	
	
	
		
 
    discoveredPorts.clear();

			




	
	
	
		
 
    for (auto port : QSerialPortInfo::availablePorts())

			




	
	
	
		
 
    {

			




	
	
	
		
 
        QString pName = port.portName();

			




	
	
	
		
 
        if (!port.description().isEmpty()) pName += QString(" ") + port.description();

			




	
	
	
		
 
        if (port.hasProductIdentifier())

			




	
	
	
		
 
        {

			




	
	
	
		
 
            QString vID = QString("%1").arg(port.vendorIdentifier(), 4, 16, QChar('0'));

			




	
	
	
		
 
            QString pID = QString("%1").arg(port.productIdentifier(), 4, 16, QChar('0'));

			




	
	
	
		
 
            pName = pName + " [" + vID + ":" + pID + "]";

			




	
	
	
		
 
        }

			




	
	
	
		
 
        ui->cbPortList->addItem(pName);

			




	
	
	
		
 
        discoveredPorts << port.portName();

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    ui->cbPortList->addItems(userEnteredPorts);

			




	
	
	
		
 

			




	
	
	
		
 
    // find current selection in the new list, maybe it doesn't exist anymore?

			




	
	
	
		
 
    int currentSelectionIndex = ui->cbPortList->findText(currentSelection);

			




	
	
	
		
 
    if (currentSelectionIndex >= 0)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        ui->cbPortList->setCurrentIndex(currentSelectionIndex);

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else // our port doesn't exist anymore, close port if it's open

			




	
	
	
		
 
    {

			




	
	
	
		
 
        if (serialPort->isOpen()) togglePort();

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void PortControl::loadBaudRateList()

			




	
	
	
		
 
{

			




	
	
	
		
 
    ui->cbBaudRate->clear();

			




	
	
	
		
 

			




	
	
	
		
 
    for (auto baudRate : QSerialPortInfo::standardBaudRates())

			




	
	
	
		
 
    {

			




	
	
	
		
 
        ui->cbBaudRate->addItem(QString::number(baudRate));

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void PortControl::selectBaudRate(QString baudRate)

			




	
	
	
		
 
{

			




	
	
	
		
 
    if (serialPort->isOpen())

			




	
	
	
		
 
    {

			




	
	
	
		
 
        if (!serialPort->setBaudRate(baudRate.toInt()))

			




	
	
	
		
 
        {

			




	
	
	
		
 
            qCritical() << "Can't set baud rate!";

			




	
	
	
		
 
        }

			




	
	
	
		
 
        else

			




	
	
	
		
 
        {

			




	
	
	
		
 
            qDebug() << "Baud rate changed to" << serialPort->baudRate();

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void PortControl::selectParity(int parity)

			




	
	
	
		
 
{

			




	
	
	
		
 
    if (serialPort->isOpen())

			




	
	
	
		
 
    {

			




	
	
	
		
 
        if(!serialPort->setParity((QSerialPort::Parity) parity))

			




	
	
	
		
 
        {

			




	
	
	
		
 
            qCritical() << "Can't set parity option!";

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void PortControl::selectDataBits(int dataBits)

			




	
	
	
		
 
{

			




	
	
	
		
 
    if (serialPort->isOpen())

			




	
	
	
		
 
    {

			




	
	
	
		
 
        if(!serialPort->setDataBits((QSerialPort::DataBits) dataBits))

			




	
	
	
		
 
        {

			




	
	
	
		
 
            qCritical() << "Can't set numer of data bits!";

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void PortControl::selectStopBits(int stopBits)

			




	
	
	
		
 
{

			




	
	
	
		
 
    if (serialPort->isOpen())

			




	
	
	
		
 
    {

			




	
	
	
		
 
        if(!serialPort->setStopBits((QSerialPort::StopBits) stopBits))

			




	
	
	
		
 
        {

			




	
	
	
		
 
            qCritical() << "Can't set number of stop bits!";

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void PortControl::selectFlowControl(int flowControl)

			




	
	
	
		
 
{

			




	
	
	
		
 
    if (serialPort->isOpen())

			




	
	
	
		
 
    {

			




	
	
	
		
 
        if(!serialPort->setFlowControl((QSerialPort::FlowControl) flowControl))

			




	
	
	
		
 
        {

			




	
	
	
		
 
            qCritical() << "Can't set flow control option!";

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void PortControl::togglePort()

			




	
	
	
		
 
{

			




	
	
	
		
 
    if (serialPort->isOpen())

			




	
	
	
		
 
    {

			




	
	
	
		
 
        serialPort->close();

			




	
	
	
		
 
        qDebug() << "Closed port:" << serialPort->portName();

			




	
	
	
		
 
        emit portToggled(false);

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else

			




	
	
	
		
 
    {

			




	
	
	
		
 
        // port name may contain description

			




	
	
	
		
 
        QString portName = ui->cbPortList->currentText().split(" ")[0];

			




	
	
	
		
 
        keepPortName(portName);

			




	
	
	
		
 

			




	
	
	
		
 
        serialPort->setPortName(portName);

			




	
	
	
		
 

			




	
	
	
		
 
        // open port

			




	
	
	
		
 
        if (serialPort->open(QIODevice::ReadWrite))

			




	
	
	
		
 
        {

			




	
	
	
		
 
            // set port settings

			




	
	
	
		
 
            selectBaudRate(ui->cbBaudRate->currentText());

			




	
	
	
		
 
            selectParity((QSerialPort::Parity) parityButtons.checkedId());

			




	
	
	
		
 
            selectDataBits((QSerialPort::DataBits) dataBitsButtons.checkedId());

			




	
	
	
		
 
            selectStopBits((QSerialPort::StopBits) stopBitsButtons.checkedId());

			




	
	
	
		
 
            selectFlowControl((QSerialPort::FlowControl) flowControlButtons.checkedId());

			




	
	
	
		
 

			




	
	
	
		
 
            qDebug() << "Opened port:" << serialPort->portName();

			




	
	
	
		
 
            emit portToggled(true);

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 
    openAction.setChecked(serialPort->isOpen());

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void PortControl::selectPort(QString portName)

			




	
	
	
		
 
{

			




	
	
	
		
 
    // portName may be coming from combobox

			




	
	
	
		
 
    portName = portName.split(" ")[0];

			




	
	
	
		
 
    // has selection actually changed

			




	
	
	
		
 
    if (portName != serialPort->portName())

			




	
	
	
		
 
    {

			




	
	
	
		
 
        // if another port is already open, close it by toggling

			




	
	
	
		
 
        if (serialPort->isOpen())

			




	
	
	
		
 
        {

			




	
	
	
		
 
            togglePort();

			




	
	
	
		
 

			




	
	
	
		
 
            // open new selection by toggling

			




	
	
	
		
 
            togglePort();

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void PortControl::enableSkipByte(bool enabled)

			




	
	
	
		
 
{

			




	
	
	
		
 
    ui->pbSkipByte->setDisabled(enabled);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void PortControl::keepPortName(QString portName)

			




	
	
	
		
 
{

			




	
	
	
		
 
    if(!discoveredPorts.contains(portName) &&

			




	
	
	
		
 
       !userEnteredPorts.contains(portName))

			




	
	
	
		
 
    {

			




	
	
	
		
 
        userEnteredPorts << portName;

			




	
	
	
		
 
    }

			




	
	
	
		
 
    if(ui->cbPortList->findText(portName) < 0)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        ui->cbPortList->addItem(portName);

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void PortControl::onPortNameChanged(QString portName)

			




	
	
	
		
 
{

			




	
	
	
		
 
    keepPortName(portName);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
QToolBar* PortControl::toolBar()

			




	
	
	
		
 
{

			




	
	
	
		
 
    return &portToolBar;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void PortControl::openActionTriggered(bool checked)

			




	
	
	
		
 
{

			




	
	
	
		
 
    togglePort();

			




	
	
	
		
 
}

			




        

    


    
    

    

        

                

                    portcontrol.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
/*

			




	
	
	
		
 
  Copyright © 2015 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 PORTCONTROL_H

			




	
	
	
		
 
#define PORTCONTROL_H

			




	
	
	
		
 

			




	
	
	
		
 
#include <QWidget>

			




	
	
	
		
 
#include <QButtonGroup>

			




	
	
	
		
 
#include <QSerialPort>

			




	
	
	
		
 
#include <QStringList>

			




	
	
	
		
 
#include <QToolBar>

			




	
	
	
		
 
#include <QAction>

			




	
	
	
		
 
#include <QComboBox>

			




	
	
	
		
 

			




	
	
	
		
 
#include "portlist.h"

			




	
	
	
		
 

			




	
	
	
		
 
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;

			




	
	
	
		
 
    QComboBox tbPortListBox;

			




	
	
	
		
 
    PortList portList;

			




	
	
	
		
 

			




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

			




	
	
	
		
 
    void portToggled(bool open);

			




	
	
	
		
 
};

			




	
	
	
		
 

			




	
	
	
		
 
#endif // PORTCONTROL_H

			




        

    


    
    

    

        

                

                    portlist.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
new file 100644

			




	
	
	
		
 
/*

			




	
	
	
		
 
  Copyright © 2015 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 <QVariant>

			




	
	
	
		
 
#include <QtDebug>

			




	
	
	
		
 

			




	
	
	
		
 
#include "portlist.h"

			




	
	
	
		
 

			




	
	
	
		
 
PortListItem::PortListItem(QString name, QString description, quint16 vid, quint16 pid)

			




	
	
	
		
 
{

			




	
	
	
		
 
    construct(name, description, vid, pid);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
PortListItem::PortListItem(QSerialPortInfo* portInfo)

			




	
	
	
		
 
{

			




	
	
	
		
 
    if (portInfo->hasProductIdentifier())

			




	
	
	
		
 
    {

			




	
	
	
		
 
        construct(portInfo->portName(),

			




	
	
	
		
 
                  portInfo->description(),

			




	
	
	
		
 
                  portInfo->vendorIdentifier(),

			




	
	
	
		
 
                  portInfo->productIdentifier());

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else

			




	
	
	
		
 
    {

			




	
	
	
		
 
        construct(portInfo->portName());

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void PortListItem::construct(QString name, QString description, quint16 vid, quint16 pid)

			




	
	
	
		
 
{

			




	
	
	
		
 
    QString text = name;

			




	
	
	
		
 
    if (!description.isEmpty())

			




	
	
	
		
 
    {

			




	
	
	
		
 
        text += QString(" ") + description;

			




	
	
	
		
 
    }

			




	
	
	
		
 
    if (vid && pid)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        text += QString("[%1:").arg(vid, 4, 16, QChar('0'));

			




	
	
	
		
 
        text += QString("%1]").arg(pid, 4, 16, QChar('0'));

			




	
	
	
		
 
    }

			




	
	
	
		
 
    setText(text);

			




	
	
	
		
 
    setData(name, PortNameRole);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
QString PortListItem::name()

			




	
	
	
		
 
{

			




	
	
	
		
 
    return data(PortNameRole).toString();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
PortList::PortList(QObject* parent) :

			




	
	
	
		
 
    QStandardItemModel(parent)

			




	
	
	
		
 
{

			




	
	
	
		
 
    loadPortList();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void PortList::loadPortList()

			




	
	
	
		
 
{

			




	
	
	
		
 
    clear();

			




	
	
	
		
 

			




	
	
	
		
 
    for (auto portInfo : QSerialPortInfo::availablePorts())

			




	
	
	
		
 
    {

			




	
	
	
		
 
        appendRow(new PortListItem(&portInfo));

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




        

    


    
    

    

        

                

                    portlist.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
new file 100644

			




	
	
	
		
 
/*

			




	
	
	
		
 
  Copyright © 2015 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 <QStandardItemModel>

			




	
	
	
		
 
#include <QStandardItem>

			




	
	
	
		
 
#include <QList>

			




	
	
	
		
 
#include <QSerialPortInfo>

			




	
	
	
		
 

			




	
	
	
		
 
enum PortListRoles

			




	
	
	
		
 
{

			




	
	
	
		
 
    PortNameRole = Qt::UserRole  // portName as QString

			




	
	
	
		
 
};

			




	
	
	
		
 

			




	
	
	
		
 
class PortListItem : public QStandardItem

			




	
	
	
		
 
{

			




	
	
	
		
 
public:

			




	
	
	
		
 
    PortListItem(QString name, QString description="", quint16 vid=0, quint16 pid=0);

			




	
	
	
		
 
    PortListItem(QSerialPortInfo* portInfo);

			




	
	
	
		
 

			




	
	
	
		
 
    QString name(); // returns only the port name

			




	
	
	
		
 

			




	
	
	
		
 
private:

			




	
	
	
		
 
    // common constructor

			




	
	
	
		
 
    void construct(QString name, QString description="", quint16 vid=0, quint16 pid=0);

			




	
	
	
		
 
};

			




	
	
	
		
 

			




	
	
	
		
 
class PortList : public QStandardItemModel

			




	
	
	
		
 
{

			




	
	
	
		
 
public:

			




	
	
	
		
 
    PortList(QObject* parent=0);

			




	
	
	
		
 

			




	
	
	
		
 
    void loadPortList();

			




	
	
	
		
 

			




	
	
	
		
 
private:

			




	
	
	
		
 
    QList<PortListItem*> userEnteredPorts;

			




	
	
	
		
 
};

			




        

    



    


    



    



      

      





    
    0 comments (0 inline, 0 general)
    





    


  

  







  


    




    








    
        Server instance: zserverv-13856
    
    
        This site is powered by
            Kallithea,
        which is
        © 2010–2021 by various authors & licensed under GPLv3.
            – Support