Changeset - c51c9195eb8f
Parent rev.
Child rev.
[Not reviewed]
snapshots
0 4 2
Hasan Yavuz ÖZDERYA - 10 years ago 2015-09-30 07:40:13
hy@ozderya.net
show flashing overlay when snapshot taken
6 files changed with 153 insertions and 0 deletions:
CMakeLists.txt
1
mainwindow.cpp
3
plot.cpp
30
plot.h
6
plotsnapshotoverlay.cpp
65
plotsnapshotoverlay.h
48
0 comments (0 inline, 0 general)
CMakeLists.txt
➞
Show inline comments
 
#
 
# Copyright © 2015 Hasan Yavuz Özderya
 
#
 
# This file is part of serialplot.
 
#
 
# serialplot is free software: you can redistribute it and/or modify
 
# it under the terms of the GNU General Public License as published by
 
# the Free Software Foundation, either version 3 of the License, or
 
# (at your option) any later version.
 
#
 
# serialplot is distributed in the hope that it will be useful,
 
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
# GNU General Public License for more details.
 
#
 
# You should have received a copy of the GNU General Public License
 
# along with serialplot.  If not, see <http://www.gnu.org/licenses/>.
 
#
 

			




	
	
	
		
 
cmake_minimum_required(VERSION 2.8.11)

			




	
	
	
		
 

			




	
	
	
		
 
project(serialplot)

			




	
	
	
		
 

			




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

			




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

			




	
	
	
		
 

			




	
	
	
		
 
# Find includes in corresponding build directories

			




	
	
	
		
 
set(CMAKE_INCLUDE_CURRENT_DIR ON)

			




	
	
	
		
 

			




	
	
	
		
 
# Instruct CMake to run moc automatically when needed.

			




	
	
	
		
 
set(CMAKE_AUTOMOC ON)

			




	
	
	
		
 

			




	
	
	
		
 
# add local path for cmake modules

			




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

			




	
	
	
		
 

			




	
	
	
		
 
# Find the QtWidgets library

			




	
	
	
		
 
find_package(Qt5Widgets)

			




	
	
	
		
 

			




	
	
	
		
 
# Find QWT or use static

			




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

			




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

			




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

			




	
	
	
		
 

			




	
	
	
		
 
if (QWT_USE_STATIC)

			




	
	
	
		
 
  set(QWT_LIBRARY ${QWT_STATIC_LIBRARY})

			




	
	
	
		
 
  set(QWT_INCLUDE_DIR ${QWT_STATIC_INCLUDE})

			




	
	
	
		
 
else (QWT_USE_STATIC)

			




	
	
	
		
 
  find_package(Qwt 6.1 REQUIRED)

			




	
	
	
		
 
endif (QWT_USE_STATIC)

			




	
	
	
		
 

			




	
	
	
		
 
# includes

			




	
	
	
		
 
include_directories(${QWT_INCLUDE_DIR})

			




	
	
	
		
 

			




	
	
	
		
 
# wrap UI and resource files

			




	
	
	
		
 
qt5_wrap_ui(UI_FILES

			




	
	
	
		
 
  mainwindow.ui

			




	
	
	
		
 
  portcontrol.ui

			




	
	
	
		
 
  about_dialog.ui

			




	
	
	
		
 
  snapshotview.ui

			




	
	
	
		
 
  )

			




	
	
	
		
 
qt5_add_resources(RES_FILES misc/icons.qrc)

			




	
	
	
		
 

			




	
	
	
		
 
add_executable(${PROGRAM_NAME} WIN32

			




	
	
	
		
 
  main.cpp

			




	
	
	
		
 
  mainwindow.cpp

			




	
	
	
		
 
  portcontrol.cpp

			




	
	
	
		
 
  plot.cpp

			




	
	
	
		
 
  zoomer.cpp

			




	
	
	
		
 
  hidabletabwidget.cpp

			




	
	
	
		
 
  framebuffer.cpp

			




	
	
	
		
 
  scalepicker.cpp

			




	
	
	
		
 
  scalezoomer.cpp

			




	
	
	
		
 
  portlist.cpp

			




	
	
	
		
 
  snapshot.cpp

			




	
	
	
		
 
  snapshotview.cpp

			




	
	
	
		
 
  snapshotmanager.cpp

			




	
	
	
		
 
  plotsnapshotoverlay.cpp

			




	
	
	
		
 
  ${UI_FILES}

			




	
	
	
		
 
  ${RES_FILES}

			




	
	
	
		
 
  misc/windows_icon.rc

			




	
	
	
		
 
  )

			




	
	
	
		
 

			




	
	
	
		
 
# Use the Widgets module from Qt 5.

			




	
	
	
		
 
target_link_libraries(${PROGRAM_NAME} ${QWT_LIBRARY})

			




	
	
	
		
 
qt5_use_modules(${PROGRAM_NAME} Widgets SerialPort Svg)

			




	
	
	
		
 

			




	
	
	
		
 
# set compiler flags

			




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

			




	
	
	
		
 

			




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

			




	
	
	
		
 
include(CheckCXXCompilerFlag)

			




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

			




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

			




	
	
	
		
 
if(COMPILER_SUPPORTS_CXX11)

			




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

			




	
	
	
		
 
elseif(COMPILER_SUPPORTS_CXX0X)

			




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

			




	
	
	
		
 
else()

			




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

			




	
	
	
		
 
endif()

			




	
	
	
		
 

			




	
	
	
		
 
# version number

			




	
	
	
		
 
set(MAJOR_VERSION 0 CACHE INT "Program major version number.")

			




	
	
	
		
 
set(MINOR_VERSION 5 CACHE INT "Program minor version number.")

			




	
	
	
		
 
set(PATCH_VERSION 0 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}/version.h.in" "${CMAKE_CURRENT_BINARY_DIR}/version.h")

			




	
	
	
		
 

			




	
	
	
		
 
# add make run target

			




	
	
	
		
 
add_custom_target(run

			




	
	
	
		
 
    COMMAND ${PROGRAM_NAME}

			




	
	
	
		
 
    DEPENDS ${PROGRAM_NAME}

			




	
	
	
		
 
    WORKING_DIRECTORY ${CMAKE_PROJECT_DIR}

			




	
	
	
		
 
)

			




	
	
	
		
 

			




	
	
	
		
 
# installing

			




	
	
	
		
 
install(TARGETS ${PROGRAM_NAME} DESTINATION bin)

			




	
	
	
		
 

			




	
	
	
		
 
# for windows put libraries to install directory

			




	
	
	
		
 
if (WIN32)

			




	
	
	
		
 
  file(GLOB WINDOWS_INSTALL_LIBRARIES

			




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

			




	
	
	
		
 
  install(FILES ${WINDOWS_INSTALL_LIBRARIES} DESTINATION bin)

			




	
	
	
		
 
endif (WIN32)

			




	
	
	
		
 

			




	
	
	
		
 
# install menu item and icon

			




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

			




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

			




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

			




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

			




	
	
	
		
 

			




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

			




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

			




	
	
	
		
 

			




	
	
	
		
 
if (UNIX)

			




	
	
	
		
 
  # first copy files to share/serialplot/

			




	
	
	
		
 
  install(FILES

			




	
	
	
		
 
    ${CMAKE_BINARY_DIR}/${PROGRAM_NAME}.desktop

			




	
	
	
		
 
    ${CMAKE_BINARY_DIR}/${PROGRAM_NAME}.png

			




	
	
	
		
 
    DESTINATION share/${PROGRAM_NAME})

			




	
	
	
		
 

			




	
	
	
		
 
  # install copyright file (in debian format)

			




	
	
	
		
 
  install(FILES

			




	
	
	
		
 
    ${CMAKE_SOURCE_DIR}/debian/copyright

			




	
	
	
		
 
    DESTINATION share/doc/${PROGRAM_NAME}/)

			




	
	
	
		
 

			




	
	
	
		
 
  install(CODE "

			




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

			




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

			




	
	
	
		
 
")

			




	
	
	
		
 
endif (UNIX)

			




        

    


    
    

    

        

                

                    mainwindow.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -15,192 +15,195 @@

			




	
	
	
		
 

			




	
	
	
		
 
  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 <QFile>

			




	
	
	
		
 
#include <QTextStream>

			




	
	
	
		
 
#include <QtDebug>

			




	
	
	
		
 
#include <QtEndian>

			




	
	
	
		
 
#include <qwt_plot.h>

			




	
	
	
		
 
#include <limits.h>

			




	
	
	
		
 
#include <cmath>

			




	
	
	
		
 
#include <iostream>

			




	
	
	
		
 

			




	
	
	
		
 
#include <plot.h>

			




	
	
	
		
 

			




	
	
	
		
 
#include "utils.h"

			




	
	
	
		
 
#include "version.h"

			




	
	
	
		
 
#include "floatswap.h"

			




	
	
	
		
 

			




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

			




	
	
	
		
 
#include <QtPlugin>

			




	
	
	
		
 
Q_IMPORT_PLUGIN(QWindowsIntegrationPlugin)

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
struct Range

			




	
	
	
		
 
{

			




	
	
	
		
 
    double rmin;

			




	
	
	
		
 
    double rmax;

			




	
	
	
		
 
};

			




	
	
	
		
 

			




	
	
	
		
 
Q_DECLARE_METATYPE(Range);

			




	
	
	
		
 

			




	
	
	
		
 
MainWindow::MainWindow(QWidget *parent) :

			




	
	
	
		
 
    QMainWindow(parent),

			




	
	
	
		
 
    ui(new Ui::MainWindow),

			




	
	
	
		
 
    portControl(&serialPort),

			




	
	
	
		
 
    snapshotMan(this, &channelBuffers)

			




	
	
	
		
 
{

			




	
	
	
		
 
    ui->setupUi(this);

			




	
	
	
		
 
    ui->tabWidget->insertTab(0, &portControl, "Port");

			




	
	
	
		
 
    ui->tabWidget->setCurrentIndex(0);

			




	
	
	
		
 
    addToolBar(portControl.toolBar());

			




	
	
	
		
 

			




	
	
	
		
 
    ui->mainToolBar->addAction(snapshotMan.takeSnapshotAction());

			




	
	
	
		
 
    ui->menuBar->insertMenu(ui->menuHelp->menuAction(), snapshotMan.menu());

			




	
	
	
		
 

			




	
	
	
		
 
    setupAboutDialog();

			




	
	
	
		
 

			




	
	
	
		
 
    // init view menu

			




	
	
	
		
 
    for (auto a : ui->plot->menuActions())

			




	
	
	
		
 
    {

			




	
	
	
		
 
        ui->menuView->addAction(a);

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    // init UI signals

			




	
	
	
		
 

			




	
	
	
		
 
    // menu signals

			




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

			




	
	
	
		
 
              &aboutDialog, &QWidget::show);

			




	
	
	
		
 

			




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

			




	
	
	
		
 
                     this, &MainWindow::onExportCsv);

			




	
	
	
		
 

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    QObject::connect(&portControl, &PortControl::skipByteRequested,

			




	
	
	
		
 
                     this, &MainWindow::skipByte);

			




	
	
	
		
 

			




	
	
	
		
 
    QObject::connect(ui->spNumOfSamples, SELECT<int>::OVERLOAD_OF(&QSpinBox::valueChanged),

			




	
	
	
		
 
                     this, &MainWindow::onNumOfSamplesChanged);

			




	
	
	
		
 

			




	
	
	
		
 
    QObject::connect(ui->cbAutoScale, &QCheckBox::toggled,

			




	
	
	
		
 
                     this, &MainWindow::onAutoScaleChecked);

			




	
	
	
		
 

			




	
	
	
		
 
    QObject::connect(ui->spYmin, SIGNAL(valueChanged(double)),

			




	
	
	
		
 
                     this, SLOT(onYScaleChanged()));

			




	
	
	
		
 

			




	
	
	
		
 
    QObject::connect(ui->spYmax, SIGNAL(valueChanged(double)),

			




	
	
	
		
 
                     this, SLOT(onYScaleChanged()));

			




	
	
	
		
 

			




	
	
	
		
 
    QObject::connect(ui->actionClear, SIGNAL(triggered(bool)),

			




	
	
	
		
 
                     this, SLOT(clearPlot()));

			




	
	
	
		
 

			




	
	
	
		
 
    QObject::connect(snapshotMan.takeSnapshotAction(), &QAction::triggered,

			




	
	
	
		
 
                     ui->plot, &Plot::flashSnapshotOverlay);

			




	
	
	
		
 

			




	
	
	
		
 
    // setup number of channels spinbox

			




	
	
	
		
 
    QObject::connect(ui->spNumOfChannels,

			




	
	
	
		
 
                     SELECT<int>::OVERLOAD_OF(&QSpinBox::valueChanged),

			




	
	
	
		
 
                     this, &MainWindow::onNumOfChannelsChanged);

			




	
	
	
		
 

			




	
	
	
		
 
    // setup number format buttons

			




	
	
	
		
 
    numberFormatButtons.addButton(ui->rbUint8,  NumberFormat_uint8);

			




	
	
	
		
 
    numberFormatButtons.addButton(ui->rbUint16, NumberFormat_uint16);

			




	
	
	
		
 
    numberFormatButtons.addButton(ui->rbUint32, NumberFormat_uint32);

			




	
	
	
		
 
    numberFormatButtons.addButton(ui->rbInt8,   NumberFormat_int8);

			




	
	
	
		
 
    numberFormatButtons.addButton(ui->rbInt16,  NumberFormat_int16);

			




	
	
	
		
 
    numberFormatButtons.addButton(ui->rbInt32,  NumberFormat_int32);

			




	
	
	
		
 
    numberFormatButtons.addButton(ui->rbFloat,  NumberFormat_float);

			




	
	
	
		
 
    numberFormatButtons.addButton(ui->rbASCII,  NumberFormat_ASCII);

			




	
	
	
		
 

			




	
	
	
		
 
    QObject::connect(&numberFormatButtons, SIGNAL(buttonToggled(int, bool)),

			




	
	
	
		
 
                     this, SLOT(onNumberFormatButtonToggled(int, bool)));

			




	
	
	
		
 

			




	
	
	
		
 
    // init port signals

			




	
	
	
		
 
    QObject::connect(&(this->serialPort), SIGNAL(error(QSerialPort::SerialPortError)),

			




	
	
	
		
 
                     this, SLOT(onPortError(QSerialPort::SerialPortError)));

			




	
	
	
		
 

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    // init data arrays and plot

			




	
	
	
		
 

			




	
	
	
		
 
    numOfSamples = ui->spNumOfSamples->value();

			




	
	
	
		
 
    numOfChannels = ui->spNumOfChannels->value();

			




	
	
	
		
 

			




	
	
	
		
 
    // init channel data and curve list

			




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

			




	
	
	
		
 
    {

			




	
	
	
		
 
        channelBuffers.append(new FrameBuffer(numOfSamples));

			




	
	
	
		
 
        curves.append(new QwtPlotCurve());

			




	
	
	
		
 
        curves[i]->setSamples(channelBuffers[i]);

			




	
	
	
		
 
        curves[i]->setPen(Plot::makeColor(i));

			




	
	
	
		
 
        curves[i]->attach(ui->plot);

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    // init auto scale

			




	
	
	
		
 
    ui->plot->setAxis(ui->cbAutoScale->isChecked(),

			




	
	
	
		
 
                      ui->spYmin->value(), ui->spYmax->value());

			




	
	
	
		
 

			




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

			




	
	
	
		
 

			




	
	
	
		
 
    // init number format

			




	
	
	
		
 
    if (numberFormatButtons.checkedId() >= 0)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        selectNumberFormat((NumberFormat) numberFormatButtons.checkedId());

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else

			




	
	
	
		
 
    {

			




	
	
	
		
 
        selectNumberFormat(NumberFormat_uint8);

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    // Init sps (sample per second) counter

			




	
	
	
		
 
    sampleCount = 0;

			




	
	
	
		
 
    spsLabel.setText("0sps");

			




	
	
	
		
 
    spsLabel.setToolTip("samples per second (total of all channels)");

			




	
	
	
		
 
    ui->statusBar->addPermanentWidget(&spsLabel);

			




	
	
	
		
 
    spsTimer.start(SPS_UPDATE_TIMEOUT * 1000);

			




	
	
	
		
 
    QObject::connect(&spsTimer, &QTimer::timeout,

			




	
	
	
		
 
                     this, &MainWindow::spsTimerTimeout);

			




	
	
	
		
 

			




	
	
	
		
 
    // Init demo mode

			




	
	
	
		
 
    demoCount = 0;

			




	
	
	
		
 
    demoTimer.setInterval(100);

			




	
	
	
		
 
    QObject::connect(&demoTimer, &QTimer::timeout,

			




        

    


    
    

    

        

                

                    plot.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
/*

			




	
	
	
		
 
  Copyright © 2015 Hasan Yavuz Özderya

			




	
	
	
		
 

			




	
	
	
		
 
  This file is part of serialplot.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot is free software: you can redistribute it and/or modify

			




	
	
	
		
 
  it under the terms of the GNU General Public License as published by

			




	
	
	
		
 
  the Free Software Foundation, either version 3 of the License, or

			




	
	
	
		
 
  (at your option) any later version.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot is distributed in the hope that it will be useful,

			




	
	
	
		
 
  but WITHOUT ANY WARRANTY; without even the implied warranty of

			




	
	
	
		
 
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

			




	
	
	
		
 
  GNU General Public License for more details.

			




	
	
	
		
 

			




	
	
	
		
 
  You should have received a copy of the GNU General Public License

			




	
	
	
		
 
  along with serialplot.  If not, see <http://www.gnu.org/licenses/>.

			




	
	
	
		
 
*/

			




	
	
	
		
 

			




	
	
	
		
 
#include <QRectF>

			




	
	
	
		
 
#include <QKeySequence>

			




	
	
	
		
 

			




	
	
	
		
 
#include "plot.h"

			




	
	
	
		
 
#include "utils.h"

			




	
	
	
		
 

			




	
	
	
		
 
Plot::Plot(QWidget* parent) :

			




	
	
	
		
 
    QwtPlot(parent),

			




	
	
	
		
 
    zoomer(this->canvas(), false),

			




	
	
	
		
 
    sZoomer(this, &zoomer),

			




	
	
	
		
 
    _showGridAction("Grid", this),

			




	
	
	
		
 
    _showMinorGridAction("Minor Grid", this),

			




	
	
	
		
 
    _unzoomAction("Unzoom", this),

			




	
	
	
		
 
    _darkBackgroundAction("Dark Background", this)

			




	
	
	
		
 
{

			




	
	
	
		
 
    isAutoScaled = true;

			




	
	
	
		
 

			




	
	
	
		
 
    QObject::connect(&zoomer, &Zoomer::unzoomed, this, &Plot::unzoomed);

			




	
	
	
		
 

			




	
	
	
		
 
    zoomer.setZoomBase();

			




	
	
	
		
 
    grid.attach(this);

			




	
	
	
		
 

			




	
	
	
		
 
    rectItem.setRect(QRectF(0,0,100,1));

			




	
	
	
		
 
    // rectItem.attach(this);

			




	
	
	
		
 

			




	
	
	
		
 
    showGrid(false);

			




	
	
	
		
 
    darkBackground(false);

			




	
	
	
		
 

			




	
	
	
		
 
    _showGridAction.setToolTip("Show Grid");

			




	
	
	
		
 
    _showMinorGridAction.setToolTip("Show Minor Grid");

			




	
	
	
		
 
    _unzoomAction.setToolTip("Unzoom the Plot");

			




	
	
	
		
 
    _darkBackgroundAction.setToolTip("Enable Dark Plot Background");

			




	
	
	
		
 

			




	
	
	
		
 
    _showGridAction.setShortcut(QKeySequence("G"));

			




	
	
	
		
 
    _showMinorGridAction.setShortcut(QKeySequence("M"));

			




	
	
	
		
 

			




	
	
	
		
 
    _showGridAction.setCheckable(true);

			




	
	
	
		
 
    _showMinorGridAction.setCheckable(true);

			




	
	
	
		
 
    _darkBackgroundAction.setCheckable(true);

			




	
	
	
		
 

			




	
	
	
		
 
    _showGridAction.setChecked(false);

			




	
	
	
		
 
    _showMinorGridAction.setChecked(false);

			




	
	
	
		
 
    _darkBackgroundAction.setChecked(false);

			




	
	
	
		
 

			




	
	
	
		
 
    _showMinorGridAction.setEnabled(false);

			




	
	
	
		
 

			




	
	
	
		
 
    connect(&_showGridAction, SELECT<bool>::OVERLOAD_OF(&QAction::triggered),

			




	
	
	
		
 
            this, &Plot::showGrid);

			




	
	
	
		
 
    connect(&_showGridAction, SELECT<bool>::OVERLOAD_OF(&QAction::triggered),

			




	
	
	
		
 
            &_showMinorGridAction, &QAction::setEnabled);

			




	
	
	
		
 
    connect(&_showMinorGridAction, SELECT<bool>::OVERLOAD_OF(&QAction::triggered),

			




	
	
	
		
 
            this, &Plot::showMinorGrid);

			




	
	
	
		
 
    connect(&_unzoomAction, &QAction::triggered, this, &Plot::unzoom);

			




	
	
	
		
 
    connect(&_darkBackgroundAction, SELECT<bool>::OVERLOAD_OF(&QAction::triggered),

			




	
	
	
		
 
            this, &Plot::darkBackground);

			




	
	
	
		
 

			




	
	
	
		
 
    snapshotOverlay = NULL;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
Plot::~Plot()

			




	
	
	
		
 
{

			




	
	
	
		
 
    if (snapshotOverlay != NULL) delete snapshotOverlay;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void Plot::setAxis(bool autoScaled, double yAxisMin, double yAxisMax)

			




	
	
	
		
 
{

			




	
	
	
		
 
    this->isAutoScaled = autoScaled;

			




	
	
	
		
 

			




	
	
	
		
 
    if (!autoScaled)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        yMin = yAxisMin;

			




	
	
	
		
 
        yMax = yAxisMax;

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    zoomer.zoom(0);

			




	
	
	
		
 
    resetAxes();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
QList<QAction*> Plot::menuActions()

			




	
	
	
		
 
{

			




	
	
	
		
 
    QList<QAction*> actions;

			




	
	
	
		
 
    actions << &_showGridAction;

			




	
	
	
		
 
    actions << &_showMinorGridAction;

			




	
	
	
		
 
    actions << &_unzoomAction;

			




	
	
	
		
 
    actions << &_darkBackgroundAction;

			




	
	
	
		
 
    return actions;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void Plot::resetAxes()

			




	
	
	
		
 
{

			




	
	
	
		
 
    if (isAutoScaled)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        setAxisAutoScale(QwtPlot::yLeft);

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else

			




	
	
	
		
 
    {

			




	
	
	
		
 
        setAxisScale(QwtPlot::yLeft, yMin, yMax);

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    replot();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void Plot::unzoomed()

			




	
	
	
		
 
{

			




	
	
	
		
 
    setAxisAutoScale(QwtPlot::xBottom);

			




	
	
	
		
 
    resetAxes();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
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::unzoom()

			




	
	
	
		
 
{

			




	
	
	
		
 
    zoomer.zoom(0);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void Plot::darkBackground(bool enabled)

			




	
	
	
		
 
{

			




	
	
	
		
 
    if (enabled)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        setCanvasBackground(QBrush(Qt::black));

			




	
	
	
		
 
        grid.setPen(Qt::darkGray);

			




	
	
	
		
 
        zoomer.setRubberBandPen(QPen(Qt::white));

			




	
	
	
		
 
        zoomer.setTrackerPen(QPen(Qt::white));

			




	
	
	
		
 
        sZoomer.setPickerPen(QPen(Qt::white));

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else

			




	
	
	
		
 
    {

			




	
	
	
		
 
        setCanvasBackground(QBrush(Qt::white));

			




	
	
	
		
 
        grid.setPen(Qt::lightGray);

			




	
	
	
		
 
        zoomer.setRubberBandPen(QPen(Qt::black));

			




	
	
	
		
 
        zoomer.setTrackerPen(QPen(Qt::black));

			




	
	
	
		
 
        sZoomer.setPickerPen(QPen(Qt::black));

			




	
	
	
		
 
    }

			




	
	
	
		
 
    replot();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
/*

			




	
	
	
		
 
  Below crude drawing demostrates how color selection occurs for

			




	
	
	
		
 
  given channel index

			




	
	
	
		
 

			




	
	
	
		
 
  0°                     <--Hue Value-->                           360°

			




	
	
	
		
 
  |* . o . + . o . * . o . + . o . * . o . + . o . * . o . + . o . |

			




	
	
	
		
 

			




	
	
	
		
 
  * -> 0-3

			




	
	
	
		
 
  + -> 4-7

			




	
	
	
		
 
  o -> 8-15

			




	
	
	
		
 
  . -> 16-31

			




	
	
	
		
 

			




	
	
	
		
 
 */

			




	
	
	
		
 
QColor Plot::makeColor(unsigned int channelIndex)

			




	
	
	
		
 
{

			




	
	
	
		
 
    auto i = channelIndex;

			




	
	
	
		
 

			




	
	
	
		
 
    if (i < 4)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        return QColor::fromHsv(360*i/4, 255, 230);

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else

			




	
	
	
		
 
    {

			




	
	
	
		
 
        double p = floor(log2(i));

			




	
	
	
		
 
        double n = pow(2, p);

			




	
	
	
		
 
        i = i - n;

			




	
	
	
		
 
        return QColor::fromHsv(360*i/n + 360/pow(2,p+1), 255, 230);

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void Plot::flashSnapshotOverlay()

			




	
	
	
		
 
{

			




	
	
	
		
 
    if (snapshotOverlay != NULL) delete snapshotOverlay;

			




	
	
	
		
 

			




	
	
	
		
 
    QColor color;

			




	
	
	
		
 
    if (_darkBackgroundAction.isChecked())

			




	
	
	
		
 
    {

			




	
	
	
		
 
        color = QColor(Qt::white);

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else

			




	
	
	
		
 
    {

			




	
	
	
		
 
        color = QColor(Qt::black);

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    snapshotOverlay = new PlotSnapshotOverlay(this->canvas(), color);

			




	
	
	
		
 
    connect(snapshotOverlay, &PlotSnapshotOverlay::done,

			




	
	
	
		
 
            [this]()

			




	
	
	
		
 
            {

			




	
	
	
		
 
                delete snapshotOverlay;

			




	
	
	
		
 
                snapshotOverlay = NULL;

			




	
	
	
		
 
            });

			




	
	
	
		
 
}

			




        

    


    
    

    

        

                

                    plot.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
/*

			




	
	
	
		
 
  Copyright © 2015 Hasan Yavuz Özderya

			




	
	
	
		
 

			




	
	
	
		
 
  This file is part of serialplot.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot is free software: you can redistribute it and/or modify

			




	
	
	
		
 
  it under the terms of the GNU General Public License as published by

			




	
	
	
		
 
  the Free Software Foundation, either version 3 of the License, or

			




	
	
	
		
 
  (at your option) any later version.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot is distributed in the hope that it will be useful,

			




	
	
	
		
 
  but WITHOUT ANY WARRANTY; without even the implied warranty of

			




	
	
	
		
 
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

			




	
	
	
		
 
  GNU General Public License for more details.

			




	
	
	
		
 

			




	
	
	
		
 
  You should have received a copy of the GNU General Public License

			




	
	
	
		
 
  along with serialplot.  If not, see <http://www.gnu.org/licenses/>.

			




	
	
	
		
 
*/

			




	
	
	
		
 

			




	
	
	
		
 
#ifndef 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 "zoomer.h"

			




	
	
	
		
 
#include "scalezoomer.h"

			




	
	
	
		
 
#include "plotsnapshotoverlay.h"

			




	
	
	
		
 

			




	
	
	
		
 
class Plot : public QwtPlot

			




	
	
	
		
 
{

			




	
	
	
		
 
    Q_OBJECT

			




	
	
	
		
 

			




	
	
	
		
 
public:

			




	
	
	
		
 
    Plot(QWidget* parent = 0);

			




	
	
	
		
 
    ~Plot();

			




	
	
	
		
 
    void setAxis(bool autoScaled, double yMin = 0, double yMax = 1);

			




	
	
	
		
 

			




	
	
	
		
 
    QList<QAction*> menuActions();

			




	
	
	
		
 

			




	
	
	
		
 
    static QColor makeColor(unsigned int channelIndex);

			




	
	
	
		
 

			




	
	
	
		
 
private:

			




	
	
	
		
 
    bool isAutoScaled;

			




	
	
	
		
 
    double yMin, yMax;

			




	
	
	
		
 
    Zoomer zoomer;

			




	
	
	
		
 
    ScaleZoomer sZoomer;

			




	
	
	
		
 
    QwtPlotGrid grid;

			




	
	
	
		
 
    QwtPlotShapeItem rectItem;

			




	
	
	
		
 
    PlotSnapshotOverlay* snapshotOverlay;

			




	
	
	
		
 

			




	
	
	
		
 
    QAction _showGridAction;

			




	
	
	
		
 
    QAction _showMinorGridAction;

			




	
	
	
		
 
    QAction _unzoomAction;

			




	
	
	
		
 
    QAction _darkBackgroundAction;

			




	
	
	
		
 

			




	
	
	
		
 
    void resetAxes();

			




	
	
	
		
 

			




	
	
	
		
 
public slots:

			




	
	
	
		
 
    void showGrid(bool show = true);

			




	
	
	
		
 
    void showMinorGrid(bool show = true);

			




	
	
	
		
 
    void unzoom();

			




	
	
	
		
 
    void darkBackground(bool enabled = true);

			




	
	
	
		
 

			




	
	
	
		
 
    void flashSnapshotOverlay();

			




	
	
	
		
 

			




	
	
	
		
 
private slots:

			




	
	
	
		
 
    void unzoomed();

			




	
	
	
		
 
};

			




	
	
	
		
 

			




	
	
	
		
 
#endif // PLOT_H

			




        

    


    
    

    

        

                

                    plotsnapshotoverlay.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
new file 100644

			




	
	
	
		
 
/*

			




	
	
	
		
 
  Copyright © 2015 Hasan Yavuz Özderya

			




	
	
	
		
 

			




	
	
	
		
 
  This file is part of serialplot.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot is free software: you can redistribute it and/or modify

			




	
	
	
		
 
  it under the terms of the GNU General Public License as published by

			




	
	
	
		
 
  the Free Software Foundation, either version 3 of the License, or

			




	
	
	
		
 
  (at your option) any later version.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot is distributed in the hope that it will be useful,

			




	
	
	
		
 
  but WITHOUT ANY WARRANTY; without even the implied warranty of

			




	
	
	
		
 
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

			




	
	
	
		
 
  GNU General Public License for more details.

			




	
	
	
		
 

			




	
	
	
		
 
  You should have received a copy of the GNU General Public License

			




	
	
	
		
 
  along with serialplot.  If not, see <http://www.gnu.org/licenses/>.

			




	
	
	
		
 
*/

			




	
	
	
		
 

			




	
	
	
		
 
#include <algorithm>

			




	
	
	
		
 
#include <QPen>

			




	
	
	
		
 

			




	
	
	
		
 
#include "plotsnapshotoverlay.h"

			




	
	
	
		
 

			




	
	
	
		
 
#define LINE_WIDTH (10)

			




	
	
	
		
 
#define ANIM_LENGTH (500) // milliseconds

			




	
	
	
		
 
#define UPDATE_PERIOD (20) // milliseconds

			




	
	
	
		
 

			




	
	
	
		
 
PlotSnapshotOverlay::PlotSnapshotOverlay(QWidget* widget, QColor color) :

			




	
	
	
		
 
    QwtWidgetOverlay(widget)

			




	
	
	
		
 
{

			




	
	
	
		
 
    _color = color;

			




	
	
	
		
 
    animTimer.setSingleShot(true);

			




	
	
	
		
 
    animTimer.setInterval(ANIM_LENGTH);

			




	
	
	
		
 
    updateTimer.setSingleShot(false);

			




	
	
	
		
 
    updateTimer.setInterval(UPDATE_PERIOD);

			




	
	
	
		
 

			




	
	
	
		
 
    connect(&updateTimer, &QTimer::timeout, [this](){this->updateOverlay();});

			




	
	
	
		
 
    connect(&animTimer, &QTimer::timeout, &updateTimer, &QTimer::stop);

			




	
	
	
		
 
    connect(&animTimer, &QTimer::timeout, this, &PlotSnapshotOverlay::done);

			




	
	
	
		
 

			




	
	
	
		
 
    animTimer.start();

			




	
	
	
		
 
    updateTimer.start();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void PlotSnapshotOverlay::drawOverlay(QPainter* painter) const

			




	
	
	
		
 
{

			




	
	
	
		
 
        if (!animTimer.isActive()) return;

			




	
	
	
		
 
    QColor lineColor = _color;

			




	
	
	
		
 

			




	
	
	
		
 
    double fadingRatio = ((double) animTimer.remainingTime()) / ANIM_LENGTH;

			




	
	
	
		
 
    lineColor.setAlpha(std::min(255, (int) (255*fadingRatio)));

			




	
	
	
		
 

			




	
	
	
		
 
    QPen pen(lineColor);

			




	
	
	
		
 
    pen.setWidth(LINE_WIDTH);

			




	
	
	
		
 
    pen.setJoinStyle(Qt::MiterJoin);

			




	
	
	
		
 

			




	
	
	
		
 
    int width = painter->device()->width();

			




	
	
	
		
 
    int height = painter->device()->height();

			




	
	
	
		
 

			




	
	
	
		
 
    painter->save();

			




	
	
	
		
 
    painter->setPen(pen);

			




	
	
	
		
 
    painter->drawRect(LINE_WIDTH/2, LINE_WIDTH/2, width-LINE_WIDTH, height-LINE_WIDTH);

			




	
	
	
		
 
    painter->restore();

			




	
	
	
		
 
}

			




        

    


    
    

    

        

                

                    plotsnapshotoverlay.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
new file 100644

			




	
	
	
		
 
/*

			




	
	
	
		
 
  Copyright © 2015 Hasan Yavuz Özderya

			




	
	
	
		
 

			




	
	
	
		
 
  This file is part of serialplot.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot is free software: you can redistribute it and/or modify

			




	
	
	
		
 
  it under the terms of the GNU General Public License as published by

			




	
	
	
		
 
  the Free Software Foundation, either version 3 of the License, or

			




	
	
	
		
 
  (at your option) any later version.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot is distributed in the hope that it will be useful,

			




	
	
	
		
 
  but WITHOUT ANY WARRANTY; without even the implied warranty of

			




	
	
	
		
 
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

			




	
	
	
		
 
  GNU General Public License for more details.

			




	
	
	
		
 

			




	
	
	
		
 
  You should have received a copy of the GNU General Public License

			




	
	
	
		
 
  along with serialplot.  If not, see <http://www.gnu.org/licenses/>.

			




	
	
	
		
 
*/

			




	
	
	
		
 

			




	
	
	
		
 
#ifndef PLOTSNAPSHOTOVERLAY_H

			




	
	
	
		
 
#define PLOTSNAPSHOTOVERLAY_H

			




	
	
	
		
 

			




	
	
	
		
 
#include <QColor>

			




	
	
	
		
 
#include <QPainter>

			




	
	
	
		
 
#include <QTimer>

			




	
	
	
		
 
#include <qwt_widget_overlay.h>

			




	
	
	
		
 

			




	
	
	
		
 
// Draws a sort of flashing effect on plot widget when snapshot taken

			




	
	
	
		
 
class PlotSnapshotOverlay : public QwtWidgetOverlay

			




	
	
	
		
 
{

			




	
	
	
		
 
    Q_OBJECT

			




	
	
	
		
 

			




	
	
	
		
 
public:

			




	
	
	
		
 
    PlotSnapshotOverlay(QWidget* widget, QColor color);

			




	
	
	
		
 

			




	
	
	
		
 
protected:

			




	
	
	
		
 
    void drawOverlay(QPainter*) const;

			




	
	
	
		
 

			




	
	
	
		
 
signals:

			




	
	
	
		
 
    void done(); // indicates that animation completed

			




	
	
	
		
 

			




	
	
	
		
 
private:

			




	
	
	
		
 
    QColor _color;

			




	
	
	
		
 
    QTimer animTimer; // controls fading

			




	
	
	
		
 
    QTimer updateTimer; // need to force repaint the canvas

			




	
	
	
		
 
};

			




	
	
	
		
 

			




	
	
	
		
 
#endif // PLOTSNAPSHOTOVERLAY_H

			




        

    



    


    



    



      

      





    
    0 comments (0 inline, 0 general)
    





    


  

  







  


    




    








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