tempo-plotter Changeset - c374f20e3844 · protofusion repositories

Changeset - c374f20e3844

Parent rev.

Child rev.

[Not reviewed]

Merge scrollbar-exp

0 47 11

Hasan Yavuz ÖZDERYA - 9 years ago 2017-04-24 14:20:22
hy@ozderya.net

Merge with default

58 files changed with 2897 insertions and 429 deletions:

.hgtags

CMakeLists.txt

cmake/modules/BuildQColorWidgets.cmake

cmake/modules/BuildQwt.cmake

cmake/modules/FindQtColorWidgets.cmake

cmake/modules/FindQwt.cmake

cmake/modules/qt_5_2_moc_creation_namespace_fix.diff

serialplot.pro

src/abstractreader.cpp

src/abstractreader.h

src/asciireader.cpp

src/asciireader.h

src/binarystreamreader.cpp

src/binarystreamreader.h

src/channelinfomodel.cpp

390

src/channelinfomodel.h

src/channelmanager.cpp

src/channelmanager.h

src/dataformatpanel.cpp

src/dataformatpanel.h

src/datarecorder.cpp

src/datarecorder.h

src/demoreader.cpp

src/demoreader.h

src/framebuffer.cpp

src/framebufferseries.cpp

src/framebufferseries.h

src/framedreader.cpp

src/framedreader.h

src/hidabletabwidget.cpp

src/hidabletabwidget.h

src/main.cpp

src/mainwindow.cpp

src/mainwindow.h

src/mainwindow.ui

src/plot.cpp

src/plot.h

src/plotcontrolpanel.cpp

166

src/plotcontrolpanel.h

src/plotcontrolpanel.ui

281

src/plotmanager.cpp

104

src/plotmanager.h

src/portcontrol.ui

src/recordpanel.cpp

294

src/recordpanel.h

117

src/recordpanel.ui

227

src/scalepicker.cpp

209

src/scalepicker.h

src/setting_defines.h

src/snapshot.cpp

src/snapshot.h

src/snapshotmanager.cpp

src/snapshotview.cpp

src/snapshotview.ui

src/version.h

src/version.h.in

src/zoomer.cpp

src/zoomer.h

0 comments (0 inline, 0 general)

.hgtags

➞

Show inline comments

 cdddeef73834c62a8ba5f3ac4c000cd4cb059e06 v0.1
 cc41d6c6f4a664b39a74ae202be21b58eaf v0.2
 b87e543fd947b57d45ccf62e9a0886e09cb5 v0.3
 b7092ddffa87776c7886dc071113416f772860 v0.4
 a1ee6b27d1cd655193cfdc032aab76ad7a743c v0.5
 ad8de497561098a63a0d21d36b103cea0719c v0.5.1
 e545d9bf398aa5728e0ae0236f6c014d9fe55320 v0.6
 b4d0a38444d31872633e474d89ffc15cd0fe42f0 v0.7
 b0354ca2c5ea7b3870156417ce7e04e799bbf7 v0.7.1
 fd5f1eb480ec372b49df58b497458de05c30057c v0.8.0
 c9a11cd15fd094e2b2b65dc51805fd8fd1d2460 v0.8.1
 cf9a1ee1f107a38e03dbe17c4f2882c43d827c9 v0.9.0

CMakeLists.txt

➞

Show inline comments

+#
-# Copyright © 2015-2016 Hasan Yavuz Özderya
+# 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/>.
+#
 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)
 # If set, cmake will download Qwt over SVN, build and use it as a static library.
 set(BUILD_QWT true CACHE BOOL "Download and build Qwt automatically.")
 # Find QWT or use static manually provided by user
 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 (BUILD_QWT)
   include(BuildQwt)
 else (BUILD_QWT)
   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)
     find_package(Qwt 6.1 REQUIRED)
 endif (BUILD_QWT)
 # If set, cmake will download QtColorWidgets over git, build and use it as a static library.
 set(BUILD_QTCOLORWIDGETS true CACHE BOOL "Download and build QtColorWidgets library automatically.")
 if (BUILD_QTCOLORWIDGETS)
   include(BuildQColorWidgets)
 else ()
   find_package(QtColorWidgets REQUIRED)
 endif ()
 # includes
 include_directories("./src" ${QWT_INCLUDE_DIR})
 include_directories("./src"
   ${QWT_INCLUDE_DIR}
   ${QTCOLORWIDGETS_INCLUDE_DIRS}
+  )
 # flags
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${QTCOLORWIDGETS_FLAGS}")
 # wrap UI and resource files
 qt5_wrap_ui(UI_FILES
   src/mainwindow.ui
   src/portcontrol.ui
   src/about_dialog.ui
   src/snapshotview.ui
   src/commandpanel.ui
   src/commandwidget.ui
   src/dataformatpanel.ui
   src/plotcontrolpanel.ui
   src/recordpanel.ui
   src/numberformatbox.ui
   src/endiannessbox.ui
   src/binarystreamreadersettings.ui
   src/asciireadersettings.ui
   src/framedreadersettings.ui
+  )
 if (WIN32)
   qt5_add_resources(RES_FILES misc/icons.qrc misc/winicons.qrc)
 else (WIN32)
   qt5_add_resources(RES_FILES misc/icons.qrc)
 endif (WIN32)
 add_executable(${PROGRAM_NAME} WIN32
   src/main.cpp
   src/mainwindow.cpp
   src/portcontrol.cpp
   src/plot.cpp
   src/zoomer.cpp
   src/scrollzoomer.cpp
   src/scrollbar.cpp
   src/hidabletabwidget.cpp
   src/framebuffer.cpp
   src/scalepicker.cpp
   src/scalezoomer.cpp
   src/portlist.cpp
   src/snapshot.cpp
   src/snapshotview.cpp
   src/snapshotmanager.cpp
   src/plotsnapshotoverlay.cpp
   src/commandpanel.cpp
   src/commandwidget.cpp
   src/commandedit.cpp
   src/dataformatpanel.cpp
   src/plotcontrolpanel.cpp
   src/recordpanel.cpp
   src/datarecorder.cpp
   src/tooltipfilter.cpp
   src/sneakylineedit.cpp
   src/channelmanager.cpp
   src/channelinfomodel.cpp
   src/framebufferseries.cpp
   src/numberformatbox.cpp
   src/endiannessbox.cpp
   src/abstractreader.cpp
   src/binarystreamreader.cpp
   src/binarystreamreadersettings.cpp
   src/asciireader.cpp
   src/asciireadersettings.cpp
   src/demoreader.cpp
   src/framedreader.cpp
   src/framedreadersettings.cpp
   src/plotmanager.cpp
   src/numberformat.cpp
   misc/windows_icon.rc
   ${UI_FILES}
   ${RES_FILES}
+  )
 # Use the Widgets module from Qt 5.
 target_link_libraries(${PROGRAM_NAME} ${QWT_LIBRARY})
 qt5_use_modules(${PROGRAM_NAME} Widgets SerialPort Svg)
 target_link_libraries(${PROGRAM_NAME}
   ${QWT_LIBRARY}
   ${QTCOLORWIDGETS_LIBRARIES}
+  )
 qt5_use_modules(${PROGRAM_NAME} Widgets SerialPort)
 if (BUILD_QWT)
   add_dependencies(${PROGRAM_NAME} QWT)
 endif (BUILD_QWT)
 endif ()
 if (BUILD_QTCOLORWIDGETS)
   add_dependencies(${PROGRAM_NAME} QCW)
 endif ()
 # 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 CACHE INT "Program major version number.")
 set(MINOR_VERSION 8 CACHE INT "Program minor version number.")
 set(PATCH_VERSION 1 CACHE INT "Program patch version number.")
 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}/src/version.h.in" "${CMAKE_CURRENT_BINARY_DIR}/version.h")
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DVERSION_REVISION=\\\"${VERSION_REVISION}\\\" ")
 # 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)

cmake/modules/BuildQColorWidgets.cmake

➞

Show inline comments

@@ new file 100644 @@
+#
 # 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(ExternalProject)
 ExternalProject_Add(QCW
   PREFIX qcw
   GIT_REPOSITORY https://github.com/mbasaglia/Qt-Color-Widgets
   PATCH_COMMAND patch -t -p1 -i ${CMAKE_CURRENT_LIST_DIR}/qt_5_2_moc_creation_namespace_fix.diff
   CMAKE_CACHE_ARGS "-DCMAKE_CXX_FLAGS:string=-D QTCOLORWIDGETS_STATICALLY_LINKED"
   UPDATE_COMMAND ""
   INSTALL_COMMAND "")
 ExternalProject_Get_Property(QCW binary_dir source_dir)
 set(QTCOLORWIDGETS_FLAGS "-D QTCOLORWIDGETS_STATICALLY_LINKED")
 set(QTCOLORWIDGETS_LIBRARY ${binary_dir}/libColorWidgets-qt5.a)
 set(QTCOLORWIDGETS_INCLUDE_DIR ${source_dir}/include)
 set(QTCOLORWIDGETS_LIBRARIES ${QTCOLORWIDGETS_LIBRARY})
 set(QTCOLORWIDGETS_INCLUDE_DIRS ${QTCOLORWIDGETS_INCLUDE_DIR})

cmake/modules/BuildQwt.cmake

➞

Show inline comments

@@ @@ -4,33 +4,36 @@ @@
 # 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(ExternalProject)
 ExternalProject_Add(QWT
   PREFIX qwt
   SVN_REPOSITORY svn://svn.code.sf.net/p/qwt/code/branches/qwt-6.1
   # disable QwtDesigner plugin and enable static build
   PATCH_COMMAND sed -i -r -e "s/QWT_CONFIG\\s*\\+=\\s*QwtDesigner/#&/"
                           -e "s/QWT_CONFIG\\s*\\+=\\s*QwtDll/#&/"
                           -e "s/QWT_CONFIG\\s*\\+=\\s*QwtSvg/#&/"
                           -e "s/QWT_CONFIG\\s*\\+=\\s*QwtOpenGL/#&/"
 						  -e "s|QWT_INSTALL_PREFIX\\s*=.*|QWT_INSTALL_PREFIX = <INSTALL_DIR>|"
 							 <SOURCE_DIR>/qwtconfig.pri
                              <SOURCE_DIR>/qwtconfig.pri
   UPDATE_COMMAND ""
   CONFIGURE_COMMAND qmake <SOURCE_DIR>/qwt.pro
+  )
 ExternalProject_Get_Property(QWT install_dir)
 set(QWT_ROOT ${install_dir})
 set(QWT_LIBRARY ${QWT_ROOT}/lib/libqwt.a)
 set(QWT_INCLUDE_DIR ${QWT_ROOT}/include)

cmake/modules/FindQtColorWidgets.cmake

➞

Show inline comments

@@ new file 100644 @@
+#
 # 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/>.
+#
 # Note: this script is intended for the debian package created for serialplot.
 find_library(QTCOLORWIDGETS_LIBRARY "libColorWidgets-qt5.a")
 find_path(QTCOLORWIDGETS_INCLUDE_DIR "color_preview.hpp" PATHS "/usr/include/qtcolorwidgets/" NO_DEFAULT_PATH)
 mark_as_advanced(QTCOLORWIDGETS_LIBRARY QTCOLORWIDGETS_INCLUDE_DIR)
 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(QtColorWidgets DEFAULT_MSG QTCOLORWIDGETS_LIBRARY QTCOLORWIDGETS_INCLUDE_DIR)
 if (QTCOLORWIDGETS_FOUND)
   set(QTCOLORWIDGETS_FLAGS "-D QTCOLORWIDGETS_STATICALLY_LINKED")
   mark_as_advanced(QTCOLORWIDGETS_FLAGS)
   set(QTCOLORWIDGETS_LIBRARIES ${QTCOLORWIDGETS_LIBRARY})
   set(QTCOLORWIDGETS_INCLUDE_DIRS ${QTCOLORWIDGETS_INCLUDE_DIR})
 endif (QTCOLORWIDGETS_FOUND)

cmake/modules/FindQwt.cmake

➞

Show inline comments

+#
-# Copyright © 2015 Hasan Yavuz Özderya
+# 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/>.
+#
 ## First, we look for local Qwt installations, if this fails we will
 ## look into system locations
 file(GLOB qwt_glob_dir "/usr/local/qwt*/" "c:/Qwt*")
 if(qwt_glob_dir)
   foreach(qwt_path ${qwt_glob_dir})
@@ @@ -45,73 +45,73 @@ if(qwt_roots) @@
 	if(qwt_version_string)
 	  string(REGEX REPLACE "[^\"]*\"([0-9.]+)\".*" "\\1"
 		qwt_version_string ${qwt_version_string})
 	  if(Qwt_FIND_VERSION)
 		if( (qwt_version_string VERSION_EQUAL Qwt_FIND_VERSION) OR
 		  (qwt_version_string VERSION_GREATER Qwt_FIND_VERSION))
 		  set(QWT_VERSION ${qwt_version_string})
 		  set(QWT_ROOT ${qwt_root})
 		  break() # found an appropriate version
 		endif()
 	  else(Qwt_FIND_VERSION)
 		set(QWT_ROOT ${qwt_root})
 		set(QWT_VERSION ${qwt_version_string})
 		break() # version is not specified stop at the first qwt_root
 	  endif(Qwt_FIND_VERSION)
 	else(qwt_version_string)
 	  message(WARNING "Couldn't find version string in qwt_global.h file.")
 	endif(qwt_version_string)
   endforeach(qwt_root ${qwt_roots})
 endif(qwt_roots)
 if(QWT_ROOT)
   set(QWT_INCLUDE_DIR "${QWT_ROOT}/include")
   find_library(QWT_LIBRARY "qwt"
+  find_library(QWT_LIBRARY "qwt-qt5"
 	PATHS "${QWT_ROOT}/lib")
 else (QWT_ROOT)
   ## Look into system locations
   find_path(QWT_INCLUDE_DIR qwt_plot.h PATHS /usr/include/qwt)
   # try extracting version information
   if (QWT_INCLUDE_DIR)
 	unset(qwt_version_string)
 	file(STRINGS "${QWT_INCLUDE_DIR}/qwt_global.h" qwt_version_string
 	  REGEX "#define[ \t]+QWT_VERSION_STR")
 	if(qwt_version_string)
 	  string(REGEX REPLACE "[^\"]*\"([0-9.]+)\".*" "\\1"
 		qwt_version_string ${qwt_version_string})
 	  if(Qwt_FIND_VERSION)
 		if( (qwt_version_string VERSION_EQUAL Qwt_FIND_VERSION) OR
 		  (qwt_version_string VERSION_GREATER Qwt_FIND_VERSION))
 		  set(QWT_VERSION ${qwt_version_string})
 		else ()
 		  set(QWT_INCLUDE_DIR "NOTFOUND")
 		endif()
 	  endif(Qwt_FIND_VERSION)
 	endif(qwt_version_string)
   endif (QWT_INCLUDE_DIR)
   # look into system locations for lib file
   find_library(QWT_LIBRARY "qwt" PATHS /usr/lib)
+  find_library(QWT_LIBRARY "qwt-qt5" PATHS /usr/lib)
 endif(QWT_ROOT)
 # set version variables
 if(QWT_VERSION)
   string(REGEX REPLACE "([0-9]+)\\.([0-9]+)\\.([0-9]+)" "\\1"
 	QWT_MAJOR_VERSION ${QWT_VERSION})
   string(REGEX REPLACE "([0-9]+)\\.([0-9]+)\\.([0-9]+)" "\\2"
 	QWT_MINOR_VERSION ${QWT_VERSION})
   string(REGEX REPLACE "([0-9]+)\\.([0-9]+)\\.([0-9]+)" "\\3"
 	QWT_PATCH_VERSION ${QWT_VERSION})
 endif(QWT_VERSION)
 # set QWT_FOUND
 if(QWT_INCLUDE_DIR AND QWT_LIBRARY)
   set(QWT_INCLUDE_DIRS ${QWT_INCLUDE_DIR})
   set(QWT_LIBRARIES ${QWT_LIBRARY})
   set(QWT_FOUND true)
 else()
   set(QWT_FOUND false)
 endif()
 # errors
 if(NOT QWT_FOUND)
   if(Qwt_FIND_QUIET)

cmake/modules/qt_5_2_moc_creation_namespace_fix.diff

➞

Show inline comments

@@ new file 100644 @@
 diff --git a/include/color_dialog.hpp b/include/color_dialog.hpp
 index 5c7653d..895215c 100644
 --- a/include/color_dialog.hpp
 +++ b/include/color_dialog.hpp
@@ -30,6 +30,8 @@
  class QAbstractButton;
 +using namespace color_widgets;
++
  namespace color_widgets {
  class QCP_EXPORT ColorDialog : public QDialog
 diff --git a/include/color_list_widget.hpp b/include/color_list_widget.hpp
 index 282bea5..7d8e0c5 100644
 --- a/include/color_list_widget.hpp
 +++ b/include/color_list_widget.hpp
@@ -25,6 +25,8 @@
  #include "abstract_widget_list.hpp"
  #include "color_wheel.hpp"
 +using namespace color_widgets;
++
  namespace color_widgets {
  class QCP_EXPORT ColorListWidget : public AbstractWidgetList
 diff --git a/include/color_selector.hpp b/include/color_selector.hpp
 index db817d5..48b374d 100644
 --- a/include/color_selector.hpp
 +++ b/include/color_selector.hpp
@@ -25,6 +25,8 @@
  #include "color_preview.hpp"
  #include "color_wheel.hpp"
 +using namespace color_widgets;
++
  namespace color_widgets {
  /**

serialplot.pro

➞

Show inline comments

@@ @@ -46,89 +46,92 @@ SOURCES += \ @@
     src/snapshotview.cpp \
     src/snapshotmanager.cpp \
     src/snapshot.cpp \
     src/plotsnapshotoverlay.cpp \
     src/commandpanel.cpp \
     src/commandwidget.cpp \
     src/commandedit.cpp \
     src/dataformatpanel.cpp \
     src/tooltipfilter.cpp \
     src/sneakylineedit.cpp \
     src/channelmanager.cpp \
     src/framebufferseries.cpp \
     src/plotcontrolpanel.cpp \
     src/numberformatbox.cpp \
     src/endiannessbox.cpp \
     src/framedreadersettings.cpp \
     src/abstractreader.cpp \
     src/binarystreamreader.cpp \
     src/binarystreamreadersettings.cpp \
     src/asciireadersettings.cpp \
     src/asciireader.cpp \
     src/demoreader.cpp \
     src/framedreader.cpp \
     src/plotmanager.cpp \
     src/numberformat.cpp
     src/numberformat.cpp \
     src/recordpanel.cpp
 HEADERS += \
     src/mainwindow.h \
     src/utils.h \
     src/portcontrol.h \
     src/floatswap.h \
     src/plot.h \
     src/zoomer.h \
     src/hidabletabwidget.h \
     src/framebuffer.h \
     src/scalepicker.h \
     src/scalezoomer.h \
     src/portlist.h \
     src/snapshotview.h \
     src/snapshotmanager.h \
     src/snapshot.h \
     src/plotsnapshotoverlay.h \
     src/commandpanel.h \
     src/commandwidget.h \
     src/commandedit.h \
     src/dataformatpanel.h \
     src/tooltipfilter.h \
     src/sneakylineedit.h \
     src/channelmanager.h \
     src/framebufferseries.h \
     src/plotcontrolpanel.h \
     src/numberformatbox.h \
     src/endiannessbox.h \
     src/framedreadersettings.h \
     src/abstractreader.h \
     src/binarystreamreader.h \
     src/binarystreamreadersettings.h \
     src/asciireadersettings.h \
     src/asciireader.h \
     src/demoreader.h \
     src/framedreader.h \
     src/plotmanager.h \
     src/setting_defines.h \
     src/numberformat.h
     src/numberformat.h \
     src/recordpanel.h
 FORMS += \
     src/mainwindow.ui \
     src/about_dialog.ui \
     src/portcontrol.ui \
     src/snapshotview.ui \
     src/commandpanel.ui \
     src/commandwidget.ui \
     src/dataformatpanel.ui \
     src/plotcontrolpanel.ui \
     src/numberformatbox.ui \
     src/endiannessbox.ui \
     src/framedreadersettings.ui \
     src/binarystreamreadersettings.ui \
     src/asciireadersettings.ui
     src/asciireadersettings.ui \
     src/recordpanel.ui
 INCLUDEPATH += qmake/ src/
 CONFIG += c++11
 RESOURCES += misc/icons.qrc
 win32 {
     RESOURCES += misc/winicons.qrc
+}

src/abstractreader.cpp

➞

Show inline comments

 /*
-  Copyright © 2016 Hasan Yavuz Özderya
+  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 "abstractreader.h"
 AbstractReader::AbstractReader(QIODevice* device, ChannelManager* channelMan, QObject *parent) :
 AbstractReader::AbstractReader(QIODevice* device, ChannelManager* channelMan,
                                DataRecorder* recorder, QObject* parent) :
     QObject(parent)
+{
     _device = device;
     _channelMan = channelMan;
     _recorder = recorder;
     recording = false;
     // initialize sps counter
     sampleCount = 0;
     samplesPerSecond = 0;
     QObject::connect(&spsTimer, &QTimer::timeout,
                      this, &AbstractReader::spsTimerTimeout);
     // TODO: start sps timer when reader is enabled
     spsTimer.start(SPS_UPDATE_TIMEOUT * 1000);
+}
 void AbstractReader::spsTimerTimeout()
+{
     unsigned currentSps = samplesPerSecond;
     samplesPerSecond = (sampleCount/numOfChannels())/SPS_UPDATE_TIMEOUT;
     if (currentSps != samplesPerSecond)
+    {
         emit samplesPerSecondChanged(samplesPerSecond);
+    }
     sampleCount = 0;
+}
 void AbstractReader::addData(double* samples, unsigned length)
+{
     _channelMan->addData(samples, length);
     if (recording)
+    {
         _recorder->addData(samples, length, numOfChannels());
+    }
     sampleCount += length;
+}

src/abstractreader.h

➞

Show inline comments

 /*
-  Copyright © 2016 Hasan Yavuz Özderya
+  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/>.
 */
 #ifndef ABSTRACTREADER_H
 #define ABSTRACTREADER_H
 #include <QObject>
 #include <QIODevice>
 #include <QWidget>
 #include <QTimer>
 #include "channelmanager.h"
 #include "datarecorder.h"
 /**
  * All reader classes must inherit this class.
  */
 class AbstractReader : public QObject
+{
     Q_OBJECT
 public:
     explicit AbstractReader(QIODevice* device, ChannelManager* channelMan, QObject *parent = 0);
     explicit AbstractReader(QIODevice* device, ChannelManager* channelMan,
                             DataRecorder* recorder, QObject* parent = 0);
     bool recording;                 /// is recording started
     /**
      * Returns a widget to be shown in data format panel when reader
      * is selected.
      */
     virtual QWidget* settingsWidget() = 0;
     /**
      * Number of channels being read.
+     *
      * This number may be user selected or automatically determined
      * from incoming stream.
      */
     virtual unsigned numOfChannels() = 0;
     /// Reader should only read when enabled. Default state should be
     /// 'disabled'.
     virtual void enable(bool enabled = true) = 0;
     /**
      * @brief Starts sending data to recorder.
+     *
      * @note recorder must have been started!
      */
     void startRecording();
     /// Stops recording.
     void stopRecording();
 signals:
     void numOfChannelsChanged(unsigned);
     // TODO: this must be signaled by 'channel man' for better abstraction
     void dataAdded(); ///< emitted when data added to channel man.
     // TODO: this should be a part of 'channel man'
     void samplesPerSecondChanged(unsigned);
 public slots:
     /**
      * Pauses the reading.
+     *
      * Reader should actually continue reading to keep the
      * synchronization but shouldn't commit data.
      */
     virtual void pause(bool) = 0;
 protected:
     QIODevice* _device;
     ChannelManager* _channelMan;
     /// Implementing class should simply increase this count as samples are read
     unsigned sampleCount;
     /// Should be called with read data
     void addData(double* samples, unsigned length);
 private:
     const int SPS_UPDATE_TIMEOUT = 1;  // second
     unsigned sampleCount;
     unsigned samplesPerSecond;
     ChannelManager* _channelMan;
     DataRecorder* _recorder;
     QTimer spsTimer;
 private slots:
     void spsTimerTimeout();
 };
 #endif // ABSTRACTREADER_H

src/asciireader.cpp

➞

Show inline comments

 /*
-  Copyright © 2016 Hasan Yavuz Özderya
+  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 <QtDebug>
 #include "asciireader.h"
 /// If set to this value number of channels is determined from input
 #define NUMOFCHANNELS_AUTO   (0)
 AsciiReader::AsciiReader(QIODevice* device, ChannelManager* channelMan, QObject *parent) :
     AbstractReader(device, channelMan, parent)
 AsciiReader::AsciiReader(QIODevice* device, ChannelManager* channelMan,
                          DataRecorder* recorder, QObject* parent) :
     AbstractReader(device, channelMan, recorder, parent)
+{
     paused = false;
     discardFirstLine = true;
     sampleCount = 0;
     _numOfChannels = _settingsWidget.numOfChannels();
     autoNumOfChannels = (_numOfChannels == NUMOFCHANNELS_AUTO);
     connect(&_settingsWidget, &AsciiReaderSettings::numOfChannelsChanged,
             [this](unsigned value)
+            {
                 _numOfChannels = value;
                 autoNumOfChannels = (_numOfChannels == NUMOFCHANNELS_AUTO);
                 if (!autoNumOfChannels)
+                {
                     emit numOfChannelsChanged(value);
+                }
             });
     connect(device, &QIODevice::aboutToClose, [this](){discardFirstLine=true;});
+}
 QWidget* AsciiReader::settingsWidget()
+{
     return &_settingsWidget;
+}
 unsigned AsciiReader::numOfChannels()
@@ @@ -118,54 +118,57 @@ void AsciiReader::onDataReady() @@
         auto separatedValues = line.split(',');
         unsigned numReadChannels; // effective number of channels to read
         unsigned numComingChannels = separatedValues.length();
         if (autoNumOfChannels)
+        {
             // did number of channels changed?
             if (numComingChannels != _numOfChannels)
+            {
                 _numOfChannels = numComingChannels;
                 emit numOfChannelsChanged(numComingChannels);
+            }
             numReadChannels = numComingChannels;
+        }
         else if (numComingChannels >= _numOfChannels)
+        {
             numReadChannels = _numOfChannels;
+        }
         else // there is missing channel data
+        {
             numReadChannels = separatedValues.length();
             qWarning() << "Incoming data is missing data for some channels!";
             qWarning() << "Read line: " << line;
+        }
         // parse read line
         double* channelSamples = new double[_numOfChannels]();
         for (unsigned ci = 0; ci < numReadChannels; ci++)
+        {
             bool ok;
             double channelSample = separatedValues[ci].toDouble(&ok);
             if (ok)
+            {
                 _channelMan->addChannelData(ci, &channelSample, 1);
                 sampleCount++;
+            }
             else
             channelSamples[ci] = separatedValues[ci].toDouble(&ok);
             if (!ok)
+            {
                 qWarning() << "Data parsing error for channel: " << ci;
                 qWarning() << "Read line: " << line;
                 channelSamples[ci] = 0;
+            }
+        }
         emit dataAdded();
         // commit data
         addData(channelSamples, _numOfChannels);
         delete[] channelSamples;
+    }
+}
 void AsciiReader::saveSettings(QSettings* settings)
+{
     _settingsWidget.saveSettings(settings);
+}
 void AsciiReader::loadSettings(QSettings* settings)
+{
     _settingsWidget.loadSettings(settings);
+}

src/asciireader.h

➞

Show inline comments

 /*
-  Copyright © 2016 Hasan Yavuz Özderya
+  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/>.
 */
 #ifndef ASCIIREADER_H
 #define ASCIIREADER_H
 #include <QSettings>
 #include "abstractreader.h"
 #include "asciireadersettings.h"
 class AsciiReader : public AbstractReader
+{
     Q_OBJECT
 public:
     explicit AsciiReader(QIODevice* device, ChannelManager* channelMan, QObject *parent = 0);
     explicit AsciiReader(QIODevice* device, ChannelManager* channelMan,
                          DataRecorder* recorder, 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:
     AsciiReaderSettings _settingsWidget;
     unsigned _numOfChannels;
     /// number of channels will be determined from incoming data
     unsigned autoNumOfChannels;
     bool paused;
     // We may have (usually true) started reading in the middle of a
     // line, so its a better idea to just discard first line.
     bool discardFirstLine;
 private slots:
     void onDataReady();

src/binarystreamreader.cpp

➞

Show inline comments

 /*
-  Copyright © 2016 Hasan Yavuz Özderya
+  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 <QtEndian>
 #include <QtDebug>
 #include "binarystreamreader.h"
 #include "floatswap.h"
 BinaryStreamReader::BinaryStreamReader(QIODevice* device, ChannelManager* channelMan, QObject *parent) :
     AbstractReader(device, channelMan, parent)
 BinaryStreamReader::BinaryStreamReader(QIODevice* device, ChannelManager* channelMan,
                                        DataRecorder* recorder, QObject* parent) :
     AbstractReader(device, channelMan, recorder, parent)
+{
     paused = false;
     skipByteRequested = false;
     skipSampleRequested = false;
     sampleCount = 0;
     _numOfChannels = _settingsWidget.numOfChannels();
     connect(&_settingsWidget, &BinaryStreamReaderSettings::numOfChannelsChanged,
             this, &BinaryStreamReader::numOfChannelsChanged);
     connect(&_settingsWidget, &BinaryStreamReaderSettings::numOfChannelsChanged,
             this, &BinaryStreamReader::onNumOfChannelsChanged);
     // initial number format selection
     onNumberFormatChanged(_settingsWidget.numberFormat());
     connect(&_settingsWidget, &BinaryStreamReaderSettings::numberFormatChanged,
             this, &BinaryStreamReader::onNumberFormatChanged);
     // enable skip byte and sample buttons
     connect(&_settingsWidget, &BinaryStreamReaderSettings::skipByteRequested,
             [this]()
+            {
                 skipByteRequested = true;
             });
     connect(&_settingsWidget, &BinaryStreamReaderSettings::skipSampleRequested,
             [this]()
+            {
                 skipSampleRequested = true;
             });
+}
@@ @@ -150,69 +150,56 @@ void BinaryStreamReader::onDataReady() @@
     if (bytesAvailable < packageSize) return;
     int numOfPackagesToRead =
         (bytesAvailable - (bytesAvailable % packageSize)) / packageSize;
     if (paused)
+    {
         // read and discard data
         _device->read(numOfPackagesToRead*packageSize);
         return;
+    }
     double* channelSamples = new double[numOfPackagesToRead*_numOfChannels];
     for (int i = 0; i < numOfPackagesToRead; i++)
+    {
         for (unsigned int ci = 0; ci < _numOfChannels; ci++)
+        {
             // channelSamples[ci].replace(i, (this->*readSample)());
             channelSamples[ci*numOfPackagesToRead+i] = (this->*readSample)();
+        }
+    }
     for (unsigned int ci = 0; ci < _numOfChannels; ci++)
+    {
         addChannelData(ci,
                        channelSamples + ci*numOfPackagesToRead,
                        numOfPackagesToRead);
+    }
     emit dataAdded();
     addData(channelSamples, numOfPackagesToRead*_numOfChannels);
     delete channelSamples;
+    delete[] channelSamples;
+}
 template<typename T> double BinaryStreamReader::readSampleAs()
+{
     T data;
     _device->read((char*) &data, sizeof(data));
     if (_settingsWidget.endianness() == LittleEndian)
+    {
         data = qFromLittleEndian(data);
+    }
     else
+    {
         data = qFromBigEndian(data);
+    }
     return double(data);
+}
 void BinaryStreamReader::addChannelData(unsigned int channel,
                                         double* data, unsigned size)
+{
     _channelMan->addChannelData(channel, data, size);
     sampleCount += size;
+}
 void BinaryStreamReader::saveSettings(QSettings* settings)
+{
     _settingsWidget.saveSettings(settings);
+}
 void BinaryStreamReader::loadSettings(QSettings* settings)
+{
     _settingsWidget.loadSettings(settings);
+}

src/binarystreamreader.h

➞

Show inline comments

 /*
-  Copyright © 2016 Hasan Yavuz Özderya
+  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/>.
 */
 #ifndef BINARYSTREAMREADER_H
 #define BINARYSTREAMREADER_H
 #include <QSettings>
 #include "abstractreader.h"
 #include "binarystreamreadersettings.h"
 /**
  * Reads a simple stream of samples in binary form from the
  * device. There is no means of synchronization other than a button
  * that should be manually triggered by user.
  */
 class BinaryStreamReader : public AbstractReader
+{
     Q_OBJECT
 public:
     explicit BinaryStreamReader(QIODevice* device, ChannelManager* channelMan, QObject *parent = 0);
     explicit BinaryStreamReader(QIODevice* device, ChannelManager* channelMan,
                                 DataRecorder* recorder, 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:
     BinaryStreamReaderSettings _settingsWidget;
     unsigned _numOfChannels;
     unsigned sampleSize;
     bool paused;
     bool skipByteRequested;
     bool skipSampleRequested;
     /// points to the readSampleAs function for currently selected number format
     double (BinaryStreamReader::*readSample)();
     /**
      * Reads 1 sample from the device in given format.
+     *
      * @note Device should already have enough bytes present before
      * calling this function.
      */
     template<typename T> double readSampleAs();
     // `data` contains i th channels data
     void addChannelData(unsigned int channel, double* data, unsigned size);
 private slots:
     void onNumberFormatChanged(NumberFormat numberFormat);
     void onNumOfChannelsChanged(unsigned value);
     void onDataReady();
 };
 #endif // BINARYSTREAMREADER_H

src/channelinfomodel.cpp

➞

Show inline comments

@@ new file 100644 @@
 /*
   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 "channelinfomodel.h"
 #include "setting_defines.h"
 #define NUMOF_COLORS  (32)
 const QColor colors[NUMOF_COLORS] =
+{
     QColor("#ff0056"),
     QColor("#7e2dd2"),
     QColor("#00ae7e"),
     QColor("#fe8900"),
     QColor("#ff937e"),
     QColor("#6a826c"),
     QColor("#ff029d"),
     QColor("#00b917"),
     QColor("#7a4782"),
     QColor("#85a900"),
     QColor("#a42400"),
     QColor("#683d3b"),
     QColor("#bdc6ff"),
     QColor("#263400"),
     QColor("#bdd393"),
     QColor("#d5ff00"),
     QColor("#9e008e"),
     QColor("#001544"),
     QColor("#c28c9f"),
     QColor("#ff74a3"),
     QColor("#01d0ff"),
     QColor("#004754"),
     QColor("#e56ffe"),
     QColor("#788231"),
     QColor("#0e4ca1"),
     QColor("#91d0cb"),
     QColor("#be9970"),
     QColor("#968ae8"),
     QColor("#bb8800"),
     QColor("#43002c"),
     QColor("#deff74"),
     QColor("#00ffc6")
 };
 ChannelInfoModel::ChannelInfoModel(unsigned numberOfChannels, QObject* parent) :
     QAbstractTableModel(parent)
+{
     _numOfChannels = 0;
     setNumOfChannels(numberOfChannels);
+}
 ChannelInfoModel::ChannelInfoModel(const ChannelInfoModel& other) :
     ChannelInfoModel(other.rowCount(), other.parent())
+{
     for (int i = 0; i < other.rowCount(); i++)
+    {
         setData(index(i, COLUMN_NAME),
                 other.data(other.index(i, COLUMN_NAME), Qt::EditRole),
                 Qt::EditRole);
         setData(index(i, COLUMN_NAME),
                 other.data(other.index(i, COLUMN_NAME), Qt::ForegroundRole),
                 Qt::ForegroundRole);
         setData(index(i, COLUMN_VISIBILITY),
                 other.data(other.index(i, COLUMN_VISIBILITY), Qt::CheckStateRole),
                 Qt::CheckStateRole);
+    }
+}
 ChannelInfoModel::ChannelInfoModel(const QStringList& channelNames) :
     ChannelInfoModel(channelNames.length(), NULL)
+{
     for (int i = 0; i < channelNames.length(); i++)
+    {
         setData(index(i, COLUMN_NAME), channelNames[i], Qt::EditRole);
+    }
+}
 ChannelInfoModel::ChannelInfo::ChannelInfo(unsigned index)
+{
     name = tr("Channel %1").arg(index + 1);
     visibility = true;
     color = colors[index % NUMOF_COLORS];
+}
 QString ChannelInfoModel::name(unsigned i) const
+{
     return infos[i].name;
+}
 QColor ChannelInfoModel::color(unsigned i) const
+{
     return infos[i].color;
+}
 bool ChannelInfoModel::isVisible(unsigned i) const
+{
     return infos[i].visibility;
+}
 QStringList ChannelInfoModel::channelNames() const
+{
     QStringList r;
     for (unsigned ci = 0; ci < _numOfChannels; ci++)
+    {
         r << name(ci);
+    }
     return r;
+}
 int ChannelInfoModel::rowCount(const QModelIndex &parent) const
+{
     return _numOfChannels;
+}
 int ChannelInfoModel::columnCount(const QModelIndex & parent) const
+{
     return COLUMN_COUNT;
+}
 Qt::ItemFlags ChannelInfoModel::flags(const QModelIndex &index) const
+{
     if (index.column() == COLUMN_NAME)
+    {
         return Qt::ItemIsEditable | Qt::ItemIsEnabled | Qt::ItemNeverHasChildren | Qt::ItemIsSelectable;
+    }
     else if (index.column() == COLUMN_VISIBILITY)
+    {
         return Qt::ItemIsUserCheckable | Qt::ItemIsEnabled | Qt::ItemNeverHasChildren | Qt::ItemIsSelectable;
+    }
     return Qt::NoItemFlags;
+}
 QVariant ChannelInfoModel::data(const QModelIndex &index, int role) const
+{
     // check index
     if (index.row() >= (int) _numOfChannels || index.row() < 0)
+    {
         return QVariant();
+    }
     // get color
     if (role == Qt::ForegroundRole)
+    {
         return infos[index.row()].color;
+    }
     // get name
     if (index.column() == COLUMN_NAME)
+    {
         if (role == Qt::DisplayRole || role == Qt::EditRole)
+        {
             return QVariant(infos[index.row()].name);
+        }
     } // get visibility
     else if (index.column() == COLUMN_VISIBILITY)
+    {
         if (role == Qt::CheckStateRole)
+        {
             bool visible = infos[index.row()].visibility;
             return visible ? Qt::Checked : Qt::Unchecked;
+        }
+    }
     return QVariant();
+}
 QVariant ChannelInfoModel::headerData(int section, Qt::Orientation orientation, int role) const
+{
     if (orientation == Qt::Horizontal)
+    {
         if (role == Qt::DisplayRole)
+        {
             if (section == COLUMN_NAME)
+            {
                 return tr("Channel");
+            }
             else if (section == COLUMN_VISIBILITY)
+            {
                 return tr("Visible");
+            }
+        }
+    }
     else                        // vertical
+    {
         if (section < (int) _numOfChannels && role == Qt::DisplayRole)
+        {
             return QString::number(section + 1);
+        }
+    }
     return QVariant();
+}
 bool ChannelInfoModel::setData(const QModelIndex &index, const QVariant &value, int role)
+{
     // check index
     if (index.row() >= (int) _numOfChannels || index.row() < 0)
+    {
         return false;
+    }
     // set color
     if (role == Qt::ForegroundRole)
+    {
         infos[index.row()].color = value.value<QColor>();
         emit dataChanged(index, index, QVector<int>({Qt::ForegroundRole}));
         return true;
+    }
     // set name
     if (index.column() == COLUMN_NAME)
+    {
         if (role == Qt::DisplayRole || role == Qt::EditRole)
+        {
             infos[index.row()].name = value.toString();
             emit dataChanged(index, index, QVector<int>({role}));
             return true;
+        }
     } // set visibility
     else if (index.column() == COLUMN_VISIBILITY)
+    {
         if (role == Qt::CheckStateRole)
+        {
             bool checked = value.toInt() == Qt::Checked;
             infos[index.row()].visibility = checked;
             emit dataChanged(index, index, QVector<int>({role}));
             return true;
+        }
+    }
     // invalid index/role
     return false;
+}
 void ChannelInfoModel::setNumOfChannels(unsigned number)
+{
     if (number == _numOfChannels) return;
     bool isInserting = number > _numOfChannels;
     if (isInserting)
+    {
         beginInsertRows(QModelIndex(), _numOfChannels, number-1);
+    }
     else
+    {
         beginRemoveRows(QModelIndex(), number, _numOfChannels-1);
+    }
     // we create channel info but never remove channel info to
     // remember user entered info
     if ((int) number > infos.length())
+    {
         for (unsigned ci = _numOfChannels; ci < number; ci++)
+        {
             infos.append(ChannelInfo(ci));
+        }
+    }
     // make sure newly available channels are visible, we don't
     // remember visibility option intentionally so that user doesn't
     // get confused
     if (number > _numOfChannels)
+    {
         for (unsigned ci = _numOfChannels; ci < number; ci++)
+        {
             infos[ci].visibility = true;
+        }
+    }
     _numOfChannels = number;
     if (isInserting)
+    {
         endInsertRows();
+    }
     else
+    {
         endRemoveRows();
+    }
+}
 void ChannelInfoModel::resetInfos()
+{
     beginResetModel();
     for (unsigned ci = 0; (int) ci < infos.length(); ci++)
+    {
         infos[ci] = ChannelInfo(ci);
+    }
     endResetModel();
+}
 void ChannelInfoModel::resetNames()
+{
     beginResetModel();
     for (unsigned ci = 0; (int) ci < infos.length(); ci++)
+    {
         infos[ci].name = ChannelInfo(ci).name;
+    }
     endResetModel();
+}
 void ChannelInfoModel::resetColors()
+{
     beginResetModel();
     for (unsigned ci = 0; (int) ci < infos.length(); ci++)
+    {
         infos[ci].color = ChannelInfo(ci).color;
+    }
     endResetModel();
+}
 void ChannelInfoModel::resetVisibility()
+{
     beginResetModel();
     for (unsigned ci = 0; (int) ci < infos.length(); ci++)
+    {
         infos[ci].visibility = true;
+    }
     endResetModel();
+}
 void ChannelInfoModel::saveSettings(QSettings* settings)
+{
     settings->beginGroup(SettingGroup_Channels);
     settings->beginWriteArray(SG_Channels_Channel);
     // save all channel information regardless of current number of channels
     for (unsigned ci = 0; (int) ci < infos.length(); ci++)
+    {
         settings->setArrayIndex(ci);
         settings->setValue(SG_Channels_Name, infos[ci].name);
         settings->setValue(SG_Channels_Color, infos[ci].color);
         settings->setValue(SG_Channels_Visible, infos[ci].visibility);
+    }
     settings->endArray();
     settings->endGroup();
+}
 void ChannelInfoModel::loadSettings(QSettings* settings)
+{
     settings->beginGroup(SettingGroup_Channels);
     unsigned size = settings->beginReadArray(SG_Channels_Channel);
     for (unsigned ci = 0; ci < size; ci++)
+    {
         settings->setArrayIndex(ci);
         ChannelInfo chanInfo(ci);
         chanInfo.name       = settings->value(SG_Channels_Name, chanInfo.name).toString();
         chanInfo.color      = settings->value(SG_Channels_Color, chanInfo.color).value<QColor>();
         chanInfo.visibility = settings->value(SG_Channels_Visible, true).toBool();
         if ((int) ci < infos.size())
+        {
             infos[ci] = chanInfo;
             if (ci < _numOfChannels)
+            {
                 auto roles = QVector<int>({
                     Qt::DisplayRole, Qt::EditRole, Qt::ForegroundRole, Qt::CheckStateRole});
                 emit dataChanged(index(ci, 0), index(ci, COLUMN_COUNT-1), roles);
+            }
+        }
         else
+        {
             infos.append(chanInfo);
+        }
+    }
     settings->endArray();
     settings->endGroup();
+}

src/channelinfomodel.h

➞

Show inline comments

@@ new file 100644 @@
 /*
   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/>.
 */
 #ifndef CHANNELINFOMODEL_H
 #define CHANNELINFOMODEL_H
 #include <QAbstractTableModel>
 #include <QColor>
 #include <QSettings>
 #include <QStringList>
 class ChannelInfoModel : public QAbstractTableModel
+{
     Q_OBJECT
 public:
     enum ChannelInfoColumn
+    {
         COLUMN_NAME = 0,
         COLUMN_VISIBILITY,
         COLUMN_COUNT
     };
     explicit ChannelInfoModel(unsigned numberOfChannels, QObject *parent = 0);
     ChannelInfoModel(const ChannelInfoModel& other);
     explicit ChannelInfoModel(const QStringList& channelNames);
     QString name     (unsigned i) const;
     QColor  color    (unsigned i) const;
     bool    isVisible(unsigned i) const;
     /// Returns a list of channel names
     QStringList channelNames() const;
     // implemented from QAbstractItemModel
     int           rowCount(const QModelIndex &parent = QModelIndex()) const;
     int           columnCount(const QModelIndex &parent = QModelIndex()) const;
     QVariant      data(const QModelIndex &index, int role = Qt::DisplayRole) const;
     bool          setData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole);
     Qt::ItemFlags flags(const QModelIndex &index) const;
     QVariant      headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const;
     void setNumOfChannels(unsigned number);
     /// Stores all channel info into a `QSettings`
     void saveSettings(QSettings* settings);
     /// Loads all channel info from a `QSettings`.
     void loadSettings(QSettings* settings);
 public slots:
     /// reset all channel info (names, color etc.)
     void resetInfos();
     /// reset all channel names
     void resetNames();
     /// reset all channel colors
     void resetColors();
     /// reset visibility
     void resetVisibility();
 private:
     struct ChannelInfo
+    {
         explicit ChannelInfo(unsigned index);
         QString name;
         bool visibility;
         QColor color;
     };
     unsigned _numOfChannels;     ///< @note this is not necessarily the length of `infos`
     /**
      * Channel info is added here but never removed so that we can
      * remember user entered info (names, colors etc.).
      */
     QList<ChannelInfo> infos;
 };
 #endif // CHANNELINFOMODEL_H

src/channelmanager.cpp

➞

Show inline comments

 /*
-  Copyright © 2016 Hasan Yavuz Özderya
+  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 <QStringList>
 #include <QModelIndex>
 #include <QtDebug>
 #include "channelmanager.h"
 #include "setting_defines.h"
 ChannelManager::ChannelManager(unsigned numberOfChannels, unsigned numberOfSamples, QObject *parent) :
     QObject(parent)
     QObject(parent),
     _infoModel(numberOfChannels)
+{
     _numOfChannels = numberOfChannels;
     _numOfSamples = numberOfSamples;
     QStringList channelNamesList;
     _paused = false;
     for (unsigned int i = 0; i < numberOfChannels; i++)
+    {
         channelBuffers.append(new FrameBuffer(numberOfSamples));
         channelNamesList << QString("Channel %1").arg(i+1);
+    }
     _channelNames.setStringList(channelNamesList);
     connect(&_channelNames, &QStringListModel::dataChanged,
             this, &ChannelManager::onChannelNameDataChange);
     connect(&_infoModel, &ChannelInfoModel::dataChanged,
             this, &ChannelManager::onChannelInfoChanged);
+}
 ChannelManager::~ChannelManager()
+{
     for (auto buffer : channelBuffers)
+    {
         delete buffer;
+    }
+}
 unsigned ChannelManager::numOfChannels()
+{
     return channelBuffers.size();
+}
 unsigned ChannelManager::numOfSamples()
+{
     return _numOfSamples;
+}
 void ChannelManager::setNumOfChannels(unsigned number)
+{
     unsigned int oldNum = channelBuffers.size();
     if (number > oldNum)
+    {
         // add new channels
         for (unsigned int i = 0; i < number - oldNum; i++)
+        {
             channelBuffers.append(new FrameBuffer(_numOfSamples));
             addChannelName(QString("Channel %1").arg(oldNum+i+1));
+        }
+    }
     else if(number < oldNum)
+    {
         // remove channels
         for (unsigned int i = oldNum-1; i > number-1; i--)
+        {
             delete channelBuffers.takeLast();
             _channelNames.removeRow(i);
+        }
+    }
     _numOfChannels = number;
     _infoModel.setNumOfChannels(number);
     emit numOfChannelsChanged(number);
+}
 void ChannelManager::setNumOfSamples(unsigned number)
+{
     _numOfSamples = number;
     for (int ci = 0; ci < channelBuffers.size(); ci++)
+    {
         channelBuffers[ci]->resize(_numOfSamples);
+    }
     emit numOfSamplesChanged(number);
+}
 void ChannelManager::pause(bool paused)
+{
     _paused = paused;
+}
 FrameBuffer* ChannelManager::channelBuffer(unsigned channel)
+{
     return channelBuffers[channel];
+}
-QStringListModel* ChannelManager::channelNames()
+ChannelInfoModel* ChannelManager::infoModel()
+{
-    return &_channelNames;
+    return &_infoModel;
+}
 QString ChannelManager::channelName(unsigned channel)
+{
     return _channelNames.data(_channelNames.index(channel, 0), Qt::DisplayRole).toString();
     return _infoModel.data(_infoModel.index(channel, ChannelInfoModel::COLUMN_NAME),
                            Qt::DisplayRole).toString();
+}
-void ChannelManager::setChannelName(unsigned channel, QString name)
+QStringList ChannelManager::channelNames()
+{
     _channelNames.setData(_channelNames.index(channel, 0), QVariant(name), Qt::DisplayRole);
     QStringList list;
     for (unsigned ci = 0; ci < _numOfChannels; ci++)
+    {
         list << channelName(ci);
+    }
     return list;
+}
 void ChannelManager::addChannelName(QString name)
 void ChannelManager::onChannelInfoChanged(const QModelIndex & topLeft,
                                           const QModelIndex & bottomRight,
                                           const QVector<int> & roles)
+{
     _channelNames.insertRow(_channelNames.rowCount());
     setChannelName(_channelNames.rowCount()-1, name);
+}
 void ChannelManager::onChannelNameDataChange(const QModelIndex & topLeft,
                                              const QModelIndex & bottomRight,
                                              const QVector<int> & roles)
+{
     Q_UNUSED(roles);
     int start = topLeft.row();
     int end = bottomRight.row();
     int col = topLeft.column();
     // TODO: maybe check `roles` parameter, can't think of a reason for current use case
     for (int i = start; i <= end; i++)
     for (int ci = start; ci <= end; ci++)
+    {
         emit channelNameChanged(i, channelName(i));
         for (auto role : roles)
+        {
             switch (role)
+            {
                 case Qt::EditRole:
                     if (col == ChannelInfoModel::COLUMN_NAME)
+                    {
                         emit channelNameChanged(ci, channelName(ci));
+                    }
                     break;
                 case Qt::ForegroundRole:
                     if (col == ChannelInfoModel::COLUMN_NAME)
+                    {
                         // TODO: emit channel color changed
+                    }
                     break;
                 case Qt::CheckStateRole:
                     if (col == ChannelInfoModel::COLUMN_VISIBILITY)
+                    {
                         // TODO: emit visibility
+                    }
                     break;
+            }
+        }
         // emit channelNameChanged(i, channelName(i));
+    }
+}
-void ChannelManager::addChannelData(unsigned channel, double* data, unsigned size)
+void ChannelManager::addData(double* data, unsigned size)
+{
     channelBuffer(channel)->addSamples(data, size);
     Q_ASSERT(size % _numOfChannels == 0);
     if (_paused) return;
     int n = size / _numOfChannels;
     for (unsigned ci = 0; ci < _numOfChannels; ci++)
+    {
         channelBuffers[ci]->addSamples(&data[ci*n], n);
+    }
     emit dataAdded();
+}
 void ChannelManager::saveSettings(QSettings* settings)
+{
     settings->beginGroup(SettingGroup_Channels);
     settings->beginWriteArray(SG_Channels_Channel);
     for (unsigned i = 0; i < numOfChannels(); i++)
+    {
         settings->setArrayIndex(i);
         settings->setValue(SG_Channels_Name, channelName(i));
+    }
     settings->endArray();
     settings->endGroup();
     _infoModel.saveSettings(settings);
+}
 void ChannelManager::loadSettings(QSettings* settings)
+{
     settings->beginGroup(SettingGroup_Channels);
     settings->beginReadArray(SG_Channels_Channel);
     for (unsigned i = 0; i < numOfChannels(); i++)
+    {
         settings->setArrayIndex(i);
         setChannelName(i, settings->value(SG_Channels_Name, channelName(i)).toString());
+    }
     settings->endArray();
     settings->endGroup();
     _infoModel.loadSettings(settings);
+}

src/channelmanager.h

➞

Show inline comments

 /*
-  Copyright © 2016 Hasan Yavuz Özderya
+  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/>.
 */
 #ifndef CHANNELMANAGER_H
 #define CHANNELMANAGER_H
 #include <QObject>
-#include <QStringListModel>
+#include <QStringList>
 #include <QModelIndex>
 #include <QVector>
 #include <QSettings>
 #include "framebuffer.h"
 #include "channelinfomodel.h"
 class ChannelManager : public QObject
+{
     Q_OBJECT
 public:
     explicit ChannelManager(unsigned numberOfChannels, unsigned numberOfSamples, QObject *parent = 0);
     ~ChannelManager();
     unsigned numOfChannels();
     unsigned numOfSamples();
     FrameBuffer* channelBuffer(unsigned channel);
     QStringListModel* channelNames();
     QString channelName(unsigned channel);
     /// Stores channel names into a `QSettings`
     void saveSettings(QSettings* settings);
     /// Loads channel names from a `QSettings`.
     void loadSettings(QSettings* settings);
     /// Returns a model that manages channel information (name, color etc)
     ChannelInfoModel* infoModel();
     /// Returns a list of channel names
     QStringList channelNames();
 signals:
     void numOfChannelsChanged(unsigned value);
     void numOfSamplesChanged(unsigned value);
     void channelNameChanged(unsigned channel, QString name);
     void dataAdded(); ///< emitted when data added to channel man.
 public slots:
     void setNumOfChannels(unsigned number);
     void setNumOfSamples(unsigned number);
     void setChannelName(unsigned channel, QString name);
     void addChannelData(unsigned channel, double* data, unsigned size);
     /**
      * Add data for all channels.
+     *
      * All channels data is provided in a single array which contains equal
      * number of samples for all channels. Structure is as shown below:
+     *
      * [CH0_SMP0, CH0_SMP1 ... CH0_SMPN, CH1_SMP0, CH1_SMP1, ... , CHN_SMPN]
+     *
      * @param data samples for all channels
      * @param size size of `data`, must be multiple of `numOfChannels`
      */
     void addData(double* data, unsigned size);
     /// When paused `addData` does nothing.
     void pause(bool paused);
 private:
     unsigned _numOfChannels;
     unsigned _numOfSamples;
     bool _paused;
     QList<FrameBuffer*> channelBuffers;
     QStringListModel _channelNames;
     // QStringListModel _channelNames;
     ChannelInfoModel _infoModel;
     void addChannelName(QString name); ///< appends a new channel name at the end of list
 private slots:
     void onChannelNameDataChange(const QModelIndex & topLeft,
                                  const QModelIndex & bottomRight,
                                  const QVector<int> & roles = QVector<int> ());
     void onChannelInfoChanged(const QModelIndex & topLeft,
                               const QModelIndex & bottomRight,
                               const QVector<int> & roles = QVector<int> ());
 };
 #endif // CHANNELMANAGER_H

src/dataformatpanel.cpp

➞

Show inline comments

 /*
-  Copyright © 2016 Hasan Yavuz Özderya
+  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 "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,
                                  DataRecorder* recorder,
                                  QWidget *parent) :
     QWidget(parent),
     ui(new Ui::DataFormatPanel),
     bsReader(port, channelMan, this),
     asciiReader(port, channelMan, this),
     framedReader(port, channelMan, this),
     demoReader(port, channelMan, this)
     bsReader(port, channelMan, recorder, this),
     asciiReader(port, channelMan, recorder, this),
     framedReader(port, channelMan, recorder, this),
     demoReader(port, channelMan, recorder, this)
+{
     ui->setupUi(this);
     serialPort = port;
     _channelMan = channelMan;
     paused = false;
     demoEnabled = 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);
         demoReader.recording = currentReader->recording;
         connect(&demoReader, &DemoReader::samplesPerSecondChanged,
                 this, &DataFormatPanel::samplesPerSecondChanged);
+    }
     else
+    {
         demoReader.enable(false);
         disconnect(&demoReader, 0, this, 0);
+    }
     demoEnabled = enabled;
+}
 void DataFormatPanel::addChannelData(unsigned int channel,
                                      double* data, unsigned size)
 void DataFormatPanel::startRecording()
+{
     _channelMan->addChannelData(channel, data, size);
     currentReader->recording = true;
     if (demoEnabled) demoReader.recording = true;
+}
 void DataFormatPanel::stopRecording()
+{
     currentReader->recording = false;
     if (demoEnabled) demoReader.recording = false;
+}
 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);
     reader->recording = currentReader->recording;
     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);

src/dataformatpanel.h

➞

Show inline comments

 /*
-  Copyright © 2016 Hasan Yavuz Özderya
+  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/>.
 */
 #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"
 #include "datarecorder.h"
 namespace Ui {
 class DataFormatPanel;
+}
 class DataFormatPanel : public QWidget
+{
     Q_OBJECT
 public:
     explicit DataFormatPanel(QSerialPort* port,
                              ChannelManager* channelMan,
                              QWidget *parent = 0);
                              DataRecorder* recorder,
                              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
     /**
      * @brief Starts sending data to recorder.
+     *
      * @note recorder must have been started!
      */
     void startRecording();
     /// Stops recording.
     void stopRecording();
 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;
     bool demoEnabled;
     DemoReader demoReader;
     // `data` contains i th channels data
     void addChannelData(unsigned int channel, double* data, unsigned size);
 };
 #endif // DATAFORMATPANEL_H

src/datarecorder.cpp

➞

Show inline comments

@@ new file 100644 @@
 /*
   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 "datarecorder.h"
 #include <QtDebug>
 DataRecorder::DataRecorder(QObject *parent) :
     QObject(parent),
     fileStream(&file)
+{
     lastNumChannels = 0;
     disableBuffering = false;
     windowsLE = false;
+}
 bool DataRecorder::startRecording(QString fileName, QString separator, QStringList channelNames)
+{
     Q_ASSERT(!file.isOpen());
     _sep =  separator;
     // open file
     file.setFileName(fileName);
     if (!file.open(QIODevice::WriteOnly))
+    {
         qCritical() << "Opening file " << fileName
                     << " for recording failed with error: " << file.error();
         return false;
+    }
     // write header line
     if (!channelNames.isEmpty())
+    {
         fileStream << channelNames.join(_sep);
         fileStream << le();
         lastNumChannels = channelNames.length();
+    }
     return true;
+}
 void DataRecorder::addData(double* data, unsigned length, unsigned numOfChannels)
+{
     Q_ASSERT(length > 0);
     Q_ASSERT(length % numOfChannels == 0);
     if (lastNumChannels != 0 && numOfChannels != lastNumChannels)
+    {
         qWarning() << "Number of channels changed from " << lastNumChannels
                    << " to " << numOfChannels <<
             " during recording, CSV file is corrupted but no data will be lost.";
+    }
     lastNumChannels = numOfChannels;
     unsigned numOfSamples = length / numOfChannels; // per channel
     for (unsigned int i = 0; i < numOfSamples; i++)
+    {
         for (unsigned ci = 0; ci < numOfChannels; ci++)
+        {
             fileStream << data[ci * numOfSamples + i];
             if (ci != numOfChannels-1) fileStream << _sep;
+        }
         fileStream << le();
+    }
     if (disableBuffering) fileStream.flush();
+}
 void DataRecorder::stopRecording()
+{
     Q_ASSERT(file.isOpen());
     file.close();
     lastNumChannels = 0;
+}
 const char* DataRecorder::le() const
+{
     return windowsLE ? "\r\n" : "\n";
+}

src/datarecorder.h

➞

Show inline comments

@@ new file 100644 @@
 /*
   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/>.
 */
 #ifndef DATARECORDER_H
 #define DATARECORDER_H
 #include <QObject>
 #include <QFile>
 #include <QTextStream>
 class DataRecorder : public QObject
+{
     Q_OBJECT
 public:
     explicit DataRecorder(QObject *parent = 0);
     /// Disables file buffering
     bool disableBuffering;
     /**
      * Use CR+LF as line ending. `false` by default.
+     *
      * @note Toggling this variable during a recording will result in
      * a corrupted file. Care must be taken at higher (UI) levels.
      */
     bool windowsLE;
     /**
      * @brief Starts recording data to a file in CSV format.
+     *
      * File is opened and header line (names of channels) is written.
+     *
      * @param fileName name of the recording file
      * @param separator column separator
      * @param channelNames names of the channels for header line, if empty no header line is written
      * @return false if file operation fails (read only etc.)
      */
     bool startRecording(QString fileName, QString separator, QStringList channelNames);
     /**
      * @brief Adds data to a channel.
+     *
      * Multiple rows of data can be added at a time. Each channels
      * data should be ordered consecutively in the `data` array:
+     *
      * [CH0_SMP0, CH0_SMP1 ... CH0_SMPN, CH1_SMP0, CH1_SMP1, ... , CHN_SMPN]
+     *
      * If `numOfChannels` changes during recording, no data will be
      * lost (ie. it will be written to the file) but this will produce
      * an invalid CSV file. An error message will be written to the
      * console.
+     *
      * @param data samples array
      * @param length number of samples in `data`, must be multiple of `numOfChannels`
      * @param numOfChannels how many channels samples this data carries
      */
     void addData(double* data, unsigned length, unsigned numOfChannels);
     /// Stops recording, closes file.
     void stopRecording();
 private:
     unsigned lastNumChannels;   ///< used for error message only
     QFile file;
     QTextStream fileStream;
     QString _sep;
     /// Returns the selected line ending.
     const char* le() const;
 };
 #endif // DATARECORDER_H

src/demoreader.cpp

➞

Show inline comments

 /*
-  Copyright © 2016 Hasan Yavuz Özderya
+  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 <math.h>
 #include "demoreader.h"
 #ifndef M_PI
 #define M_PI 3.14159265358979323846
 #endif
 DemoReader::DemoReader(QIODevice* device, ChannelManager* channelMan, QObject *parent) :
     AbstractReader(device, channelMan, parent)
 DemoReader::DemoReader(QIODevice* device, ChannelManager* channelMan,
                        DataRecorder* recorder, QObject* parent) :
     AbstractReader(device, channelMan, recorder, parent)
+{
     paused = false;
     _numOfChannels = 1;
     count = 0;
     timer.setInterval(100);
     QObject::connect(&timer, &QTimer::timeout,
                      this, &DemoReader::demoTimerTimeout);
+}
 QWidget* DemoReader::settingsWidget()
+{
     return NULL;
+}
 void DemoReader::enable(bool enabled)
+{
     if (enabled)
+    {
         timer.start();
+    }
     else
+    {
         timer.stop();
+    }
@@ @@ -55,34 +56,34 @@ void DemoReader::enable(bool enabled) @@
 unsigned DemoReader::numOfChannels()
+{
     return _numOfChannels;
+}
 void DemoReader::setNumOfChannels(unsigned value)
+{
     _numOfChannels = value;
+}
 void DemoReader::pause(bool enabled)
+{
     paused = enabled;
+}
 void DemoReader::demoTimerTimeout()
+{
     const double period = 100;
     count++;
     if (count >= 100) count = 0;
     if (!paused)
+    {
         double* samples = new double[_numOfChannels];
         for (unsigned ci = 0; ci < _numOfChannels; ci++)
+        {
             // we are calculating the fourier components of square wave
             double value = 4*sin(2*M_PI*double((ci+1)*count)/period)/((2*(ci+1))*M_PI);
             _channelMan->addChannelData(ci, &value, 1);
             sampleCount++;
             samples[ci] = 4*sin(2*M_PI*double((ci+1)*count)/period)/((2*(ci+1))*M_PI);
+        }
         emit dataAdded();
         addData(samples, _numOfChannels);
         delete[] samples;
+    }
+}

src/demoreader.h

➞

Show inline comments

 /*
-  Copyright © 2016 Hasan Yavuz Özderya
+  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/>.
 */
 #ifndef DEMOREADER_H
 #define DEMOREADER_H
 #include <QTimer>
 #include "abstractreader.h"
 /**
  * This is a special case of reader implementation and should be used
  * with care.
+ *
  * There is no settings widget. Number of channels should be set from
  * currently selected actual readers settings widget.
+ *
  * This reader should not be enabled when port is open!
  */
 class DemoReader : public AbstractReader
+{
     Q_OBJECT
 public:
     explicit DemoReader(QIODevice* device, ChannelManager* channelMan, QObject *parent = 0);
     explicit DemoReader(QIODevice* device, ChannelManager* channelMan,
                         DataRecorder* recorder, QObject* parent = 0);
     /// Demo reader is an exception so this function returns NULL
     QWidget* settingsWidget();
     unsigned numOfChannels();
     void enable(bool enabled = true);
 public slots:
     void pause(bool);
     /// Sets the number of channels, this doesn't trigger a `numOfChannelsChanged` signal.
     void setNumOfChannels(unsigned value);
 private:
     bool paused;
     unsigned _numOfChannels;
     QTimer timer;
     int count;
 private slots:
     void demoTimerTimeout();
 };

src/framebuffer.cpp

➞

Show inline comments

@@ @@ -9,49 +9,49 @@ @@
   (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 "framebuffer.h"
 FrameBuffer::FrameBuffer(size_t size)
+{
     _size = size;
     data = new double[_size]();
     headIndex = 0;
     _boundingRect.setCoords(0, 0, size, 0);
+}
 FrameBuffer::~FrameBuffer()
+{
     delete data;
+    delete[] data;
+}
 void FrameBuffer::resize(size_t size)
+{
     int offset = size - _size;
     if (offset == 0) return;
     double* newData = new double[size];
     // move data to new array
     int fill_start = offset > 0 ? offset : 0;
     for (int i = fill_start; i < int(size); i++)
+    {
         newData[i] = sample(i - offset);
+    }
     // fill the beginning of the new data
     if (fill_start > 0)
+    {
         for (int i = 0; i < fill_start; i++)
+        {
             newData[i] = 0;
+        }

src/framebufferseries.cpp

➞

Show inline comments

 /*
-  Copyright © 2016 Hasan Yavuz Özderya
+  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 "framebufferseries.h"
 FrameBufferSeries::FrameBufferSeries(FrameBuffer* buffer)
+{
     xAsIndex = true;
     _xmin = 0;
     _xmax = 1;
     _buffer = buffer;
+}
 void FrameBufferSeries::setXAxis(bool asIndex, double xmin, double xmax)
+{
     xAsIndex = asIndex;
     _xmin = xmin;
     _xmax = xmax;
+}
 size_t FrameBufferSeries::size() const
+{
     return _buffer->size();
+}
 QPointF FrameBufferSeries::sample(size_t i) const
+{
     return QPointF(i, _buffer->sample(i));
     if (xAsIndex)
+    {
         return QPointF(i, _buffer->sample(i));
+    }
     else
+    {
         return QPointF(i * (_xmax - _xmin) / size() + _xmin, _buffer->sample(i));
+    }
+}
 QRectF FrameBufferSeries::boundingRect() const
+{
     return _buffer->boundingRect();
     if (xAsIndex)
+    {
         return _buffer->boundingRect();
+    }
     else
+    {
         auto rect = _buffer->boundingRect();
         rect.setLeft(_xmin);
         rect.setRight(_xmax);
         return rect;
+    }
+}

src/framebufferseries.h

➞

Show inline comments

 /*
-  Copyright © 2016 Hasan Yavuz Özderya
+  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/>.
 */
 #ifndef FRAMEBUFFERSERIES_H
 #define FRAMEBUFFERSERIES_H
 #include <QPointF>
 #include <QRectF>
 #include <qwt_series_data.h>
 #include "framebuffer.h"
 /**
  * This class provides an interface for actual FrameBuffer
  * object. That way we can keep our data structures relatively
  * isolated from Qwt. Otherwise QwtPlotCurve owns FrameBuffer
  * structures.
  */
 class FrameBufferSeries : public QwtSeriesData<QPointF>
+{
 public:
     FrameBufferSeries(FrameBuffer* buffer);
     /// Behavior of X axis
     void setXAxis(bool asIndex, double xmin, double xmax);
     // QwtSeriesData implementations
     size_t size() const;
     QPointF sample(size_t i) const;
     QRectF boundingRect() const;
 private:
     FrameBuffer* _buffer;
     bool xAsIndex;
     double _xmin;
     double _xmax;
 };
 #endif // FRAMEBUFFERSERIES_H

src/framedreader.cpp

➞

Show inline comments

 /*
-  Copyright © 2016 Hasan Yavuz Özderya
+  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 <QtDebug>
 #include <QtEndian>
 #include "floatswap.h"
 #include "framedreader.h"
 FramedReader::FramedReader(QIODevice* device, ChannelManager* channelMan, QObject *parent) :
     AbstractReader(device, channelMan, parent)
 FramedReader::FramedReader(QIODevice* device, ChannelManager* channelMan,
                            DataRecorder* recorder, QObject* parent) :
     AbstractReader(device, channelMan, recorder, parent)
+{
     paused = false;
     // initial settings
     settingsInvalid = 0;
     _numOfChannels = _settingsWidget.numOfChannels();
     hasSizeByte = _settingsWidget.frameSize() == 0;
     frameSize = _settingsWidget.frameSize();
     syncWord = _settingsWidget.syncWord();
     checksumEnabled = _settingsWidget.isChecksumEnabled();
     onNumberFormatChanged(_settingsWidget.numberFormat());
     debugModeEnabled = _settingsWidget.isDebugModeEnabled();
     checkSettings();
     // init setting connections
     connect(&_settingsWidget, &FramedReaderSettings::numberFormatChanged,
             this, &FramedReader::onNumberFormatChanged);
     connect(&_settingsWidget, &FramedReaderSettings::numOfChannelsChanged,
             this, &FramedReader::onNumOfChannelsChanged);
     connect(&_settingsWidget, &FramedReaderSettings::syncWordChanged,
             this, &FramedReader::onSyncWordChanged);
@@ @@ -289,64 +290,56 @@ void FramedReader::readFrameDataAndCheck @@
     unsigned numOfPackagesToRead = frameSize / (_numOfChannels * sampleSize);
     double* channelSamples = new double[numOfPackagesToRead * _numOfChannels];
     for (unsigned i = 0; i < numOfPackagesToRead; i++)
+    {
         for (unsigned int ci = 0; ci < _numOfChannels; ci++)
+        {
             channelSamples[ci*numOfPackagesToRead+i] = (this->*readSample)();
+        }
+    }
     // read checksum
     unsigned rChecksum = 0;
     bool checksumPassed = false;
     if (checksumEnabled)
+    {
         _device->read((char*) &rChecksum, 1);
         calcChecksum &= 0xFF;
         checksumPassed = (calcChecksum == rChecksum);
+    }
     if (!checksumEnabled || checksumPassed)
+    {
         // commit data
         for (unsigned int ci = 0; ci < _numOfChannels; ci++)
+        {
             _channelMan->addChannelData(
                 ci,
                 channelSamples + ci*numOfPackagesToRead,
                 numOfPackagesToRead);
             sampleCount += numOfPackagesToRead;
+        }
         emit dataAdded();
         addData(channelSamples, numOfPackagesToRead*_numOfChannels);
+    }
     else
+    {
         qCritical() << "Checksum failed! Received:" << rChecksum << "Calculated:" << calcChecksum;
+    }
     delete channelSamples;
+    delete[] channelSamples;
+}
 template<typename T> double FramedReader::readSampleAs()
+{
     T data;
     _device->read((char*) &data, sizeof(data));
     if (checksumEnabled)
+    {
         for (unsigned i = 0; i < sizeof(data); i++)
+        {
             calcChecksum += ((unsigned char*) &data)[i];
+        }
+    }
     if (_settingsWidget.endianness() == LittleEndian)
+    {
         data = qFromLittleEndian(data);
+    }
     else
+    {
         data = qFromBigEndian(data);
+    }

src/framedreader.h

➞

Show inline comments

 /*
-  Copyright © 2016 Hasan Yavuz Özderya
+  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/>.
 */
 #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);
     explicit FramedReader(QIODevice* device, ChannelManager* channelMan,
                           DataRecorder* recorder, 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;
@@ @@ -62,37 +63,35 @@ private: @@
     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();
     // `data` contains i th channels data
     void addChannelData(unsigned int channel, double* data, unsigned size);
 private slots:
     void onDataReady();
     void onNumberFormatChanged(NumberFormat numberFormat);
     void onNumOfChannelsChanged(unsigned value);
     void onSyncWordChanged(QByteArray);
     void onFrameSizeChanged(unsigned);
 };
 #endif // FRAMEDREADER_H

src/hidabletabwidget.cpp

➞

Show inline comments

 /*
-  Copyright © 2015 Hasan Yavuz Özderya
+  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 "hidabletabwidget.h"
 #include <QTabBar>
 #include <QToolButton>
 #include <QSizePolicy>
 #include <QTimer>
 #define DOUBLE_CLICK_DELAY (200) // ms
@@ @@ -56,24 +56,29 @@ void HidableTabWidget::onHideAction(bool @@
+    }
+}
 void HidableTabWidget::onTabBarClicked()
+{
     hideAction.setChecked(false);
+}
 void HidableTabWidget::onTabBarDoubleClicked()
+{
     hideAction.setChecked(true);
+}
 void HidableTabWidget::connectSignals()
+{
     if (hideAction.isChecked()) // hidden
+    {
         connect(this, SIGNAL(tabBarClicked(int)), this, SLOT(onTabBarClicked()));
+    }
     else // shown
+    {
         connect(this, SIGNAL(tabBarDoubleClicked(int)), this, SLOT(onTabBarDoubleClicked()));
+    }
+}
 void HidableTabWidget::showTabs()
+{
     hideAction.setChecked(false);
+}

src/hidabletabwidget.h

➞

Show inline comments

 /*
-  Copyright © 2015 Hasan Yavuz Özderya
+  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/>.
 */
 #ifndef HIDABLETABWIDGET_H
 #define HIDABLETABWIDGET_H
 #include <QTabWidget>
 #include <QAction>
 class HidableTabWidget : public QTabWidget
+{
     Q_OBJECT
 public:
     explicit HidableTabWidget(QWidget *parent = 0);
     QAction hideAction;
 public slots:
     void showTabs();
 private slots:
     void onHideAction(bool checked);
     void onTabBarClicked();
     void onTabBarDoubleClicked();
     void connectSignals();
 };
 #endif // HIDABLETABWIDGET_H

src/main.cpp

➞

Show inline comments

 /*
-  Copyright © 2015 Hasan Yavuz Özderya
+  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 <QApplication>
 #include <QtGlobal>
 #include "mainwindow.h"
 #include "tooltipfilter.h"
 #include "version.h"
 MainWindow* pMainWindow;
 void messageHandler(QtMsgType type, const QMessageLogContext &context,
                     const QString &msg)
+{
     // TODO: don't call MainWindow::messageHandler if window is destroyed
     pMainWindow->messageHandler(type, context, msg);
+}
 int main(int argc, char *argv[])
+{
     QApplication a(argc, argv);
     MainWindow w;
     pMainWindow = &w;
     qInstallMessageHandler(messageHandler);
     ToolTipFilter ttf;
     a.installEventFilter(&ttf);
     // log application information
     qDebug() << "SerialPlot" << VERSION_STRING;
     qDebug() << "Revision" << VERSION_REVISION;
     w.show();
     return a.exec();
+}

src/mainwindow.cpp

➞

Show inline comments

 /*
-  Copyright © 2016 Hasan Yavuz Özderya
+  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>
@@ @@ -41,236 +41,308 @@ @@
 #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)
     dataFormatPanel(&serialPort, &channelMan, &recorder),
     recordPanel(&recorder, &channelMan)
+{
     ui->setupUi(this);
     plotMan = new PlotManager(ui->plotArea);
+    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->insertTab(4, &recordPanel, "Record");
     ui->tabWidget->setCurrentIndex(0);
     auto tbPortControl = portControl.toolBar();
     addToolBar(tbPortControl);
     addToolBar(recordPanel.toolbar());
     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);
                 this->ui->tabWidget->showTabs();
             });
     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);
     // plot control signals
     connect(&plotControlPanel, &PlotControlPanel::numOfSamplesChanged,
             this, &MainWindow::onNumOfSamplesChanged);
     connect(&plotControlPanel, &PlotControlPanel::numOfSamplesChanged,
             plotMan, &PlotManager::onNumOfSamplesChanged);
     connect(&plotControlPanel, &PlotControlPanel::scaleChanged,
             plotMan, &PlotManager::setAxis);
     connect(&plotControlPanel, &PlotControlPanel::yScaleChanged,
             plotMan, &PlotManager::setYAxis);
     connect(&plotControlPanel, &PlotControlPanel::xScaleChanged,
             plotMan, &PlotManager::setXAxis);
     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,
+    QObject::connect(&channelMan, &ChannelManager::dataAdded,
                      plotMan, &PlotManager::replot);
     QObject::connect(ui->actionPause, &QAction::triggered,
                      &dataFormatPanel, &DataFormatPanel::pause);
                      &channelMan, &ChannelManager::pause);
     QObject::connect(&recordPanel, &RecordPanel::recordStarted,
                      &dataFormatPanel, &DataFormatPanel::startRecording);
     QObject::connect(&recordPanel, &RecordPanel::recordStopped,
                      &dataFormatPanel, &DataFormatPanel::stopRecording);
     QObject::connect(ui->actionPause, &QAction::triggered,
                      [this](bool enabled)
+                     {
                          if (enabled && !recordPanel.recordPaused())
+                         {
                              dataFormatPanel.pause(true);
+                         }
                          else
+                         {
                              dataFormatPanel.pause(false);
+                         }
                      });
     QObject::connect(&recordPanel, &RecordPanel::recordPausedChanged,
                      [this](bool enabled)
+                     {
                          if (ui->actionPause->isChecked() && enabled)
+                         {
                              dataFormatPanel.pause(false);
+                         }
                      });
     connect(&serialPort, &QIODevice::aboutToClose,
             &recordPanel, &RecordPanel::onPortClose);
     // 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());
     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 scales
     plotMan->setYAxis(plotControlPanel.autoScale(),
                       plotControlPanel.yMin(), plotControlPanel.yMax());
     plotMan->setXAxis(plotControlPanel.xAxisAsIndex(),
                       plotControlPanel.xMin(), plotControlPanel.xMax());
     plotMan->onNumOfSamplesChanged(numOfSamples);
     // 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);
                 this->ui->tabWidget->showTabs();
             });
+}
 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)
+{
     // save snapshots
     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;
+        }
+    }
     // save settings
     QSettings settings("serialplot", "serialplot");
     saveAllSettings(&settings);
     settings.sync();
     if (settings.status() != QSettings::NoError)
+    {
         QString errorText;
         if (settings.status() == QSettings::AccessError)
+        {
             QString file = settings.fileName();
             errorText = QString("Serialplot cannot save settings due to access error. \
 This happens if you have run serialplot as root (with sudo for ex.) previously. \
 Try fixing the permissions of file: %1, or just delete it.").arg(file);
+        }
         else
+        {
             errorText = QString("Serialplot cannot save settings due to unknown error: %1").\
                 arg(settings.status());
+        }
         auto button = QMessageBox::critical(
             NULL,
             "Failed to save settings!", errorText,
             QMessageBox::Cancel | QMessageBox::Ok);
         if (button == 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);
+}
@@ @@ -348,59 +420,48 @@ void MainWindow::onNumOfSamplesChanged(i @@
     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::onChannelNameChanged(unsigned channel, QString name)
+{
     // This slot is triggered also when a new channel is added, in
     // this case curve list doesn't contain said channel. No worries,
     // since `onNumOfChannelsChanged` slot will update curve list.
     if (channel < plotMan->numOfCurves()) // check if channel exists in curve list
+    {
         plotMan->setTitle(channel, name);
+    }
+}
 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
@@ @@ -442,70 +503,77 @@ void MainWindow::messageHandler(QtMsgTyp @@
             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)
+    {
         __builtin_trap();
+    }
+}
 void MainWindow::saveAllSettings(QSettings* settings)
+{
     saveMWSettings(settings);
     portControl.saveSettings(settings);
     dataFormatPanel.saveSettings(settings);
     channelMan.saveSettings(settings);
     plotControlPanel.saveSettings(settings);
     plotMan->saveSettings(settings);
     commandPanel.saveSettings(settings);
     recordPanel.saveSettings(settings);
+}
 void MainWindow::loadAllSettings(QSettings* settings)
+{
     loadMWSettings(settings);
     portControl.loadSettings(settings);
     dataFormatPanel.loadSettings(settings);
     channelMan.loadSettings(settings);
     plotControlPanel.loadSettings(settings);
     plotMan->loadSettings(settings);
     commandPanel.loadSettings(settings);
     recordPanel.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));
     // save toolbar/dockwidgets state
     settings->setValue(SG_MainWindow_State, saveState());
     settings->endGroup();
+}
 void MainWindow::loadMWSettings(QSettings* settings)
+{

src/mainwindow.h

➞

Show inline comments

 /*
-  Copyright © 2016 Hasan Yavuz Özderya
+  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/>.
 */
 #ifndef MAINWINDOW_H
 #define MAINWINDOW_H
 #include <QMainWindow>
 #include <QButtonGroup>
 #include <QLabel>
 #include <QString>
 #include <QVector>
 #include <QList>
 #include <QSerialPort>
 #include <QSignalMapper>
 #include <QTimer>
 #include <QColor>
 #include <QtGlobal>
 #include <QSettings>
 #include <qwt_plot_curve.h>
 #include "portcontrol.h"
 #include "commandpanel.h"
 #include "dataformatpanel.h"
 #include "plotcontrolpanel.h"
 #include "recordpanel.h"
 #include "ui_about_dialog.h"
 #include "framebuffer.h"
 #include "channelmanager.h"
 #include "snapshotmanager.h"
 #include "plotmanager.h"
 #include "datarecorder.h"
 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;
     unsigned int numOfSamples;
     QList<QwtPlotCurve*> curves;
     ChannelManager channelMan;
     PlotManager* plotMan;
     SnapshotManager snapshotMan;
     DataRecorder recorder;       // operated by `recordPanel`
     QLabel spsLabel;
     CommandPanel commandPanel;
     DataFormatPanel dataFormatPanel;
     RecordPanel recordPanel;
     PlotControlPanel plotControlPanel;
     bool isDemoRunning();
     /// Stores settings for all modules
     void saveAllSettings(QSettings* settings);
     /// Load settings for all modules
     void loadAllSettings(QSettings* settings);
     /// Stores main window settings into a `QSettings`
     void saveMWSettings(QSettings* settings);
     /// Loads main window settings from a `QSettings`
     void loadMWSettings(QSettings* settings);
     /// `QWidget::closeEvent` handler
     void closeEvent(QCloseEvent * event);
 private slots:
     void onPortToggled(bool open);
     void onPortError(QSerialPort::SerialPortError error);
     void onNumOfSamplesChanged(int value);
     void onNumOfChannelsChanged(unsigned value);
     void onChannelNameChanged(unsigned channel, QString name);
     void clearPlot();
     void onSpsChanged(unsigned sps);
     void enableDemo(bool enabled);
     void onExportCsv();
     void onSaveSettings();
     void onLoadSettings();
 };
 #endif // MAINWINDOW_H

src/mainwindow.ui

➞

Show inline comments

@@ @@ -120,59 +120,65 @@ @@
    <addaction name="menuView"/>
    <addaction name="menuHelp"/>
   </widget>
   <widget class="QToolBar" name="plotToolBar">
    <property name="windowTitle">
     <string>Plot Toolbar</string>
    </property>
    <attribute name="toolBarArea">
     <enum>TopToolBarArea</enum>
    </attribute>
    <attribute name="toolBarBreak">
     <bool>false</bool>
    </attribute>
    <addaction name="actionPause"/>
    <addaction name="actionClear"/>
   </widget>
   <widget class="QStatusBar" name="statusBar"/>
   <action name="actionPause">
    <property name="checkable">
     <bool>true</bool>
    </property>
    <property name="checked">
     <bool>false</bool>
    </property>
    <property name="icon">
     <iconset theme="player_pause"/>
    </property>
    <property name="text">
     <string>Pause</string>
    </property>
    <property name="toolTip">
     <string>Pause Plotting</string>
    </property>
    <property name="shortcut">
     <string>P</string>
    </property>
   </action>
   <action name="actionClear">
    <property name="icon">
     <iconset theme="editclear"/>
    </property>
    <property name="text">
     <string>Clear</string>
    </property>
    <property name="shortcut">
     <string>Ctrl+K</string>
    </property>
   </action>
   <action name="actionHelpAbout">
    <property name="text">
     <string>&amp;About</string>
    </property>
   </action>
   <action name="actionDemoMode">
    <property name="checkable">
     <bool>true</bool>
    </property>
    <property name="text">
     <string>&amp;Demo Mode</string>
    </property>
    <property name="toolTip">
     <string>Toggle Demo Mode</string>
    </property>
   </action>
   <action name="actionExportCsv">

src/plot.cpp

➞

Show inline comments

 /*
-  Copyright © 2015 Hasan Yavuz Özderya
+  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 <QRectF>
 #include <QKeySequence>
 #include <QColor>
 #include <qwt_symbol.h>
 #include <qwt_plot_curve.h>
 #include <math.h>
 #include <algorithm>
 #include "plot.h"
 #include "utils.h"
 static const int SYMBOL_SHOW_AT_WIDTH = 5;
 static const int SYMBOL_SIZE_MAX = 7;
 Plot::Plot(QWidget* parent) :
     QwtPlot(parent),
     zoomer(this->canvas(), false),
     sZoomer(this, &zoomer)
+{
     isAutoScaled = true;
     symbolSize = 0;
     numOfSamples = 1;
     QObject::connect(&zoomer, &Zoomer::unzoomed, this, &Plot::unzoomed);
     zoomer.setZoomBase(QRectF(0,-1,2,500));
     grid.attach(this);
     legend.attach(this);
     showGrid(false);
     darkBackground(false);
     snapshotOverlay = NULL;
     connect(&zoomer, &QwtPlotZoomer::zoomed,
             [this](const QRectF &rect)
+            {
                 onXScaleChanged();
             });
     connect(this, &QwtPlot::itemAttached,
             [this](QwtPlotItem *plotItem, bool on)
+            {
                 if (symbolSize) updateSymbols();
             });
     // init demo indicator
     QwtText demoText(" DEMO RUNNING ");  // looks better with spaces
     demoText.setColor(QColor("white"));
     demoText.setBackgroundBrush(Qt::darkRed);
     demoText.setBorderRadius(4);
     demoText.setRenderFlags(Qt::AlignLeft | Qt::AlignBottom);
     demoIndicator.setText(demoText);
     demoIndicator.hide();
     demoIndicator.attach(this);
+}
 Plot::~Plot()
+{
     if (snapshotOverlay != NULL) delete snapshotOverlay;
+}
-void Plot::setAxis(bool autoScaled, double yAxisMin, double yAxisMax)
+void Plot::setYAxis(bool autoScaled, double yAxisMin, double yAxisMax)
+{
     this->isAutoScaled = autoScaled;
     if (!autoScaled)
+    {
         yMin = yAxisMin;
         yMax = yAxisMax;
+    }
     zoomer.zoom(0);
     resetAxes();
+}
 void Plot::setXAxis(double xMin, double xMax)
+{
     _xMin = xMin;
     _xMax = xMax;
     zoomer.zoom(0); // unzoom
     // set axis
     setAxisScale(QwtPlot::xBottom, xMin, xMax);
     replot(); // Note: if we don't replot here scale at startup isn't set correctly
     // reset zoom base
     auto base = zoomer.zoomBase();
     base.setLeft(xMin);
     base.setRight(xMax);
     zoomer.setZoomBase(base);
     onXScaleChanged();
+}
 void Plot::resetAxes()
+{
     // reset y axis
     if (isAutoScaled)
+    {
         setAxisAutoScale(QwtPlot::yLeft);
+    }
     else
+    {
         setAxisScale(QwtPlot::yLeft, yMin, yMax);
+    }
     zoomer.setZoomBase();
     replot();
+}
 void Plot::unzoomed()
+{
     setAxisAutoScale(QwtPlot::xBottom);
     resetAxes();
     onXScaleChanged();
+}
 void Plot::showGrid(bool show)
+{
     grid.enableX(show);
     grid.enableY(show);
     replot();
+}
 void Plot::showMinorGrid(bool show)
+{
     grid.enableXMin(show);
     grid.enableYMin(show);
     replot();
+}
 void Plot::showLegend(bool show)
+{
     legend.setVisible(show);
     replot();
+}
@@ @@ -208,73 +231,74 @@ void Plot::flashSnapshotOverlay(bool lig @@
     QColor color;
     if(light)
+    {
         color = QColor(Qt::white);
+    }
     else
+    {
         color = QColor(Qt::black);
+    }
     snapshotOverlay = new PlotSnapshotOverlay(this->canvas(), color);
     connect(snapshotOverlay, &PlotSnapshotOverlay::done,
             [this]()
+            {
                 delete snapshotOverlay;
                 snapshotOverlay = NULL;
             });
+}
 void Plot::onXScaleChanged()
+{
     auto sw = axisWidget(QwtPlot::xBottom);
     auto paintDist = sw->scaleDraw()->scaleMap().pDist();
     auto scaleDist = sw->scaleDraw()->scaleMap().sDist();
     int symDisPx = round(paintDist / scaleDist);
     auto fullScaleDist = zoomer.zoomBase().width();
     auto zoomRate = fullScaleDist / scaleDist;
     float samplesInView = numOfSamples / zoomRate;
     int symDisPx = round(paintDist / samplesInView);
     if (symDisPx < SYMBOL_SHOW_AT_WIDTH)
+    {
         symbolSize = 0;
+    }
     else
+    {
         symbolSize = std::min(SYMBOL_SIZE_MAX, symDisPx-SYMBOL_SHOW_AT_WIDTH+1);
+    }
     updateSymbols();
+}
 void Plot::updateSymbols()
+{
     const QwtPlotItemList curves = itemList( QwtPlotItem::Rtti_PlotCurve );
     if (curves.size() > 0)
+    {
         for (int i = 0; i < curves.size(); i++)
+        {
             QwtSymbol* symbol = NULL;
             QwtPlotCurve* curve = static_cast<QwtPlotCurve*>(curves[i]);
             if (symbolSize)
+            {
                 symbol = new QwtSymbol(QwtSymbol::Ellipse,
                                        canvasBackground(),
                                        curve->pen(),
                                        QSize(symbolSize, symbolSize));
+            }
             curve->setSymbol(symbol);
+        }
+    }
+}
 void Plot::resizeEvent(QResizeEvent * event)
+{
     QwtPlot::resizeEvent(event);
     onXScaleChanged();
+}
 void Plot::onNumOfSamplesChanged(unsigned value)
+{
     auto currentBase = zoomer.zoomBase();
     currentBase.setWidth(value);
     zoomer.setZoomBase(currentBase);
     numOfSamples = value;
     onXScaleChanged();
+}

src/plot.h

➞

Show inline comments

 /*
-  Copyright © 2016 Hasan Yavuz Özderya
+  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/>.
 */
 #ifndef PLOT_H
 #define PLOT_H
 #include <QColor>
 #include <QList>
 #include <QAction>
 #include <qwt_plot.h>
 #include <qwt_plot_grid.h>
 #include <qwt_plot_shapeitem.h>
 #include <qwt_plot_legenditem.h>
 #include <qwt_plot_textlabel.h>
 #include "zoomer.h"
 #include "scalezoomer.h"
 #include "plotsnapshotoverlay.h"
 class Plot : public QwtPlot
+{
     Q_OBJECT
     friend class PlotManager;
 public:
     Plot(QWidget* parent = 0);
     ~Plot();
     static QColor makeColor(unsigned int channelIndex);
 private:
     bool isAutoScaled;
     double yMin, yMax;
     int symbolSize;
     Zoomer zoomer;
     ScaleZoomer sZoomer;
     QwtPlotGrid grid;
     PlotSnapshotOverlay* snapshotOverlay;
     QwtPlotLegendItem legend;
     QwtPlotTextLabel demoIndicator;
     /// update the display of symbols depending on `symbolSize`
     void updateSymbols();
     void resetAxes();
     void resizeEvent(QResizeEvent * event);
 public slots:
     void showGrid(bool show = true);
     void showMinorGrid(bool show = true);
     void showLegend(bool show = true);
     void showDemoIndicator(bool show = true);
     void unzoom();
     void darkBackground(bool enabled = true);
     void setAxis(bool autoScaled, double yMin = 0, double yMax = 1);
     void setYAxis(bool autoScaled, double yMin = 0, double yMax = 1);
     void setXAxis(double xMin, double xMax);
     /**
      * Displays an animation for snapshot.
+     *
      * @param light show a light colored (white) animation or the opposite
      */
     void flashSnapshotOverlay(bool light);
     void onNumOfSamplesChanged(unsigned value);
 protected:
     /// update the display of symbols depending on `symbolSize`
     void updateSymbols();
 private:
     bool isAutoScaled;
     double yMin, yMax;
     double _xMin, _xMax;
     unsigned numOfSamples;
     int symbolSize;
     Zoomer zoomer;
     ScaleZoomer sZoomer;
     QwtPlotGrid grid;
     PlotSnapshotOverlay* snapshotOverlay;
     QwtPlotLegendItem legend;
     QwtPlotTextLabel demoIndicator;
     void resetAxes();
     void resizeEvent(QResizeEvent * event);
 private slots:
     void unzoomed();
     void onXScaleChanged();
 };
 #endif // PLOT_H

src/plotcontrolpanel.cpp

➞

Show inline comments

 /*
-  Copyright © 2016 Hasan Yavuz Özderya
+  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 <QVariant>
 #include <QMessageBox>
 #include <QCheckBox>
 #include <math.h>
 #include "color_selector.hpp"
 #include "plotcontrolpanel.h"
 #include "ui_plotcontrolpanel.h"
 #include "setting_defines.h"
 /// Confirm if #samples is being set to a value greater than this
 const int NUMSAMPLES_CONFIRM_AT = 10000;
 /// Used for scale range selection combobox
 struct Range
+{
     double rmin;
     double rmax;
 };
 Q_DECLARE_METATYPE(Range);
 PlotControlPanel::PlotControlPanel(QWidget *parent) :
     QWidget(parent),
     ui(new Ui::PlotControlPanel)
     ui(new Ui::PlotControlPanel),
     resetAct(tr("Reset"), this),
     resetNamesAct(tr("Reset Names"), this),
     resetColorsAct(tr("Reset Colors"), this),
     showAllAct(tr("Show All"), this),
     resetMenu(tr("Reset Menu"), this)
+{
     ui->setupUi(this);
     warnNumOfSamples = true;    // TODO: load from settings
     _numOfSamples = ui->spNumOfSamples->value();
     // set limits for axis limit boxes
     ui->spYmin->setRange((-1) * std::numeric_limits<double>::max(),
                          std::numeric_limits<double>::max());
     ui->spYmax->setRange((-1) * std::numeric_limits<double>::max(),
                          std::numeric_limits<double>::max());
     ui->spXmin->setRange((-1) * std::numeric_limits<double>::max(),
                          std::numeric_limits<double>::max());
     ui->spXmax->setRange((-1) * std::numeric_limits<double>::max(),
                          std::numeric_limits<double>::max());
     // connect signals
     connect(ui->spNumOfSamples, SIGNAL(valueChanged(int)),
             this, SLOT(onNumOfSamples(int)));
     connect(ui->cbAutoScale, &QCheckBox::toggled,
             this, &PlotControlPanel::onAutoScaleChecked);
     connect(ui->spYmax, SIGNAL(valueChanged(double)),
             this, SLOT(onYScaleChanged()));
     connect(ui->spYmin, SIGNAL(valueChanged(double)),
             this, SLOT(onYScaleChanged()));
     connect(ui->cbIndex, &QCheckBox::toggled,
             this, &PlotControlPanel::onIndexChecked);
     connect(ui->spXmax, SIGNAL(valueChanged(double)),
             this, SLOT(onXScaleChanged()));
     connect(ui->spXmin, SIGNAL(valueChanged(double)),
             this, SLOT(onXScaleChanged()));
     // init scale range preset list
     for (int nbits = 8; nbits <= 24; nbits++) // signed binary formats
+    {
         int rmax = pow(2, nbits-1)-1;
         int rmin = -rmax-1;
         Range r = {double(rmin),  double(rmax)};
         ui->cbRangePresets->addItem(
             QString().sprintf("Signed %d bits %d to +%d", nbits, rmin, rmax),
             QVariant::fromValue(r));
+    }
     for (int nbits = 8; nbits <= 24; nbits++) // unsigned binary formats
+    {
         int rmax = pow(2, nbits)-1;
         ui->cbRangePresets->addItem(
             QString().sprintf("Unsigned %d bits %d to +%d", nbits, 0, rmax),
             QVariant::fromValue(Range{0, double(rmax)}));
+    }
     ui->cbRangePresets->addItem("-1 to +1", QVariant::fromValue(Range{-1, +1}));
     ui->cbRangePresets->addItem("0 to +1", QVariant::fromValue(Range{0, +1}));
     ui->cbRangePresets->addItem("-100 to +100", QVariant::fromValue(Range{-100, +100}));
     ui->cbRangePresets->addItem("0 to +100", QVariant::fromValue(Range{0, +100}));
     QObject::connect(ui->cbRangePresets, SIGNAL(activated(int)),
                      this, SLOT(onRangeSelected()));
     // color selector starts disabled until a channel is selected
     ui->colorSelector->setColor(QColor(0,0,0,0));
     ui->colorSelector->setDisplayMode(color_widgets::ColorPreview::AllAlpha);
     ui->colorSelector->setDisabled(true);
     // reset button
     resetMenu.addAction(&resetNamesAct);
     resetMenu.addAction(&resetColorsAct);
     resetMenu.addAction(&showAllAct);
     resetAct.setMenu(&resetMenu);
     ui->tbReset->setDefaultAction(&resetAct);
+}
 PlotControlPanel::~PlotControlPanel()
+{
     delete ui;
+}
 unsigned PlotControlPanel::numOfSamples()
+{
     return ui->spNumOfSamples->value();
+}
 void PlotControlPanel::onNumOfSamples(int value)
+{
     if (warnNumOfSamples && value > NUMSAMPLES_CONFIRM_AT)
+    {
         // ask confirmation
         if (!askNSConfirmation(value))
+        {
             // revert to old value
             disconnect(ui->spNumOfSamples, SIGNAL(valueChanged(int)),
                        this, SLOT(onNumOfSamples(int)));
             ui->spNumOfSamples->setValue(_numOfSamples);
@@ @@ -142,91 +175,214 @@ bool PlotControlPanel::askNSConfirmation @@
                    text,
                    QMessageBox::Apply | QMessageBox::Cancel,
                    this);
     auto cb = new QCheckBox("Don't show this again.");
     connect(cb, &QCheckBox::stateChanged, [this](int state)
+            {
                 warnNumOfSamples = (state == Qt::Unchecked);
             });
     mb.setCheckBox(cb);
     return mb.exec() == QMessageBox::Apply;
+}
 void PlotControlPanel::onAutoScaleChecked(bool checked)
+{
     if (checked)
+    {
         ui->lYmin->setEnabled(false);
         ui->lYmax->setEnabled(false);
         ui->spYmin->setEnabled(false);
         ui->spYmax->setEnabled(false);
-        emit scaleChanged(true); // autoscale
+        emit yScaleChanged(true); // autoscale
+    }
     else
+    {
         ui->lYmin->setEnabled(true);
         ui->lYmax->setEnabled(true);
         ui->spYmin->setEnabled(true);
         ui->spYmax->setEnabled(true);
-        emit scaleChanged(false, ui->spYmin->value(), ui->spYmax->value());
+        emit yScaleChanged(false, ui->spYmin->value(), ui->spYmax->value());
+    }
+}
 void PlotControlPanel::onYScaleChanged()
+{
     emit scaleChanged(false, ui->spYmin->value(), ui->spYmax->value());
     if (!autoScale())
+    {
         emit yScaleChanged(false, ui->spYmin->value(), ui->spYmax->value());
+    }
+}
 bool PlotControlPanel::autoScale()
+bool PlotControlPanel::autoScale() const
+{
     return ui->cbAutoScale->isChecked();
+}
 double PlotControlPanel::yMax()
+double PlotControlPanel::yMax() const
+{
     return ui->spYmax->value();
+}
 double PlotControlPanel::yMin()
+double PlotControlPanel::yMin() const
+{
     return ui->spYmin->value();
+}
 bool PlotControlPanel::xAxisAsIndex() const
+{
     return ui->cbIndex->isChecked();
+}
 double PlotControlPanel::xMax() const
+{
     return ui->spXmax->value();
+}
 double PlotControlPanel::xMin() const
+{
     return ui->spXmin->value();
+}
 void PlotControlPanel::onRangeSelected()
+{
     Range r = ui->cbRangePresets->currentData().value<Range>();
     ui->spYmin->setValue(r.rmin);
     ui->spYmax->setValue(r.rmax);
     ui->cbAutoScale->setChecked(false);
+}
 void PlotControlPanel::setChannelNamesModel(QAbstractItemModel * model)
 void PlotControlPanel::onIndexChecked(bool checked)
+{
     if (checked)
+    {
         ui->lXmin->setEnabled(false);
         ui->lXmax->setEnabled(false);
         ui->spXmin->setEnabled(false);
         ui->spXmax->setEnabled(false);
         emit xScaleChanged(true); // use index
+    }
     else
+    {
         ui->lXmin->setEnabled(true);
         ui->lXmax->setEnabled(true);
         ui->spXmin->setEnabled(true);
         ui->spXmax->setEnabled(true);
         emit xScaleChanged(false, ui->spXmin->value(), ui->spXmax->value());
+    }
+}
 void PlotControlPanel::onXScaleChanged()
+{
     if (!xAxisAsIndex())
+    {
         emit xScaleChanged(false, ui->spXmin->value(), ui->spXmax->value());
+    }
+}
 void PlotControlPanel::setChannelInfoModel(ChannelInfoModel* model)
+{
     ui->lvChannelNames->setModel(model);
     ui->tvChannelInfo->setModel(model);
     // channel color selector
     connect(ui->tvChannelInfo->selectionModel(), &QItemSelectionModel::currentRowChanged,
             [this](const QModelIndex &current, const QModelIndex &previous)
+            {
                 // TODO: duplicate with below lambda
                 QColor color(0,0,0,0); // transparent
                 if (current.isValid())
+                {
                     ui->colorSelector->setEnabled(true);
                     auto model = ui->tvChannelInfo->model();
                     color = model->data(current, Qt::ForegroundRole).value<QColor>();
+                }
                 else
+                {
                     ui->colorSelector->setDisabled(true);
+                }
                 // temporarily block signals because `setColor` emits `colorChanged`
                 bool wasBlocked = ui->colorSelector->blockSignals(true);
                 ui->colorSelector->setColor(color);
                 ui->colorSelector->blockSignals(wasBlocked);
             });
     connect(ui->tvChannelInfo->selectionModel(), &QItemSelectionModel::selectionChanged,
             [this](const QItemSelection & selected, const QItemSelection & deselected)
+            {
                 if (!selected.length())
+                {
                     ui->colorSelector->setDisabled(true);
                     // temporarily block signals because `setColor` emits `colorChanged`
                     bool wasBlocked = ui->colorSelector->blockSignals(true);
                     ui->colorSelector->setColor(QColor(0,0,0,0));
                     ui->colorSelector->blockSignals(wasBlocked);
+                }
             });
     connect(ui->colorSelector, &color_widgets::ColorSelector::colorChanged,
             [this](QColor color)
+            {
                 auto index = ui->tvChannelInfo->selectionModel()->currentIndex();
                 ui->tvChannelInfo->model()->setData(index, color, Qt::ForegroundRole);
             });
     connect(model, &QAbstractItemModel::dataChanged,
             [this](const QModelIndex & topLeft, const QModelIndex & bottomRight, const QVector<int> & roles = QVector<int> ())
+            {
                 auto current = ui->tvChannelInfo->selectionModel()->currentIndex();
                 // no current selection
                 if (!current.isValid()) return;
                 auto mod = ui->tvChannelInfo->model();
                 QColor color = mod->data(current, Qt::ForegroundRole).value<QColor>();
                 // temporarily block signals because `setColor` emits `colorChanged`
                 bool wasBlocked = ui->colorSelector->blockSignals(true);
                 ui->colorSelector->setColor(color);
                 ui->colorSelector->blockSignals(wasBlocked);
             });
     // reset actions
     connect(&resetAct, &QAction::triggered, model, &ChannelInfoModel::resetInfos);
     connect(&resetNamesAct, &QAction::triggered, model, &ChannelInfoModel::resetNames);
     connect(&resetColorsAct, &QAction::triggered, model, &ChannelInfoModel::resetColors);
     connect(&showAllAct, &QAction::triggered, model, &ChannelInfoModel::resetVisibility);
+}
 void PlotControlPanel::saveSettings(QSettings* settings)
+{
     settings->beginGroup(SettingGroup_Plot);
     settings->setValue(SG_Plot_NumOfSamples, numOfSamples());
     settings->setValue(SG_Plot_IndexAsX, xAxisAsIndex());
     settings->setValue(SG_Plot_XMax, xMax());
     settings->setValue(SG_Plot_XMin, xMin());
     settings->setValue(SG_Plot_AutoScale, autoScale());
     settings->setValue(SG_Plot_YMax, yMax());
     settings->setValue(SG_Plot_YMin, yMin());
     settings->endGroup();
+}
 void PlotControlPanel::loadSettings(QSettings* settings)
+{
     settings->beginGroup(SettingGroup_Plot);
     ui->spNumOfSamples->setValue(
         settings->value(SG_Plot_NumOfSamples, numOfSamples()).toInt());
     ui->cbIndex->setChecked(
         settings->value(SG_Plot_IndexAsX, xAxisAsIndex()).toBool());
     ui->spXmax->setValue(settings->value(SG_Plot_XMax, xMax()).toDouble());
     ui->spXmin->setValue(settings->value(SG_Plot_XMin, xMin()).toDouble());
     ui->cbAutoScale->setChecked(
         settings->value(SG_Plot_AutoScale, autoScale()).toBool());
     ui->spYmax->setValue(settings->value(SG_Plot_YMax, yMax()).toDouble());
     ui->spYmin->setValue(settings->value(SG_Plot_YMin, yMin()).toDouble());
     settings->endGroup();
+}

src/plotcontrolpanel.h

➞

Show inline comments

 /*
-  Copyright © 2016 Hasan Yavuz Özderya
+  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/>.
 */
 #ifndef PLOTCONTROLPANEL_H
 #define PLOTCONTROLPANEL_H
 #include <QWidget>
 #include <QAbstractItemModel>
 #include <QSettings>
 #include <QAction>
 #include <QMenu>
 #include "channelinfomodel.h"
 namespace Ui {
 class PlotControlPanel;
+}
 class PlotControlPanel : public QWidget
+{
     Q_OBJECT
 public:
     explicit PlotControlPanel(QWidget *parent = 0);
     ~PlotControlPanel();
     unsigned numOfSamples();
     bool autoScale();
     double yMax();
     double yMin();
     bool   autoScale() const;
     double yMax() const;
     double yMin() const;
     bool   xAxisAsIndex() const;
     double xMax() const;
     double xMin() const;
-    void setChannelNamesModel(QAbstractItemModel * model);
+    void setChannelInfoModel(ChannelInfoModel* model);
     /// Stores plot settings into a `QSettings`
     void saveSettings(QSettings* settings);
     /// Loads plot settings from a `QSettings`.
     void loadSettings(QSettings* settings);
 signals:
     void numOfSamplesChanged(int value);
     void scaleChanged(bool autoScaled, double yMin = 0, double yMax = 1);
     void yScaleChanged(bool autoScaled, double yMin = 0, double yMax = 1);
     void xScaleChanged(bool asIndex, double xMin = 0, double xMax = 1);
 private:
     Ui::PlotControlPanel *ui;
     /// Holds 'number of samples' after the confirmation
     unsigned _numOfSamples;
     /// User can disable this setting in the checkbox
     bool warnNumOfSamples;
     QAction resetAct, resetNamesAct, resetColorsAct, showAllAct;
     QMenu resetMenu;
     /// Show a confirmation dialog before setting #samples to a big value
     bool askNSConfirmation(int value);
 private slots:
     void onNumOfSamples(int value);
     void onAutoScaleChecked(bool checked);
     void onYScaleChanged();
     void onRangeSelected();
     void onIndexChecked(bool checked);
     void onXScaleChanged();
 };
 #endif // PLOTCONTROLPANEL_H

src/plotcontrolpanel.ui

➞

Show inline comments

 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>PlotControlPanel</class>
  <widget class="QWidget" name="PlotControlPanel">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>590</width>
+    <width>706</width>
     <height>187</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>Form</string>
   </property>
   <layout class="QHBoxLayout" name="horizontalLayout">
    <item>
     <layout class="QVBoxLayout" name="verticalLayout">
      <item>
       <widget class="QLabel" name="label_2">
        <property name="styleSheet">
         <string notr="true">font-weight: bold;</string>
        </property>
        <property name="text">
         <string>Channel Names:</string>
        </property>
       </widget>
      </item>
      <item>
       <widget class="QListView" name="lvChannelNames">
        <property name="maximumSize">
         <size>
          <width>16777215</width>
          <height>170</height>
         </size>
        </property>
       </widget>
      </item>
     </layout>
     <widget class="QWidget" name="widget" native="true">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Maximum" vsizetype="Preferred">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <layout class="QVBoxLayout" name="verticalLayout_2">
       <property name="spacing">
        <number>3</number>
       </property>
       <property name="leftMargin">
        <number>0</number>
       </property>
       <property name="topMargin">
        <number>0</number>
       </property>
       <property name="rightMargin">
        <number>0</number>
       </property>
       <property name="bottomMargin">
        <number>0</number>
       </property>
       <item>
        <widget class="QTableView" name="tvChannelInfo">
         <property name="sizePolicy">
          <sizepolicy hsizetype="MinimumExpanding" vsizetype="Expanding">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="maximumSize">
          <size>
           <width>300</width>
           <height>170</height>
          </size>
         </property>
         <property name="selectionMode">
          <enum>QAbstractItemView::SingleSelection</enum>
         </property>
         <property name="selectionBehavior">
          <enum>QAbstractItemView::SelectRows</enum>
         </property>
        </widget>
       </item>
       <item>
        <layout class="QHBoxLayout" name="horizontalLayout_2">
         <property name="sizeConstraint">
          <enum>QLayout::SetMaximumSize</enum>
         </property>
         <item>
          <widget class="color_widgets::ColorSelector" name="colorSelector" native="true">
           <property name="sizePolicy">
            <sizepolicy hsizetype="Maximum" vsizetype="Preferred">
             <horstretch>0</horstretch>
             <verstretch>0</verstretch>
            </sizepolicy>
           </property>
           <property name="minimumSize">
            <size>
             <width>20</width>
             <height>20</height>
            </size>
           </property>
           <property name="maximumSize">
            <size>
             <width>20</width>
             <height>20</height>
            </size>
           </property>
          </widget>
         </item>
         <item>
          <spacer name="horizontalSpacer">
           <property name="orientation">
            <enum>Qt::Horizontal</enum>
           </property>
           <property name="sizeHint" stdset="0">
            <size>
             <width>1</width>
             <height>20</height>
            </size>
           </property>
          </spacer>
         </item>
         <item>
          <widget class="QToolButton" name="tbReset">
           <property name="text">
            <string>Reset</string>
           </property>
           <property name="popupMode">
            <enum>QToolButton::MenuButtonPopup</enum>
           </property>
           <property name="arrowType">
            <enum>Qt::NoArrow</enum>
           </property>
          </widget>
         </item>
        </layout>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <widget class="Line" name="line">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
     </widget>
    </item>
    <item>
     <layout class="QFormLayout" name="formLayout_2">
      <property name="fieldGrowthPolicy">
-      <enum>QFormLayout::AllNonFixedFieldsGrow</enum>
+      <enum>QFormLayout::FieldsStayAtSizeHint</enum>
      </property>
      <item row="0" column="0">
       <widget class="QLabel" name="label_3">
        <property name="text">
         <string>Number Of Samples:</string>
        </property>
       </widget>
      </item>
      <item row="0" column="1">
       <widget class="QSpinBox" name="spNumOfSamples">
        <property name="toolTip">
         <string>length of X axis</string>
        </property>
        <property name="keyboardTracking">
         <bool>false</bool>
        </property>
        <property name="minimum">
         <number>2</number>
        </property>
        <property name="maximum">
         <number>1000000</number>
        </property>
        <property name="value">
         <number>1000</number>
        </property>
       </widget>
      </item>
      <item row="1" column="0">
       <widget class="QCheckBox" name="cbIndex">
        <property name="text">
         <string>Index as X AXis</string>
        </property>
        <property name="checked">
         <bool>true</bool>
        </property>
       </widget>
      </item>
      <item row="1" column="1">
       <layout class="QHBoxLayout" name="horizontalLayout_4">
        <item>
         <widget class="QLabel" name="lXmin">
          <property name="enabled">
           <bool>false</bool>
          </property>
          <property name="text">
           <string>Xmin</string>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QDoubleSpinBox" name="spXmin">
          <property name="enabled">
           <bool>false</bool>
          </property>
          <property name="minimumSize">
           <size>
            <width>75</width>
            <height>0</height>
           </size>
          </property>
          <property name="maximumSize">
           <size>
            <width>75</width>
            <height>16777215</height>
           </size>
          </property>
          <property name="toolTip">
           <string>lower limit of Y axis</string>
          </property>
          <property name="value">
           <double>0.000000000000000</double>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QLabel" name="lXmax">
          <property name="enabled">
           <bool>false</bool>
          </property>
          <property name="text">
           <string>Xmax</string>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QDoubleSpinBox" name="spXmax">
          <property name="enabled">
           <bool>false</bool>
          </property>
          <property name="maximumSize">
           <size>
            <width>75</width>
            <height>16777215</height>
           </size>
          </property>
          <property name="toolTip">
           <string>upper limit of Y axis</string>
          </property>
          <property name="maximum">
           <double>1000.000000000000000</double>
          </property>
          <property name="value">
           <double>1000.000000000000000</double>
          </property>
         </widget>
        </item>
       </layout>
      </item>
      <item row="2" column="0">
       <widget class="QCheckBox" name="cbAutoScale">
        <property name="text">
         <string>Auto Scale Y Axis</string>
        </property>
        <property name="checked">
         <bool>true</bool>
        </property>
       </widget>
      </item>
      <item row="2" column="0">
       <widget class="QLabel" name="lYmax">
        <property name="enabled">
         <bool>false</bool>
        </property>
        <property name="text">
         <string>Ymax</string>
        </property>
       </widget>
      <item row="2" column="1">
       <layout class="QHBoxLayout" name="horizontalLayout_3">
        <item>
         <widget class="QLabel" name="lYmin">
          <property name="enabled">
           <bool>false</bool>
          </property>
          <property name="text">
           <string>Ymin</string>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QDoubleSpinBox" name="spYmin">
          <property name="enabled">
           <bool>false</bool>
          </property>
          <property name="minimumSize">
           <size>
            <width>75</width>
            <height>0</height>
           </size>
          </property>
          <property name="maximumSize">
           <size>
            <width>75</width>
            <height>16777215</height>
           </size>
          </property>
          <property name="toolTip">
           <string>lower limit of Y axis</string>
          </property>
          <property name="value">
           <double>0.000000000000000</double>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QLabel" name="lYmax">
          <property name="enabled">
           <bool>false</bool>
          </property>
          <property name="text">
           <string>Ymax</string>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QDoubleSpinBox" name="spYmax">
          <property name="enabled">
           <bool>false</bool>
          </property>
          <property name="maximumSize">
           <size>
            <width>75</width>
            <height>16777215</height>
           </size>
          </property>
          <property name="toolTip">
           <string>upper limit of Y axis</string>
          </property>
          <property name="maximum">
           <double>1000.000000000000000</double>
          </property>
          <property name="value">
           <double>1000.000000000000000</double>
          </property>
         </widget>
        </item>
       </layout>
      </item>
      <item row="2" column="1">
       <widget class="QDoubleSpinBox" name="spYmax">
        <property name="enabled">
         <bool>false</bool>
        </property>
        <property name="maximumSize">
         <size>
          <width>75</width>
          <height>16777215</height>
         </size>
        </property>
        <property name="toolTip">
         <string>upper limit of Y axis</string>
        </property>
        <property name="maximum">
         <double>1000.000000000000000</double>
        </property>
        <property name="value">
         <double>1000.000000000000000</double>
        </property>
       </widget>
      </item>
      <item row="3" column="0">
       <widget class="QLabel" name="lYmin">
        <property name="enabled">
         <bool>false</bool>
        </property>
        <property name="text">
         <string>Ymin</string>
        </property>
       </widget>
      </item>
      <item row="3" column="1">
       <widget class="QDoubleSpinBox" name="spYmin">
        <property name="enabled">
         <bool>false</bool>
        </property>
        <property name="maximumSize">
         <size>
          <width>75</width>
          <height>16777215</height>
         </size>
        </property>
        <property name="toolTip">
         <string>lower limit of Y axis</string>
        </property>
        <property name="value">
         <double>0.000000000000000</double>
        </property>
       </widget>
      </item>
      <item row="4" column="0">
      <item row="5" column="0">
       <widget class="QLabel" name="label">
        <property name="text">
         <string>Select Range Preset:</string>
        </property>
       </widget>
      </item>
-     <item row="4" column="1">
+     <item row="5" column="1">
       <widget class="QComboBox" name="cbRangePresets"/>
      </item>
     </layout>
    </item>
    <item>
     <spacer name="horizontalSpacer_2">
      <property name="orientation">
       <enum>Qt::Horizontal</enum>
      </property>
      <property name="sizeType">
       <enum>QSizePolicy::MinimumExpanding</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>1</width>
        <height>20</height>
       </size>
      </property>
     </spacer>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>color_widgets::ColorSelector</class>
    <extends>QWidget</extends>
    <header>color_selector.hpp</header>
    <container>1</container>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>

src/plotmanager.cpp

➞

Show inline comments

 /*
-  Copyright © 2016 Hasan Yavuz Özderya
+  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 <QtDebug>
+#include "qwt_symbol.h"
 #include "plot.h"
 #include "plotmanager.h"
 #include "utils.h"
 #include "setting_defines.h"
 PlotManager::PlotManager(QWidget* plotArea, QObject *parent) :
+PlotManager::PlotManager(QWidget* plotArea, ChannelInfoModel* infoModel, QObject *parent) :
     QObject(parent),
     _plotArea(plotArea),
     showGridAction("&Grid", this),
     showMinorGridAction("&Minor Grid", this),
     unzoomAction("&Unzoom", this),
     darkBackgroundAction("&Dark Background", this),
     showLegendAction("&Legend", this),
     showMultiAction("Multi &Plot", this)
+{
     _autoScaled = true;
     _yMin = 0;
     _yMax = 1;
     isDemoShown = false;
     _infoModel = infoModel;
     _numOfSamples = 1;
     // initalize layout and single widget
     isMulti = false;
     scrollArea = NULL;
     setupLayout(isMulti);
     addPlotWidget();
     // initialize menu actions
     showGridAction.setToolTip("Show Grid");
     showMinorGridAction.setToolTip("Show Minor Grid");
     unzoomAction.setToolTip("Unzoom the Plot");
     darkBackgroundAction.setToolTip("Enable Dark Plot Background");
     showLegendAction.setToolTip("Display the Legend on Plot");
     showMultiAction.setToolTip("Display All Channels Separately");
     showGridAction.setShortcut(QKeySequence("G"));
     showMinorGridAction.setShortcut(QKeySequence("M"));
     showGridAction.setCheckable(true);
     showMinorGridAction.setCheckable(true);
     darkBackgroundAction.setCheckable(true);
     showLegendAction.setCheckable(true);
     showMultiAction.setCheckable(true);
     showGridAction.setChecked(false);
     showMinorGridAction.setChecked(false);
     darkBackgroundAction.setChecked(false);
     showLegendAction.setChecked(true);
     showMultiAction.setChecked(false);
     showMinorGridAction.setEnabled(false);
     connect(&showGridAction, SELECT<bool>::OVERLOAD_OF(&QAction::triggered),
             this, &PlotManager::showGrid);
     connect(&showGridAction, SELECT<bool>::OVERLOAD_OF(&QAction::triggered),
             &showMinorGridAction, &QAction::setEnabled);
     connect(&showMinorGridAction, SELECT<bool>::OVERLOAD_OF(&QAction::triggered),
             this, &PlotManager::showMinorGrid);
     connect(&unzoomAction, &QAction::triggered, this, &PlotManager::unzoom);
     connect(&darkBackgroundAction, SELECT<bool>::OVERLOAD_OF(&QAction::triggered),
             this, &PlotManager::darkBackground);
     connect(&showLegendAction, SELECT<bool>::OVERLOAD_OF(&QAction::triggered),
             this, &PlotManager::showLegend);
     connect(&showLegendAction, SELECT<bool>::OVERLOAD_OF(&QAction::triggered),
             this, &PlotManager::showLegend);
     connect(&showMultiAction, SELECT<bool>::OVERLOAD_OF(&QAction::triggered),
             this, &PlotManager::setMulti);
     // connect to channel info model
     if (_infoModel != NULL)     // TODO: remove when snapshots have infomodel
+    {
         connect(_infoModel, &QAbstractItemModel::dataChanged,
                 this, &PlotManager::onChannelInfoChanged);
         connect(_infoModel, &QAbstractItemModel::modelReset,
                 [this]()
+                {
                     onChannelInfoChanged(_infoModel->index(0, 0), // start
                                          _infoModel->index(_infoModel->rowCount()-1, 0), // end
                                          {}); // roles ignored
                 });
+    }
+}
 PlotManager::~PlotManager()
+{
     while (curves.size())
+    {
         delete curves.takeLast();
+    }
     // remove all widgets
     while (plotWidgets.size())
+    {
         delete plotWidgets.takeLast();
+    }
     if (scrollArea != NULL) delete scrollArea;
+}
 void PlotManager::onChannelInfoChanged(const QModelIndex &topLeft,
                                        const QModelIndex &bottomRight,
                                        const QVector<int> &roles)
+{
     int start = topLeft.row();
     int end = bottomRight.row();
     for (int ci = start; ci <= end; ci++)
+    {
         QString name = topLeft.sibling(ci, ChannelInfoModel::COLUMN_NAME).data(Qt::EditRole).toString();
         QColor color = topLeft.sibling(ci, ChannelInfoModel::COLUMN_NAME).data(Qt::ForegroundRole).value<QColor>();
         bool visible = topLeft.sibling(ci, ChannelInfoModel::COLUMN_VISIBILITY).data(Qt::CheckStateRole).toBool();
         curves[ci]->setTitle(name);
         curves[ci]->setPen(color);
         curves[ci]->setVisible(visible);
         curves[ci]->setItemAttribute(QwtPlotItem::Legend, visible);
         // replot only updated widgets
         if (isMulti)
+        {
             plotWidgets[ci]->updateSymbols(); // required for color change
             plotWidgets[ci]->updateLegend(curves[ci]);
             plotWidgets[ci]->setVisible(visible);
             if (visible)
+            {
                 plotWidgets[ci]->replot();
+            }
+        }
+    }
     // replot single widget
     if (!isMulti)
+    {
         plotWidgets[0]->updateSymbols();
         plotWidgets[0]->updateLegend();
         replot();
+    }
+}
 void PlotManager::setMulti(bool enabled)
+{
     if (enabled == isMulti) return;
     isMulti = enabled;
     // detach all curves
     for (auto curve : curves)
+    {
         curve->detach();
+    }
     // remove all widgets
     while (plotWidgets.size())
+    {
         delete plotWidgets.takeLast();
+    }
     // setup new layout
     setupLayout(isMulti);
     if (isMulti)
+    {
         // add new widgets and attach
@@ @@ -173,74 +230,86 @@ void PlotManager::setupLayout(bool multi @@
         if (scrollArea != NULL)
+        {
             delete scrollArea;
             scrollArea = NULL;
+        }
         layout = new QVBoxLayout(_plotArea);
+    }
     layout->setContentsMargins(2,2,2,2);
     layout->setSpacing(1);
+}
 Plot* PlotManager::addPlotWidget()
+{
     auto plot = new Plot();
     plotWidgets.append(plot);
     layout->addWidget(plot);
     plot->darkBackground(darkBackgroundAction.isChecked());
     plot->showGrid(showGridAction.isChecked());
     plot->showMinorGrid(showMinorGridAction.isChecked());
     plot->showLegend(showLegendAction.isChecked());
     plot->showDemoIndicator(isDemoShown);
     plot->setAxis(_autoScaled, _yMin, _yMax);
     plot->setYAxis(_autoScaled, _yMin, _yMax);
     if (_xAxisAsIndex)
+    {
         plot->setXAxis(0, _numOfSamples);
+    }
     else
+    {
         plot->setXAxis(_xMin, _xMax);
+    }
     return plot;
+}
 void PlotManager::addCurve(QString title, FrameBuffer* buffer)
+{
     auto curve = new QwtPlotCurve(title);
     curve->setSamples(new FrameBufferSeries(buffer));
     auto series = new FrameBufferSeries(buffer);
     series->setXAxis(_xAxisAsIndex, _xMin, _xMax);
     curve->setSamples(series);
     _addCurve(curve);
+}
 void PlotManager::addCurve(QString title, QVector<QPointF> data)
+{
     auto curve = new QwtPlotCurve(title);
     curve->setSamples(data);
     _addCurve(curve);
+}
 void PlotManager::_addCurve(QwtPlotCurve* curve)
+{
     // store and init the curve
     curves.append(curve);
     unsigned index = curves.size()-1;
     curve->setPen(Plot::makeColor(index));
     auto color = _infoModel->color(index);
     curve->setPen(color);
     // create the plot for the curve if we are on multi display
     Plot* plot;
     if (isMulti)
+    {
         // create a new plot widget
         plot = addPlotWidget();
+    }
     else
+    {
         plot = plotWidgets[0];
+    }
     // show the curve
     curve->attach(plot);
     plot->replot();
+}
 void PlotManager::removeCurves(unsigned number)
+{
     for (unsigned i = 0; i < number; i++)
+    {
         if (!curves.isEmpty())
+        {
@@ @@ -325,72 +394,99 @@ void PlotManager::showDemoIndicator(bool @@
+{
     isDemoShown = show;
     for (auto plot : plotWidgets)
+    {
         plot->showDemoIndicator(show);
+    }
+}
 void PlotManager::unzoom()
+{
     for (auto plot : plotWidgets)
+    {
         plot->unzoom();
+    }
+}
 void PlotManager::darkBackground(bool enabled)
+{
     for (auto plot : plotWidgets)
+    {
         plot->darkBackground(enabled);
+    }
+}
-void PlotManager::setAxis(bool autoScaled, double yAxisMin, double yAxisMax)
+void PlotManager::setYAxis(bool autoScaled, double yAxisMin, double yAxisMax)
+{
     _autoScaled = autoScaled;
     _yMin = yAxisMin;
     _yMax = yAxisMax;
     for (auto plot : plotWidgets)
+    {
-        plot->setAxis(autoScaled, yAxisMin, yAxisMax);
+        plot->setYAxis(autoScaled, yAxisMin, yAxisMax);
+    }
+}
 void PlotManager::setXAxis(bool asIndex, double xMin, double xMax)
+{
     _xAxisAsIndex = asIndex;
     _xMin = xMin;
     _xMax = xMax;
     for (auto curve : curves)
+    {
         // TODO: what happens when addCurve(QVector) is used?
         FrameBufferSeries* series = static_cast<FrameBufferSeries*>(curve->data());
         series->setXAxis(asIndex, xMin, xMax);
+    }
     for (auto plot : plotWidgets)
+    {
         if (asIndex)
+        {
             plot->setXAxis(0, _numOfSamples);
+        }
         else
+        {
             plot->setXAxis(xMin, xMax);
+        }
+    }
     replot();
+}
 void PlotManager::flashSnapshotOverlay()
+{
     for (auto plot : plotWidgets)
+    {
         plot->flashSnapshotOverlay(darkBackgroundAction.isChecked());
+    }
+}
 void PlotManager::onNumOfSamplesChanged(unsigned value)
+{
     _numOfSamples = value;
     for (auto plot : plotWidgets)
+    {
         plot->onNumOfSamplesChanged(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());
     settings->endGroup();
+}
 void PlotManager::loadSettings(QSettings* settings)
+{
     settings->beginGroup(SettingGroup_Plot);
     darkBackgroundAction.setChecked(
         settings->value(SG_Plot_DarkBackground, darkBackgroundAction.isChecked()).toBool());
     darkBackground(darkBackgroundAction.isChecked());
     showGridAction.setChecked(
         settings->value(SG_Plot_Grid, showGridAction.isChecked()).toBool());
     showGrid(showGridAction.isChecked());
     showMinorGridAction.setChecked(

src/plotmanager.h

➞

Show inline comments

 /*
-  Copyright © 2016 Hasan Yavuz Özderya
+  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/>.
 */
 #ifndef PLOTMANAGER_H
 #define PLOTMANAGER_H
 #include <QObject>
 #include <QWidget>
 #include <QScrollArea>
 #include <QVBoxLayout>
 #include <QList>
 #include <QSettings>
 #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, QObject *parent = 0);
+    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);
     /// Set the Y axis
     void setAxis(bool autoScaled, double yMin = 0, double yMax = 1);
     void setYAxis(bool autoScaled, double yMin = 0, double yMax = 1);
     /// Set the X axis
     void setXAxis(bool asIndex, double xMin = 0 , double xMax = 1);
     /// Display an animation for snapshot
     void flashSnapshotOverlay();
     /// Should be called to update zoom base
     void onNumOfSamplesChanged(unsigned value);
 private:
     bool isMulti;
     QWidget* _plotArea;
     QVBoxLayout* layout; ///< layout of the `plotArea`
     QScrollArea* scrollArea;
     QList<QwtPlotCurve*> curves;
     QList<Plot*> plotWidgets;
     ChannelInfoModel* _infoModel;
     bool isDemoShown;
     bool _autoScaled;
     double _yMin;
     double _yMax;
     bool _xAxisAsIndex;
     double _xMin;
     double _xMax;
     unsigned _numOfSamples;
     // menu actions
     QAction showGridAction;
     QAction showMinorGridAction;
     QAction unzoomAction;
     QAction darkBackgroundAction;
     QAction showLegendAction;
     QAction showMultiAction;
     void setupLayout(bool multiPlot);
     /// Inserts a new plot widget to the current layout.
     Plot* addPlotWidget();
     /// Returns the plot widget that given curve is attached to
     Plot* plotWidget(unsigned curveIndex);
     /// Common part of overloaded `addCurve` functions
     void _addCurve(QwtPlotCurve* curve);
 private slots:
     void showGrid(bool show = true);
     void showMinorGrid(bool show = true);
     void showLegend(bool show = true);
     void unzoom();
     void darkBackground(bool enabled = true);
     void onChannelInfoChanged(const QModelIndex & topLeft,
                               const QModelIndex & bottomRight,
                               const QVector<int> & roles = QVector<int> ());
 };
 #endif // PLOTMANAGER_H

src/portcontrol.ui

➞

Show inline comments

@@ @@ -296,27 +296,45 @@ @@
         <string>Open</string>
        </property>
        <property name="checkable">
         <bool>true</bool>
        </property>
       </widget>
      </item>
      <item>
       <spacer name="verticalSpacer">
        <property name="orientation">
         <enum>Qt::Vertical</enum>
        </property>
        <property name="sizeHint" stdset="0">
         <size>
          <width>20</width>
          <height>40</height>
         </size>
        </property>
       </spacer>
      </item>
     </layout>
    </item>
   </layout>
  </widget>
  <tabstops>
   <tabstop>cbPortList</tabstop>
   <tabstop>pbReloadPorts</tabstop>
   <tabstop>pbOpenPort</tabstop>
   <tabstop>cbBaudRate</tabstop>
   <tabstop>rbNoParity</tabstop>
   <tabstop>rbOddParity</tabstop>
   <tabstop>rbEvenParity</tabstop>
   <tabstop>rb8Bits</tabstop>
   <tabstop>rb7Bits</tabstop>
   <tabstop>rb6Bits</tabstop>
   <tabstop>rb5Bits</tabstop>
   <tabstop>rb1StopBit</tabstop>
   <tabstop>rb2StopBit</tabstop>
   <tabstop>rbNoFlowControl</tabstop>
   <tabstop>rbHardwareControl</tabstop>
   <tabstop>rbSoftwareControl</tabstop>
  </tabstops>
  <resources/>
  <connections/>
 </ui>

src/recordpanel.cpp

➞

Show inline comments

@@ new file 100644 @@
 /*
   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 <QIcon>
 #include <QFile>
 #include <QFileInfo>
 #include <QMessageBox>
 #include <QFileDialog>
 #include <QRegularExpression>
 #include <QtDebug>
 #include "recordpanel.h"
 #include "ui_recordpanel.h"
 #include "setting_defines.h"
 RecordPanel::RecordPanel(DataRecorder* recorder, ChannelManager* channelMan, QWidget *parent) :
     QWidget(parent),
     ui(new Ui::RecordPanel),
     recordToolBar(tr("Record Toolbar")),
     recordAction(QIcon::fromTheme("media-record"), tr("Record"), this)
+{
     overwriteSelected = false;
     _recorder = recorder;
     _channelMan = channelMan;
     ui->setupUi(this);
     recordToolBar.setObjectName("tbRecord");
     recordAction.setCheckable(true);
     recordToolBar.addAction(&recordAction);
     ui->pbRecord->setDefaultAction(&recordAction);
     connect(ui->pbBrowse, &QPushButton::clicked,
             this, &RecordPanel::selectFile);
     connect(&recordAction, &QAction::triggered,
             this, &RecordPanel::onRecord);
     connect(ui->cbRecordPaused, SIGNAL(toggled(bool)),
             this, SIGNAL(recordPausedChanged(bool)));
     connect(ui->cbDisableBuffering, &QCheckBox::toggled,
             [this](bool enabled)
+            {
                 _recorder->disableBuffering = enabled;
             });
     connect(ui->cbWindowsLE, &QCheckBox::toggled,
             [this](bool enabled)
+            {
                 _recorder->windowsLE = enabled;
             });
     connect(&recordAction, &QAction::toggled, ui->cbWindowsLE, &QWidget::setDisabled);
+}
 RecordPanel::~RecordPanel()
+{
     delete ui;
+}
 QToolBar* RecordPanel::toolbar()
+{
     return &recordToolBar;
+}
 bool RecordPanel::isRecording()
+{
     return recordAction.isChecked();
+}
 bool RecordPanel::recordPaused()
+{
     return ui->cbRecordPaused->isChecked();
+}
 bool RecordPanel::selectFile()
+{
     QString fileName = QFileDialog::getSaveFileName(
         parentWidget(), tr("Select recording file"));
     if (fileName.isEmpty())
+    {
         return false;
+    }
     else
+    {
         selectedFile = fileName;
         ui->lbFileName->setText(selectedFile);
         overwriteSelected = QFile::exists(fileName);
         return true;
+    }
+}
 void RecordPanel::onRecord(bool start)
+{
     if (!start)
+    {
         stopRecording();
         return;
+    }
     bool canceled = false;
     if (ui->leSeparator->text().isEmpty())
+    {
         QMessageBox::critical(this, "Error",
                               "Column separator cannot be empty! Please select a separator.");
         ui->leSeparator->setFocus(Qt::OtherFocusReason);
         canceled = true;
+    }
     // check file name
     if (!canceled && selectedFile.isEmpty() && !selectFile())
+    {
         canceled = true;
+    }
     if (!canceled && !overwriteSelected && QFile::exists(selectedFile))
+    {
         if (ui->cbAutoIncrement->isChecked())
+        {
             // TODO: should we increment even if user selected to replace?
             canceled = !incrementFileName();
+        }
         else
+        {
             canceled = !confirmOverwrite(selectedFile);
+        }
+    }
     if (canceled)
+    {
         recordAction.setChecked(false);
+    }
     else
+    {
         overwriteSelected = false;
         startRecording();
+    }
+}
 bool RecordPanel::incrementFileName(void)
+{
     QFileInfo fileInfo(selectedFile);
     QString base = fileInfo.completeBaseName();
     QRegularExpression regex("(.*?)(\\d+)(?!.*\\d)(.*)");
     auto match = regex.match(base);
     if (match.hasMatch())
+    {
         bool ok;
         int fileNum = match.captured(2).toInt(&ok);
         base = match.captured(1) + QString::number(fileNum + 1) + match.captured(3);
+    }
     else
+    {
         base += "_1";
+    }
     QString suffix = fileInfo.suffix();;
     if (!suffix.isEmpty())
+    {
         suffix = "." + suffix;
+    }
     QString autoFileName = fileInfo.path() + "/" + base + suffix;
     // check if auto generated file name exists, ask user another name
     if (QFile::exists(autoFileName))
+    {
         if (!confirmOverwrite(autoFileName))
+        {
             return false;
+        }
+    }
     else
+    {
         selectedFile = autoFileName;
+    }
     ui->lbFileName->setText(selectedFile);
     return true;
+}
 bool RecordPanel::confirmOverwrite(QString fileName)
+{
     // prepare message box
     QMessageBox mb(parentWidget());
     mb.setWindowTitle(tr("File Already Exists"));
     mb.setIcon(QMessageBox::Warning);
     mb.setText(tr("File (%1) already exists. How to continue?").arg(fileName));
     auto bCancel    = mb.addButton(QMessageBox::Cancel);
     auto bOverwrite = mb.addButton(tr("Overwrite"), QMessageBox::DestructiveRole);
     mb.addButton(tr("Select Another File"), QMessageBox::YesRole);
     mb.setEscapeButton(bCancel);
     // show message box
     mb.exec();
     if (mb.clickedButton() == bCancel)
+    {
         return false;
+    }
     else if (mb.clickedButton() == bOverwrite)
+    {
         selectedFile = fileName;
         return true;
+    }
     else                    // select button
+    {
         return selectFile();
+    }
+}
 void RecordPanel::startRecording(void)
+{
     QStringList channelNames;
     if (ui->cbHeader->isChecked())
+    {
         channelNames = _channelMan->infoModel()->channelNames();
+    }
     _recorder->startRecording(selectedFile, getSeparator(), channelNames);
     emit recordStarted();
+}
 void RecordPanel::stopRecording(void)
+{
     emit recordStopped();
     _recorder->stopRecording();
+}
 void RecordPanel::onPortClose()
+{
     if (recordAction.isChecked() && ui->cbStopOnClose->isChecked())
+    {
         stopRecording();
         recordAction.setChecked(false);
+    }
+}
 QString RecordPanel::getSeparator() const
+{
     QString sep = ui->leSeparator->text();
     sep.replace("\\t", "\t");
     return sep;
+}
 void RecordPanel::saveSettings(QSettings* settings)
+{
     settings->beginGroup(SettingGroup_Record);
     settings->setValue(SG_Record_AutoIncrement, ui->cbAutoIncrement->isChecked());
     settings->setValue(SG_Record_RecordPaused, ui->cbRecordPaused->isChecked());
     settings->setValue(SG_Record_StopOnClose, ui->cbStopOnClose->isChecked());
     settings->setValue(SG_Record_Header, ui->cbHeader->isChecked());
     settings->setValue(SG_Record_DisableBuffering, ui->cbDisableBuffering->isChecked());
     settings->setValue(SG_Record_Separator, ui->leSeparator->text());
     settings->endGroup();
+}
 void RecordPanel::loadSettings(QSettings* settings)
+{
     settings->beginGroup(SettingGroup_Record);
     ui->cbAutoIncrement->setChecked(
         settings->value(SG_Record_AutoIncrement, ui->cbAutoIncrement->isChecked()).toBool());
     ui->cbRecordPaused->setChecked(
         settings->value(SG_Record_RecordPaused, ui->cbRecordPaused->isChecked()).toBool());
     ui->cbStopOnClose->setChecked(
         settings->value(SG_Record_StopOnClose, ui->cbStopOnClose->isChecked()).toBool());
     ui->cbHeader->setChecked(
         settings->value(SG_Record_Header, ui->cbHeader->isChecked()).toBool());
     ui->cbDisableBuffering->setChecked(
         settings->value(SG_Record_DisableBuffering, ui->cbDisableBuffering->isChecked()).toBool());
     ui->leSeparator->setText(settings->value(SG_Record_Separator, ui->leSeparator->text()).toString());
     settings->endGroup();
+}

src/recordpanel.h

➞

Show inline comments

@@ new file 100644 @@
 /*
   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/>.
 */
 #ifndef RECORDPANEL_H
 #define RECORDPANEL_H
 #include <QWidget>
 #include <QString>
 #include <QToolBar>
 #include <QAction>
 #include "datarecorder.h"
 #include "channelmanager.h"
 namespace Ui {
 class RecordPanel;
+}
 class RecordPanel : public QWidget
+{
     Q_OBJECT
 public:
     explicit RecordPanel(DataRecorder* recorder, ChannelManager* channelMan,
                          QWidget* parent = 0);
     ~RecordPanel();
     QToolBar* toolbar();
     bool isRecording();
     bool recordPaused();
     /// Stores settings into a `QSettings`
     void saveSettings(QSettings* settings);
     /// Loads settings from a `QSettings`.
     void loadSettings(QSettings* settings);
 signals:
     void recordStarted();
     void recordStopped();
     void recordPausedChanged(bool enabled);
 public slots:
     /// Must be called when port is closed
     void onPortClose();
 private:
     Ui::RecordPanel *ui;
     QToolBar recordToolBar;
     QAction recordAction;
     QString selectedFile;
     bool overwriteSelected;
     DataRecorder* _recorder;
     ChannelManager* _channelMan;
     /**
      * @brief Increments the file name.
+     *
      * If file name doesn't have a number at the end of it, a number is appended
      * with underscore starting from 1.
+     *
      * @return false if user cancels
      */
     bool incrementFileName(void);
     /**
      * @brief Used to ask user confirmation if auto generated file
      * name exists.
+     *
      * If user confirms overwrite, `selectedFile` is set to
      * `fileName`. User is also given option to select file and is
      * shown a file select dialog in this case.
+     *
      * @param fileName auto generated file name.
      * @return false if user cancels
      */
     bool confirmOverwrite(QString fileName);
     void startRecording(void);
     void stopRecording(void);
     /// Returns separator text from ui. "\t" is converted to TAB
     /// character.
     QString getSeparator() const;
 private slots:
     /**
      * @brief Opens up the file select dialog
+     *
      * If you cancel the selection operation, currently selected file is not
      * changed.
+     *
      * @return true if file selected, false if user cancels
      */
     bool selectFile();
     void onRecord(bool start);
 };
 #endif // RECORDPANEL_H

src/recordpanel.ui

➞

Show inline comments

@@ new file 100644 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>RecordPanel</class>
  <widget class="QWidget" name="RecordPanel">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>627</width>
     <height>261</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>Form</string>
   </property>
   <layout class="QHBoxLayout" name="horizontalLayout_2">
    <item>
     <layout class="QVBoxLayout" name="verticalLayout">
      <item>
       <layout class="QHBoxLayout" name="horizontalLayout">
        <item>
         <widget class="QPushButton" name="pbBrowse">
          <property name="toolTip">
           <string>Select record file</string>
          </property>
          <property name="text">
           <string>Browse</string>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QLabel" name="lbFileName">
          <property name="sizePolicy">
           <sizepolicy hsizetype="MinimumExpanding" vsizetype="Preferred">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="text">
           <string>Select file...</string>
          </property>
         </widget>
        </item>
       </layout>
      </item>
      <item>
       <layout class="QGridLayout" name="gridLayout">
        <item row="1" column="1">
         <widget class="QCheckBox" name="cbHeader">
          <property name="toolTip">
           <string>Channel names are written to the first line of record file</string>
          </property>
          <property name="text">
           <string>Write header line</string>
          </property>
          <property name="checked">
           <bool>true</bool>
          </property>
         </widget>
        </item>
        <item row="2" column="0">
         <widget class="QCheckBox" name="cbRecordPaused">
          <property name="toolTip">
           <string>Continue recording to file even when plotting is paused</string>
          </property>
          <property name="text">
           <string>Record while paused</string>
          </property>
          <property name="checked">
           <bool>true</bool>
          </property>
         </widget>
        </item>
        <item row="3" column="0">
         <widget class="QCheckBox" name="cbDisableBuffering">
          <property name="toolTip">
           <string>Do not buffer when writing to file. Check this if you are using other software to open the file during recording.</string>
          </property>
          <property name="text">
           <string>Disable buffering</string>
          </property>
         </widget>
        </item>
        <item row="2" column="1">
         <widget class="QCheckBox" name="cbStopOnClose">
          <property name="text">
           <string>Stop recording when port closed</string>
          </property>
          <property name="checked">
           <bool>true</bool>
          </property>
         </widget>
        </item>
        <item row="1" column="0">
         <widget class="QCheckBox" name="cbAutoIncrement">
          <property name="toolTip">
           <string>Increments file name automatically everytime a new recording starts</string>
          </property>
          <property name="text">
           <string>Auto increment file name</string>
          </property>
          <property name="checked">
           <bool>true</bool>
          </property>
         </widget>
        </item>
        <item row="3" column="1">
         <widget class="QCheckBox" name="cbWindowsLE">
          <property name="toolTip">
           <string>Use CR+LF as line endings. Some windows software may not show lines correctly otherwise. Can't be changed during recording.</string>
          </property>
          <property name="text">
           <string>Windows Style Line Endings</string>
          </property>
          <property name="checked">
           <bool>false</bool>
          </property>
         </widget>
        </item>
        <item row="1" column="2">
         <spacer name="horizontalSpacer_2">
          <property name="orientation">
           <enum>Qt::Horizontal</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>1</width>
            <height>20</height>
           </size>
          </property>
         </spacer>
        </item>
       </layout>
      </item>
      <item>
       <layout class="QHBoxLayout" name="horizontalLayout_3">
        <item>
         <widget class="QLabel" name="label">
          <property name="text">
           <string>Column Separator:</string>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QLineEdit" name="leSeparator">
          <property name="maximumSize">
           <size>
            <width>30</width>
            <height>16777215</height>
           </size>
          </property>
          <property name="toolTip">
           <string>For TAB character enter \t</string>
          </property>
          <property name="text">
           <string>,</string>
          </property>
         </widget>
        </item>
        <item>
         <spacer name="horizontalSpacer">
          <property name="orientation">
           <enum>Qt::Horizontal</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>40</width>
            <height>20</height>
           </size>
          </property>
         </spacer>
        </item>
       </layout>
      </item>
      <item>
       <spacer name="verticalSpacer">
        <property name="orientation">
         <enum>Qt::Vertical</enum>
        </property>
        <property name="sizeHint" stdset="0">
         <size>
          <width>20</width>
          <height>1</height>
         </size>
        </property>
       </spacer>
      </item>
     </layout>
    </item>
    <item>
     <layout class="QVBoxLayout" name="verticalLayout_2">
      <item>
       <widget class="QToolButton" name="pbRecord">
        <property name="minimumSize">
         <size>
          <width>85</width>
          <height>50</height>
         </size>
        </property>
        <property name="toolTip">
         <string>Start/Stop Recording</string>
        </property>
        <property name="text">
         <string>Record</string>
        </property>
       </widget>
      </item>
      <item>
       <spacer name="verticalSpacer_2">
        <property name="orientation">
         <enum>Qt::Vertical</enum>
        </property>
        <property name="sizeHint" stdset="0">
         <size>
          <width>20</width>
          <height>1</height>
         </size>
        </property>
       </spacer>
      </item>
     </layout>
    </item>
   </layout>
  </widget>
  <resources/>
  <connections/>
 </ui>

src/scalepicker.cpp

➞

Show inline comments

 /*
-  Copyright © 2015 Hasan Yavuz Özderya
+  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 <QEvent>
 #include <QMouseEvent>
 #include <QPainter>
 #include <qwt_scale_widget.h>
 #include <qwt_scale_map.h>
 #include <qwt_scale_div.h>
 #include <qwt_text.h>
 #include <math.h>
 #include "scalepicker.h"
 // minimum size for pick (in pixels)
 #define MIN_PICK_SIZE (2)
 #define SNAP_DISTANCE (5)
 class PlotOverlay : public QwtWidgetOverlay
+{
 public:
     PlotOverlay(QWidget* widget, ScalePicker* picker);
 protected:
     virtual void drawOverlay(QPainter*) const;
 private:
     ScalePicker* _picker;
 };
 PlotOverlay::PlotOverlay(QWidget* widget, ScalePicker* picker) :
     QwtWidgetOverlay(widget)
+{
@@ @@ -86,193 +87,365 @@ ScalePicker::ScalePicker(QwtScaleWidget* @@
     scaleWidget->installEventFilter(this);
     scaleWidget->setMouseTracking(true);
     pickerOverlay = new PlotOverlay(canvas, this);
     scaleOverlay = new ScaleOverlay(scaleWidget, this);
     started = false;
     pressed = false;
+}
 bool ScalePicker::eventFilter(QObject* object, QEvent* event)
+{
     if (event->type() == QEvent::MouseButtonPress ||
         event->type() == QEvent::MouseButtonRelease ||
         event->type() == QEvent::MouseMove)
+    {
         updateSnapPoints();
         QMouseEvent* mouseEvent = (QMouseEvent*) event;
         int posPx = this->positionPx(mouseEvent);
         // do snapping unless Shift is pressed
         if (! (mouseEvent->modifiers() & Qt::ShiftModifier))
+        {
             for (auto sp : snapPoints)
+            {
-                if (fabs(posPx-sp) <= SNAP_DISTANCE)
+                if (std::abs(posPx-sp) <= SNAP_DISTANCE)
+                {
                     posPx = sp;
                     break;
+                }
+            }
+        }
         double pos = this->position(posPx);
         currentPosPx = posPx;
         if (event->type() == QEvent::MouseButtonPress &&
             mouseEvent->button() == Qt::LeftButton)
+        {
             pressed = true; // not yet started
             firstPos = pos;
             firstPosPx = posPx;
+        }
         else if (event->type() == QEvent::MouseMove)
+        {
             // make sure pick size is big enough, so that just
             // clicking won't trigger pick
             if (!started && pressed && (fabs(posPx-firstPosPx) > MIN_PICK_SIZE))
+            {
                 started = true;
                 emit pickStarted(pos);
+            }
             else if (started)
+            {
                 pickerOverlay->updateOverlay();
                 emit picking(firstPos, pos);
+            }
             pickerOverlay->updateOverlay();
             scaleOverlay->updateOverlay();
+        }
         else // event->type() == QEvent::MouseButtonRelease
+        {
             pressed = false;
             if (started)
+            {
                 // finalize
                 started = false;
                 emit picked(firstPos, pos);
                 if (firstPos != pos) // ignore 0 width zoom
+                {
                     emit picked(firstPos, pos);
+                }
+            }
             pickerOverlay->updateOverlay();
             scaleOverlay->updateOverlay();
+        }
         return true;
+    }
     else if (event->type() == QEvent::Leave)
+    {
         scaleOverlay->updateOverlay();
         pickerOverlay->updateOverlay();
         return true;
+    }
     else
+    {
         return QObject::eventFilter(object, event);
+    }
+}
 const int TEXT_MARGIN = 4;
 void ScalePicker::drawPlotOverlay(QPainter* painter)
+{
     const double FILL_ALPHA = 0.2;
     painter->save();
     painter->setPen(_pen);
     if (started)
+    {
         painter->save();
         painter->setPen(_pen);
         QColor color = _pen.color();
         color.setAlphaF(FILL_ALPHA);
         painter->setBrush(color);
         QRect rect;
         QwtText text = trackerText();
         auto tSize = text.textSize(painter->font());
         if (_scaleWidget->alignment() == QwtScaleDraw::BottomScale ||
             _scaleWidget->alignment() == QwtScaleDraw::TopScale)
+        {
             int height = painter->device()->height();
             rect = QRect(posCanvasPx(firstPosPx), 0, currentPosPx-firstPosPx, height);
             int canvasHeight = painter->device()->height();
             int pickWidth = currentPosPx-firstPosPx;
             rect = QRect(posCanvasPx(firstPosPx), 0, pickWidth, canvasHeight);
+        }
         else // vertical
+        {
             int width = painter->device()->width();
             rect = QRect(0, posCanvasPx(firstPosPx), width, currentPosPx-firstPosPx);
             int canvasWidth = painter->device()->width();
             int pickHeight = currentPosPx-firstPosPx;
             rect = QRect(0, posCanvasPx(firstPosPx), canvasWidth, pickHeight);
+        }
         painter->drawRect(rect);
         painter->restore();
         text.draw(painter, pickTrackerTextRect(painter, rect, tSize));
+    }
     else if (_scaleWidget->underMouse())
+    {
         // draw tracker text centered on cursor
         QwtText text = trackerText();
         auto tsize = text.textSize(painter->font());
         text.draw(painter, trackerTextRect(painter, currentPosPx, tsize));
+    }
     painter->restore();
+}
 QwtText ScalePicker::trackerText() const
+{
     double pos;
     // use stored value if snapped to restore precision
     if (snapPointMap.contains(currentPosPx))
+    {
         pos = snapPointMap[currentPosPx];
+    }
     else
+    {
         pos = position(currentPosPx);
+    }
     return QwtText(QString("%1").arg(pos));
+}
 QRectF ScalePicker::trackerTextRect(QPainter* painter, int posPx, QSizeF textSize) const
+{
     int canvasPosPx = posCanvasPx(posPx);
     QPointF topLeft;
     if (_scaleWidget->alignment() == QwtScaleDraw::BottomScale ||
         _scaleWidget->alignment() == QwtScaleDraw::TopScale)
+    {
         int left = canvasPosPx - textSize.width() / 2;
         int canvasWidth = painter->device()->width();
         left = std::max(TEXT_MARGIN, left);
         left = std::min(double(left), canvasWidth - textSize.width() - TEXT_MARGIN);
         int top = 0;
         if (_scaleWidget->alignment() == QwtScaleDraw::BottomScale)
+        {
             top = painter->device()->height() - textSize.height();
+        }
         topLeft = QPointF(left, top);
+    }
     else                        // left/right scales
+    {
         int top = canvasPosPx-textSize.height() / 2;
         int canvasHeight = painter->device()->height();
         top = std::max(0, top);
         top = std::min(double(top), canvasHeight - textSize.height());
         int left = TEXT_MARGIN;
         if (_scaleWidget->alignment() == QwtScaleDraw::RightScale)
+        {
             left = painter->device()->width() - textSize.width();
+        }
         topLeft = QPointF(left, top);
+    }
     return QRectF(topLeft, textSize);
+}
 QRectF ScalePicker::pickTrackerTextRect(QPainter* painter, QRect pickRect, QSizeF textSize) const
+{
     qreal left = 0;
     int pickLength = currentPosPx - firstPosPx;
     QPointF topLeft;
     if (_scaleWidget->alignment() == QwtScaleDraw::BottomScale ||
         _scaleWidget->alignment() == QwtScaleDraw::TopScale)
+    {
         int canvasWidth = painter->device()->width();
         if (pickLength > 0)
+        {
             left = pickRect.right() + TEXT_MARGIN;
+        }
         else
+        {
             left = pickRect.right() - (textSize.width() + TEXT_MARGIN);
+        }
         // make sure text is not off the canvas
         if (left < TEXT_MARGIN)
+        {
             left = std::max(0, pickRect.right()) + TEXT_MARGIN;
+        }
         else if (left + textSize.width() + TEXT_MARGIN > canvasWidth)
+        {
             left = std::min(pickRect.right(), canvasWidth) - (textSize.width() + TEXT_MARGIN);
+        }
         if (_scaleWidget->alignment() == QwtScaleDraw::BottomScale)
+        {
             int canvasHeight = painter->device()->height();
             topLeft = QPointF(left, canvasHeight - textSize.height());
+        }
         else                // top scale
+        {
             topLeft = QPointF(left, 0);
+        }
+    }
     else                        // left/right scale
+    {
         int canvasHeight = painter->device()->height();
         int top = 0;
         if (pickLength > 0)
+        {
             top = pickRect.bottom();
+        }
         else
+        {
             top = pickRect.bottom() - textSize.height();
+        }
         // make sure text is not off the canvas
         if (top < 0)
+        {
             top = std::max(0, pickRect.bottom());
+        }
         else if (top + textSize.height() > canvasHeight)
+        {
             top = std::min(canvasHeight, pickRect.bottom()) - textSize.height();
+        }
         if (_scaleWidget->alignment() == QwtScaleDraw::LeftScale)
+        {
             topLeft = QPointF(TEXT_MARGIN, top);
+        }
         else                    // right scale
+        {
             int canvasWidth = painter->device()->width();
             topLeft = QPointF(canvasWidth - textSize.width() - TEXT_MARGIN, top);
+        }
+    }
     return QRectF(topLeft, textSize);
+}
 void ScalePicker::drawScaleOverlay(QPainter* painter)
+{
     painter->save();
     painter->setPen(_pen);
     if (_scaleWidget->alignment() == QwtScaleDraw::BottomScale ||
         _scaleWidget->alignment() == QwtScaleDraw::TopScale)
+    {
         int height = painter->device()->height();
         if (started) painter->drawLine(firstPosPx, 0, firstPosPx, height);
         if (started || _scaleWidget->underMouse())
+        {
             painter->drawLine(currentPosPx, 0, currentPosPx, height);
+        }
+    }
     else // vertical
     // rotate & adjust coordinate system for vertical drawing
     if (_scaleWidget->alignment() == QwtScaleDraw::LeftScale ||
         _scaleWidget->alignment() == QwtScaleDraw::RightScale) // vertical
+    {
         int width = painter->device()->width();
         if (started) painter->drawLine(0, firstPosPx, width, firstPosPx);
         if (started || _scaleWidget->underMouse())
         painter->rotate(90);
         painter->translate(0, -width);
+    }
     // draw the indicators
     if (started) drawTriangle(painter, firstPosPx);
     if (started || _scaleWidget->underMouse())
+    {
         drawTriangle(painter, currentPosPx);
+    }
     painter->restore();
+}
 void ScalePicker::drawTriangle(QPainter* painter, int position)
+{
     const double tan60 = 1.732;
     const double trsize = 10;
     const int TRIANGLE_NUM_POINTS = 3;
     const int MARGIN = 2;
     const QPointF points[TRIANGLE_NUM_POINTS] =
+        {
             painter->drawLine(0, currentPosPx, width, currentPosPx);
+        }
+    }
             {0, 0},
             {-trsize/tan60 , trsize},
             {trsize/tan60 , trsize}
         };
     painter->save();
     painter->setPen(Qt::NoPen);
     painter->setBrush(_scaleWidget->palette().windowText());
     painter->setRenderHint(QPainter::Antialiasing);
     painter->translate(position, MARGIN);
     painter->drawPolygon(points, TRIANGLE_NUM_POINTS);
     painter->restore();
+}
 void ScalePicker::setPen(QPen pen)
+{
     _pen = pen;
+}
 // convert the position of the click to the plot coordinates
 double ScalePicker::position(double posPx)
+double ScalePicker::position(double posPx) const
+{
     return _scaleWidget->scaleDraw()->scaleMap().invTransform(posPx);
+}
 int ScalePicker::positionPx(QMouseEvent* mouseEvent)
+{
     double pos;
     if (_scaleWidget->alignment() == QwtScaleDraw::BottomScale ||
         _scaleWidget->alignment() == QwtScaleDraw::TopScale)
+    {
         pos = mouseEvent->pos().x();
+    }
     else // left or right scale
+    {
         pos = mouseEvent->pos().y();
+    }
     return pos;
+}
 /*
  * Scale widget and canvas widget is not always aligned. Especially
  * when zooming scaleWidget moves around. This causes irregularities
  * when drawing the tracker lines. This function maps scale widgets
  * pixel coordinate to canvas' coordinate.
  */
 double ScalePicker::posCanvasPx(double pos)
+double ScalePicker::posCanvasPx(double pos) const
+{
     // assumption: scale.width < canvas.width && scale.x > canvas.x
     if (_scaleWidget->alignment() == QwtScaleDraw::BottomScale ||
         _scaleWidget->alignment() == QwtScaleDraw::TopScale)
+    {
         return pos + (_scaleWidget->x() - _canvas->x());
+    }
     else // left or right scale
+    {
         return pos + (_scaleWidget->y() - _canvas->y());
+    }
     return pos;
+}
 void ScalePicker::updateSnapPoints()
+{
     auto allTicks = _scaleWidget->scaleDraw()->scaleDiv().ticks(QwtScaleDiv::MajorTick) +
         _scaleWidget->scaleDraw()->scaleDiv().ticks(QwtScaleDiv::MediumTick) +
         _scaleWidget->scaleDraw()->scaleDiv().ticks(QwtScaleDiv::MinorTick);
     snapPoints.clear();
     snapPointMap.clear();
     for(auto t : allTicks)
+    {
         // `round` is used because `allTicks` is double but `snapPoints` is int
         snapPoints << round(_scaleWidget->scaleDraw()->scaleMap().transform(t));
         int p = round(_scaleWidget->scaleDraw()->scaleMap().transform(t));
         snapPoints << p;
         snapPointMap[p] = t;
+    }
+}

src/scalepicker.h

➞

Show inline comments

 /*
-  Copyright © 2015 Hasan Yavuz Özderya
+  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/>.
 */
 #ifndef SCALEPICKER_H
 #define SCALEPICKER_H
 #include <QObject>
 #include <QMouseEvent>
 #include <QPen>
 #include <QWidget>
 #include <QList>
 #include <QMap>
 #include <qwt_scale_widget.h>
 #include <qwt_widget_overlay.h>
 class ScalePicker : public QObject
+{
     Q_OBJECT
 public:
     ScalePicker(QwtScaleWidget* scaleWidget, QWidget* canvas);
     virtual bool eventFilter(QObject*, QEvent*);
     void drawPlotOverlay(QPainter*); // called from ScalePickerOverlay
     void drawScaleOverlay(QPainter*); // called from ScaleOverlay
     void setPen(QPen pen);
 signals:
     void pickStarted(double pos);
     void picking(double firstPos, double lastPos);
     void picked(double firstPos, double lastPos);
 private:
     QwtScaleWidget* _scaleWidget;
     QWidget* _canvas;
     QwtWidgetOverlay* pickerOverlay; // will be PlotOverlay
     QwtWidgetOverlay* scaleOverlay;  // will be ScaleOverlay
     QPen _pen;
     bool pressed;
     bool started;
     double firstPos; // converted to plot coordinates
     double firstPosPx; // pixel coordinates
     double currentPosPx; // current position in pixel coordinates
     QList<int> snapPoints;
     /// used to restore precision of snappoints that is lost due to rounding
     QMap<int, double> snapPointMap;
     double position(double); // returns the axis mouse position relative to plot coordinates
+    double position(double) const; // returns the axis mouse position relative to plot coordinates
     int positionPx(QMouseEvent*); // returns the axis mouse position in pixels
     double posCanvasPx(double pos); // returns the given position in canvas coordinates
     double posCanvasPx(double pos) const; // returns the given position in canvas coordinates
     void drawTriangle(QPainter* painter, int position);
     QwtText trackerText() const;
      /// Returns tracker text position
     QRectF trackerTextRect(QPainter* painter, int posPx, QSizeF textSize) const;
     /// Returns the text position for tracker text shown during picking
     QRectF pickTrackerTextRect(QPainter* painter, QRect pickRect, QSizeF textSize) const;
 private slots:
     void updateSnapPoints();
 };
 #endif // SCALEPICKER_H

src/setting_defines.h

➞

Show inline comments

 /*
-  Copyright © 2016 Hasan Yavuz Özderya
+  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/>.
 */
 #ifndef SETTING_DEFINES_H
 #define SETTING_DEFINES_H
 const char SettingGroup_MainWindow[] = "MainWindow";
 const char SettingGroup_Port[] = "Port";
 const char SettingGroup_DataFormat[] = "DataFormat";
 const char SettingGroup_Binary[] = "DataFormat_Binary";
 const char SettingGroup_ASCII[] = "DataFormat_ASCII";
 const char SettingGroup_CustomFrame[] = "DataFormat_CustomFrame";
 const char SettingGroup_Channels[] = "Channels";
 const char SettingGroup_Plot[] = "Plot";
 const char SettingGroup_Commands[] = "Commands";
 const char SettingGroup_Record[] = "Record";
 // 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";
 const char SG_MainWindow_State[] = "state";
 // 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";
 const char SG_Channels_Color[] = "color";
 const char SG_Channels_Visible[] = "visible";
 // plot settings keys
 const char SG_Plot_NumOfSamples[] = "numOfSamples";
 const char SG_Plot_IndexAsX[] = "indexAsX";
 const char SG_Plot_XMax[] = "xMax";
 const char SG_Plot_XMin[] = "xMin";
 const char SG_Plot_AutoScale[] = "autoScale";
 const char SG_Plot_YMax[] = "yMax";
 const char SG_Plot_YMin[] = "yMin";
 const char SG_Plot_DarkBackground[] = "darkBackground";
 const char SG_Plot_Grid[] = "grid";
 const char SG_Plot_MinorGrid[] = "minorGrid";
 const char SG_Plot_Legend[] = "legend";
 const char SG_Plot_MultiPlot[] = "multiPlot";
 // command setting keys
 const char SG_Commands_Command[] = "command";
 const char SG_Commands_Name[] = "name";
 const char SG_Commands_Type[] = "type";
 const char SG_Commands_Data[] = "data";
 // record panel settings keys
 const char SG_Record_AutoIncrement[]    = "autoIncrement";
 const char SG_Record_RecordPaused[]     = "recordPaused";
 const char SG_Record_StopOnClose[]      = "stopOnClose";
 const char SG_Record_Header[]           = "header";
 const char SG_Record_Separator[]        = "separator";
 const char SG_Record_DisableBuffering[] = "disableBuffering";
 #endif // SETTING_DEFINES_H

src/snapshot.cpp

➞

Show inline comments

@@ @@ -3,50 +3,51 @@ @@
   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"
 Snapshot::Snapshot(QMainWindow* parent, QString name) :
+Snapshot::Snapshot(QMainWindow* parent, QString name, ChannelInfoModel infoModel) :
     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);
     _deleteAction.setToolTip(QString("Delete ") + _name);
     connect(&_deleteAction, &QAction::triggered, this, &Snapshot::onDeleteTriggered);
+}
 Snapshot::~Snapshot()
+{
     if (view != NULL)
+    {
         delete view;
+    }
+}
 QAction* Snapshot::showAction()
@@ @@ -85,56 +86,56 @@ void Snapshot::onDeleteTriggered() @@
 QString Snapshot::name()
+{
     return _name;
+}
 QString Snapshot::displayName()
+{
     if (_saved)
+    {
         return name();
+    }
     else
+    {
         return name() + "*";
+    }
+}
 void Snapshot::setName(QString name)
+{
     _name = name;
     _showAction.setText(_name);
     emit nameChanged(this);
+}
-void Snapshot::setChannelNames(QStringList names)
+ChannelInfoModel* Snapshot::infoModel()
+{
-    _channelNames = names;
+    return &cInfoModel;
+}
 QString Snapshot::channelName(unsigned channel)
+{
-    return _channelNames[channel];
+    return cInfoModel.name(channel);
+}
 void Snapshot::save(QString fileName)
+{
     // TODO: remove code duplication (MainWindow::onExportCsv)
     QSaveFile file(fileName);
     if (file.open(QIODevice::WriteOnly | QIODevice::Text))
+    {
         QTextStream fileStream(&file);
         unsigned numOfChannels = data.size();
         unsigned numOfSamples = data[0].size();
         // print header
         for (unsigned int ci = 0; ci < numOfChannels; ci++)
+        {
             fileStream << channelName(ci);
             if (ci != numOfChannels-1) fileStream << ",";
+        }
         fileStream << '\n';
         // print rows
         for (unsigned int i = 0; i < numOfSamples; i++)

src/snapshot.h

➞

Show inline comments

@@ @@ -6,68 +6,70 @@ @@
   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 <QMainWindow>
 #include <QAction>
 #include <QVector>
 #include <QString>
 #include <QStringList>
 #include "channelinfomodel.h"
 class SnapshotView;
 class Snapshot : public QObject
+{
     Q_OBJECT
 public:
     Snapshot(QMainWindow* parent, QString name);
+    Snapshot(QMainWindow* parent, QString name, ChannelInfoModel infoModel);
     ~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);
     void setChannelNames(QStringList names); // must be called when setting data!
     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;
-    QStringList _channelNames;
+    ChannelInfoModel cInfoModel;
     QAction _showAction;
     QAction _deleteAction;
     QMainWindow* mainWindow;
     SnapshotView* view;
     bool _saved;
 private slots:
     void show();
     void viewClosed();
     void onDeleteTriggered();
 };
 #endif /* SNAPSHOT_H */

src/snapshotmanager.cpp

➞

Show inline comments

 /*
-  Copyright © 2015 Hasan Yavuz Özderya
+  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 <QTime>
 #include <QMenuBar>
 #include <QKeySequence>
 #include <QFileDialog>
 #include <QFile>
 #include <QVector>
 #include <QPointF>
 #include <QIcon>
 #include <QtDebug>
 #include "snapshotmanager.h"
 SnapshotManager::SnapshotManager(QMainWindow* mainWindow,
                                  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"));
     loadSnapshotAction.setToolTip("Load snapshots from CSV files");
     clearAction.setToolTip("Delete all snapshots");
     connect(&_takeSnapshotAction, SIGNAL(triggered(bool)),
             this, SLOT(takeSnapshot()));
     connect(&clearAction, SIGNAL(triggered(bool)),
             this, SLOT(clearSnapshots()));
     connect(&loadSnapshotAction, SIGNAL(triggered(bool)),
             this, SLOT(loadSnapshots()));
     updateMenu();
+}
 SnapshotManager::~SnapshotManager()
+{
     for (auto snapshot : snapshots)
+    {
         delete snapshot;
+    }
+}
 Snapshot* SnapshotManager::makeSnapshot()
+{
     QString name = QTime::currentTime().toString("'Snapshot ['HH:mm:ss']'");
     auto snapshot = new Snapshot(_mainWindow, name);
+    auto snapshot = new Snapshot(_mainWindow, name, *(_channelMan->infoModel()));
     unsigned numOfChannels = _channelMan->numOfChannels();
     unsigned numOfSamples = _channelMan->numOfSamples();
     for (unsigned ci = 0; ci < numOfChannels; ci++)
+    {
         snapshot->data.append(QVector<QPointF>(numOfSamples));
         for (unsigned i = 0; i < numOfSamples; i++)
+        {
             snapshot->data[ci][i] = QPointF(i, _channelMan->channelBuffer(ci)->sample(i));
+        }
+    }
     snapshot->setChannelNames(_channelMan->channelNames()->stringList());
     return snapshot;
+}
 void SnapshotManager::takeSnapshot()
+{
     addSnapshot(makeSnapshot());
+}
 void SnapshotManager::addSnapshot(Snapshot* snapshot, bool update_menu)
+{
     snapshots.append(snapshot);
     QObject::connect(snapshot, &Snapshot::deleteRequested,
                      this, &SnapshotManager::deleteSnapshot);
     if (update_menu) updateMenu();
+}
 void SnapshotManager::updateMenu()
+{
     _menu.clear();
     _menu.addAction(&_takeSnapshotAction);
     _menu.addAction(&loadSnapshotAction);
     if (snapshots.size())
+    {
@@ @@ -168,49 +169,51 @@ void SnapshotManager::loadSnapshotFromFi @@
+        {
             qCritical() << "Parsing error at line " << lineNum
                         << ": number of columns is not consistent.";
             return;
+        }
         for (unsigned ci = 0; ci < numOfChannels; ci++)
+        {
             // parse column
             bool ok;
             double y = split[ci].toDouble(&ok);
             if (!ok)
+            {
                 qCritical() << "Parsing error at line " << lineNum
                             << ", column " << ci
                             << ": can't convert \"" << split[ci]
                             << "\" to double.";
                 return;
+            }
             data[ci].append(QPointF(lineNum-1, y));
+        }
         lineNum++;
+    }
     auto snapshot = new Snapshot(_mainWindow, QFileInfo(fileName).baseName());
     ChannelInfoModel channelInfo(channelNames);
     auto snapshot = new Snapshot(
         _mainWindow, QFileInfo(fileName).baseName(), ChannelInfoModel(channelNames));
     snapshot->data = data;
     snapshot->setChannelNames(channelNames);
     addSnapshot(snapshot, false);
+}
 QMenu* SnapshotManager::menu()
+{
     return &_menu;
+}
 QAction* SnapshotManager::takeSnapshotAction()
+{
     return &_takeSnapshotAction;
+}
 bool SnapshotManager::isAllSaved()
+{
     for (auto snapshot : snapshots)
+    {
         if (!snapshot->isSaved()) return false;
+    }
     return true;
+}

src/snapshotview.cpp

➞

Show inline comments

@@ @@ -8,66 +8,66 @@ @@
   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 "snapshotview.h"
 #include "ui_snapshotview.h"
 SnapshotView::SnapshotView(QWidget *parent, Snapshot* snapshot) :
     QMainWindow(parent),
     ui(new Ui::SnapshotView),
     renameDialog(this)
+{
     _snapshot = snapshot;
     ui->setupUi(this);
     plotMan = new PlotManager(ui->plotArea);
+    plotMan = new PlotManager(ui->plotArea, snapshot->infoModel());
     ui->menuSnapshot->insertAction(ui->actionClose, snapshot->deleteAction());
     this->setWindowTitle(snapshot->displayName());
     // initialize curves
     unsigned numOfChannels = snapshot->data.size();
     for (unsigned ci = 0; ci < numOfChannels; ci++)
+    {
         plotMan->addCurve(snapshot->channelName(ci), snapshot->data[ci]);
+    }
     renameDialog.setWindowTitle("Rename Snapshot");
     renameDialog.setLabelText("Enter new name:");
     connect(ui->actionRename, &QAction::triggered,
             this, &SnapshotView::showRenameDialog);
-    connect(ui->actionExport, &QAction::triggered,
+    connect(ui->actionSave, &QAction::triggered,
             this, &SnapshotView::save);
     // add 'View' menu items
     for (auto a : plotMan->menuActions())
+    {
         ui->menuView->addAction(a);
+    }
+}
 SnapshotView::~SnapshotView()
+{
     for (auto curve : curves)
+    {
         delete curve;
+    }
     delete ui;
+}
 void SnapshotView::closeEvent(QCloseEvent *event)
+{
     QMainWindow::closeEvent(event);
     emit closed();
+}

src/snapshotview.ui

➞

Show inline comments

@@ @@ -5,70 +5,70 @@ @@
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>544</width>
     <height>449</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>MainWindow</string>
   </property>
   <widget class="QWidget" name="centralwidget">
    <layout class="QVBoxLayout" name="verticalLayout">
     <item>
      <widget class="QWidget" name="plotArea" native="true"/>
     </item>
    </layout>
   </widget>
   <widget class="QMenuBar" name="menubar">
    <property name="geometry">
     <rect>
      <x>0</x>
      <y>0</y>
      <width>544</width>
-     <height>20</height>
+     <height>25</height>
     </rect>
    </property>
    <widget class="QMenu" name="menuSnapshot">
     <property name="title">
      <string>&amp;Snapshot</string>
     </property>
     <addaction name="actionRename"/>
-    <addaction name="actionExport"/>
+    <addaction name="actionSave"/>
     <addaction name="actionClose"/>
    </widget>
    <widget class="QMenu" name="menuView">
     <property name="title">
      <string>&amp;View</string>
     </property>
    </widget>
    <addaction name="menuSnapshot"/>
    <addaction name="menuView"/>
   </widget>
-  <action name="actionExport">
+  <action name="actionSave">
    <property name="text">
-    <string>&amp;Export CSV</string>
+    <string>&amp;Save as CSV</string>
    </property>
    <property name="toolTip">
     <string>Save snapshot as CSV file</string>
    </property>
   </action>
   <action name="actionRename">
    <property name="text">
     <string>&amp;Rename</string>
    </property>
    <property name="toolTip">
     <string>Rename this snapshot</string>
    </property>
   </action>
   <action name="actionClose">
    <property name="text">
     <string>&amp;Close</string>
    </property>
    <property name="toolTip">
     <string>Close Window</string>
    </property>
    <property name="shortcut">
     <string>Ctrl+W</string>
    </property>
   </action>

src/version.h

➞

Show inline comments

@@ new file 100644 @@
 /*
   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/>.
 */
 #ifndef VERSION_H
 #define VERSION_H
 #ifndef VERSION_STRING
 #define VERSION_STRING   "0.9.0"
 #endif
 #ifndef VERSION_REVISION
 #define VERSION_REVISION ""
 #endif
 #endif // VERSION_H

src/version.h.in

➞

Show inline comments

 /*
-  Copyright © 2015 Hasan Yavuz Özderya
+  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/>.
 */
 #ifndef VERSION_H
 #define VERSION_H
 #define MAJOR_VERSION    @MAJOR_VERSION@
 #define MINOR_VERSION    @MINOR_VERSION@
 #define PATCH_VERSION    @PATCH_VERSION@
 #define VERSION_STRING   "@VERSION_STRING@"
 #define VERSION_REVISION "@VERSION_REVISION@"
 #endif // VERSION_H

src/zoomer.cpp

➞

Show inline comments

 /*
-  Copyright © 2016 Hasan Yavuz Özderya
+  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 "zoomer.h"
 #include <qwt_plot.h>
 #include <QtDebug>
 #include <QMouseEvent>
 Zoomer::Zoomer(QWidget* widget, bool doReplot) :
     ScrollZoomer(widget)
+{
     is_panning = false;
     // set corner widget between the scrollbars with default background color
     auto cornerWidget = new QWidget();
     auto bgColor = cornerWidget->palette().color(QPalette::Window).name();
     auto styleSheet = QString("background-color:%1;").arg(bgColor);
     cornerWidget->setStyleSheet(styleSheet);
     ScrollZoomer::setCornerWidget(cornerWidget);
+}
 void Zoomer::zoom(int up)
+{
     ScrollZoomer::zoom(up);
     if(zoomRectIndex() == 0)
+    {
         emit unzoomed();
+    }
+}
 void Zoomer::zoom( const QRectF & rect)
+{
     // set the zoom base when user zooms in to first level
     if (zoomRectIndex() == 0)
+    {
         this->setZoomBase(false);
+    }
     ScrollZoomer::zoom(rect);
+}
 QwtText Zoomer::trackerTextF(const QPointF& pos) const
+{
     QwtText b = ScrollZoomer::trackerTextF(pos);
     const QPolygon pa = selection();
     if (pa.count() < 2)
+    {
         return b;
+    }
     const QRectF rect = invTransform(QRect(pa.first(), pa.last()).normalized());
     QString sizeText = QString(" [%1, %2]").\
         arg(rect.width(), 0, 'g', 4).\
         arg(rect.height(), 0, 'g', 4);
     b.setText(b.text() + sizeText);
     return b;
+}
 void Zoomer::drawRubberBand(QPainter* painter) const
+{
     const double FILL_ALPHA = 0.2;
     QColor color = painter->pen().color();
     color.setAlphaF(FILL_ALPHA);
     painter->setBrush(color);
     ScrollZoomer::drawRubberBand(painter);
+}
 QRegion Zoomer::rubberBandMask() const
+{
     const QPolygon pa = selection();
     if (pa.count() < 2)
+    {
         return QRegion();
+    }
     const QRect r = QRect(pa.first(), pa.last()).normalized().adjusted(0, 0, 1, 1);
     return QRegion(r);
+}
 void Zoomer::widgetMousePressEvent(QMouseEvent* mouseEvent)
+{
     if (mouseEvent->modifiers() & Qt::ControlModifier)
+    {
         is_panning = true;
         parentWidget()->setCursor(Qt::ClosedHandCursor);
         pan_point = invTransform(mouseEvent->pos());
+    }
     else
+    {
         ScrollZoomer::widgetMousePressEvent(mouseEvent);
+    }
+}
 void Zoomer::widgetMouseMoveEvent(QMouseEvent* mouseEvent)
+{
     if (is_panning)
+    {
         auto cur_point = invTransform(mouseEvent->pos());
         auto delta = cur_point - pan_point;
         moveBy(-delta.x(), -delta.y());
         pan_point = invTransform(mouseEvent->pos());
+    }
     else
+    {
         ScrollZoomer::widgetMouseMoveEvent(mouseEvent);
+    }
+}
 void Zoomer::widgetMouseReleaseEvent(QMouseEvent* mouseEvent)
+{
     if (is_panning)
+    {
         is_panning = false;
         parentWidget()->setCursor(Qt::CrossCursor);
+    }
     else
+    {
         ScrollZoomer::widgetMouseReleaseEvent(mouseEvent);
+    }
+}

src/zoomer.h

➞

Show inline comments

 /*
-  Copyright © 2016 Hasan Yavuz Özderya
+  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/>.
 */
 #ifndef ZOOMER_H
 #define ZOOMER_H
 #include <scrollzoomer.h>
 class Zoomer : public ScrollZoomer
+{
     Q_OBJECT
 public:
     Zoomer(QWidget *, bool doReplot=true);
     void zoom(int up);
     void zoom( const QRectF & );
 signals:
     void unzoomed();
 protected:
     /// Re-implemented to display selection size in the tracker text.
     QwtText trackerTextF(const QPointF &pos) const;
     /// Re-implemented for alpha background
     void drawRubberBand(QPainter* painter) const;
     /// Re-implemented for alpha background (masking is basically disabled)
     QRegion rubberBandMask() const;
     /// Overloaded for panning
     void widgetMousePressEvent(QMouseEvent* mouseEvent);
     /// Overloaded for panning
     void widgetMouseReleaseEvent(QMouseEvent* mouseEvent);
     /// Overloaded for panning
     void widgetMouseMoveEvent(QMouseEvent* mouseEvent);
 private:
     bool is_panning;
     QPointF pan_point;
 };
 #endif // ZOOMER_H

0 comments (0 inline, 0 general)