baseplotwidget.h

Go to the documentation of this file.

/* This code comes right from the msXpertSuite software project.
 *
 * msXpertSuite - mass spectrometry software suite
 * -----------------------------------------------
 * Copyright(C) 2009,...,2018 Filippo Rusconi
 *
 * http://www.msxpertsuite.org
 *
 * This program 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.
 *
 * This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
 *
 * END software license
 */
 
 
#pragma once
 
/////////////////////// StdLib includes
#include <memory>
 
 
/////////////////////// Qt includes
#include <QObject>
#include <QString>
#include <QWidget>
#include <QBrush>
#include <QColor>
#include <QVector>
 
 
/////////////////////// QCustomPlot
#include <qcustomplot.h>
 
 
/////////////////////// Local includes
#include "pappsomspp/export-import-config.h"
#include "../../core/types.h"
#include "pappsomspp/core/processing/combiners/selectionpolygon.h"
#include "baseplotcontext.h"
 
 
namespace pappso
{
 
 enum class SelectionDrawingLines
 {
  NOT_SET = 0x0000,
 
  TOP_LINE    = 1 << 0,
  BOTTOM_LINE = 1 << 1,
 
  HORIZONTAL_LINES = (TOP_LINE | BOTTOM_LINE),
 
  RIGHT_LINE = 1 << 2,
  LEFT_LINE  = 1 << 3,
 
  VERTICAL_LINES = (RIGHT_LINE | LEFT_LINE),
 
  FULL_POLYGON = (HORIZONTAL_LINES | VERTICAL_LINES)
 };
 
 enum class RangeType
 {
   OUTERMOST = 1,
   INNERMOST = 2,
 };
 
 class BasePlotWidget;
 
 typedef std::shared_ptr<BasePlotWidget> BasePlotWidgetSPtr;
 typedef std::shared_ptr<const BasePlotWidget> BasePlotWidgetCstSPtr;
 
 class PMSPP_LIB_DECL BasePlotWidget : public QCustomPlot
 {
   Q_OBJECT
 
   public:
   explicit BasePlotWidget(QWidget *parent);
   explicit BasePlotWidget(QWidget *parent,
                           const QString &x_axis_label,
                           const QString &y_axis_label);
 
   virtual ~BasePlotWidget();
 
   virtual bool setupWidget();
 
   virtual void setPen(const QPen &pen);
   virtual const QPen &getPen() const;
 
   virtual void setPlottingColor(QCPAbstractPlottable *plottable_p, const QColor &new_color);
   virtual void setPlottingColor(int index, const QColor &new_color);
 
   virtual QColor getPlottingColor(QCPAbstractPlottable *plottable_p) const;
   virtual QColor getPlottingColor(int index = 0) const;
 
   virtual void setAxisLabelX(const QString &label);
   virtual void setAxisLabelY(const QString &label);
 
   // AXES RANGE HISTORY-related functions
   virtual void resetAxesRangeHistory();
   virtual void updateAxesRangeHistory();
   virtual void restorePreviousAxesRangeHistory();
   virtual void restoreAxesRangeHistory(std::size_t index);
   // AXES RANGE HISTORY-related functions
 
 
   /// KEYBOARD-related EVENTS
   virtual void keyPressEvent(QKeyEvent *event);
   virtual void keyReleaseEvent(QKeyEvent *event);
 
   virtual void spaceKeyReleaseEvent(QKeyEvent *event);
 
   virtual void directionKeyPressEvent(QKeyEvent *event);
   virtual void directionKeyReleaseEvent(QKeyEvent *event);
 
   virtual void mousePseudoButtonKeyPressEvent(QKeyEvent *event);
   virtual void mousePseudoButtonKeyReleaseEvent(QKeyEvent *event);
   /// KEYBOARD-related EVENTS
 
 
   /// MOUSE-related EVENTS
   virtual void mousePressHandler(QMouseEvent *event);
   virtual void mouseReleaseHandler(QMouseEvent *event);
   virtual void mouseReleaseHandlerLeftButton(QMouseEvent *event);
   virtual void mouseReleaseHandlerRightButton(QMouseEvent *event);
 
   virtual void mouseWheelHandler(QWheelEvent *event);
 
   virtual void mouseMoveHandler(QMouseEvent *event);
   virtual void mouseMoveHandlerNotDraggingCursor(QMouseEvent *event);
   virtual void mouseMoveHandlerDraggingCursor(QMouseEvent *event);
   virtual void mouseMoveHandlerLeftButtonDraggingCursor(QMouseEvent *event);
   virtual void mouseMoveHandlerRightButtonDraggingCursor(QMouseEvent *event);
 
   virtual void
   axisDoubleClickHandler(QCPAxis *axis, QCPAxis::SelectablePart part, QMouseEvent *event);
   bool isClickOntoXAxis(const QPointF &mousePoint);
   bool isClickOntoYAxis(const QPointF &mousePoint);
   /// MOUSE-related EVENTS
 
 
   /// MOUSE MOVEMENTS mouse/keyboard-triggered
   int dragDirection();
   virtual void moveMouseCursorGraphCoordToGlobal(QPointF plot_coordinates);
   virtual void moveMouseCursorPixelCoordToGlobal(QPointF local_coordinates);
   virtual void horizontalMoveMouseCursorCountPixels(int pixel_count);
   virtual QPointF horizontalGetGraphCoordNewPointCountPixels(int pixel_count);
   virtual void verticalMoveMouseCursorCountPixels(int pixel_count);
   virtual QPointF verticalGetGraphCoordNewPointCountPixels(int pixel_count);
   /// MOUSE MOVEMENTS mouse/keyboard-triggered
 
 
   /// RANGE-related functions
   virtual QCPRange getRangeX(bool &found_range, int index, RangeType range_type) const;
   virtual void
   getRangeX(bool &found_range, int index, RangeType range_type, double &start, double &stop) const;
   virtual void getRangeX(bool &found_range,
                          int index,
                          RangeType range_type,
                          std::pair<double, double> &start_stop_pair) const;
 
   virtual QCPRange getRangeY(bool &found_range, int index, RangeType range_type) const;
   virtual void
   getRangeY(bool &found_range, int index, RangeType range_type, double &start, double &stop) const;
   virtual void getRangeY(bool &found_range,
                          int index,
                          RangeType range_type,
                          std::pair<double, double> &start_stop_pair) const;
 
   QCPRange getRange(Enums::Axis axis, RangeType range_type, bool &found_range) const;
 
   virtual QCPRange getInnermostRangeX(bool &found_range) const;
   virtual QCPRange getOutermostRangeX(bool &found_range) const;
 
   virtual QCPRange getInnermostRangeY(bool &found_range) const;
   virtual QCPRange getOutermostRangeY(bool &found_range) const;
 
   void yMinMaxOnXAxisCurrentRange(double &min,
                                   double &max,
                                   QCPAbstractPlottable *plottable_p = nullptr);
   void yMinMaxOnXAxisCurrentRange(double &min, double &max, int index);
   /// RANGE-related functions
 
 
   /// PLOTTING / REPLOTTING functions
   virtual void axisRescale();
   virtual void axisReframe();
   virtual void axisZoom();
   virtual void axisPan();
 
   virtual void replotWithAxesRanges(QCPRange xAxisRange, QCPRange yAxisRange, Enums::Axis axis);
 
   virtual void replotWithAxisRangeX(double lower, double upper);
   virtual void replotWithAxisRangeY(double lower, double upper);
   /// PLOTTING / REPLOTTING functions
 
 
   /// PLOT ITEMS : TRACER TEXT ITEMS...
   virtual void hideAllPlotItems();
 
   virtual void showTracers();
   virtual void hideTracers();
 
   virtual void drawXScopeSpanFeatures();
   virtual void drawYScopeSpanFeatures();
 
   virtual void calculateDragDeltas();
 
   virtual bool isVerticalDisplacementAboveThreshold();
 
   virtual void drawSelectionRectangleAndPrepareZoom(bool as_line_segment = false,
                                                     bool for_integration = false);
 
   virtual void updateIntegrationScopeDrawing(bool as_line_segment = false,
                                              bool for_integration = false);
 
   virtual void resetSelectionRectangle();
   virtual void hideSelectionRectangle(bool reset_values = false);
   virtual bool isSelectionRectangleVisible();
   virtual SelectionDrawingLines whatIsVisibleOfTheSelectionRectangle();
   /// PLOT ITEMS : TRACER TEXT ITEMS...
 
 
   virtual void setFocus();
 
   virtual void redrawPlotBackground(QWidget *focusedPlotWidget);
 
   virtual void updateContextXandYAxisRanges();
 
   virtual const BasePlotContext &getContext() const;
 
   virtual int getPlotIndex(QCPAbstractPlottable *plottable_p);
 
   ////////////////////////// SIGNALS /////////////////////////////////
   ////////////////////////// SIGNALS /////////////////////////////////
   ////////////////////////// SIGNALS /////////////////////////////////
   signals:
 
   void setFocusSignal();
 
   void lastCursorHoveredPointSignal(const QPointF &pointf);
 
   void plotRangesChangedSignal(QMouseEvent *event, const pappso::BasePlotContext &context);
   void plotRangesChangedWheelEventSignal(QWheelEvent *event,
                                          const pappso::BasePlotContext &context);
 
   void xAxisMeasurementSignal(const pappso::BasePlotContext &context, bool with_delta);
 
   void keyPressEventSignal(QKeyEvent *event, const pappso::BasePlotContext &context);
   void keyReleaseEventSignal(QKeyEvent *event, const pappso::BasePlotContext &context);
 
   void mousePressEventSignal(QMouseEvent *event, const pappso::BasePlotContext &context);
   void mouseReleaseEventSignal(QMouseEvent *event, const pappso::BasePlotContext &context);
   void mouseMoveDraggingCursorSignal(QMouseEvent *event, const pappso::BasePlotContext &context);
 
   void mouseWheelEventSignal(QWheelEvent *event, const pappso::BasePlotContext &context);
 
   void plottableSelectionChangedSignal(QCPAbstractPlottable *plottable_p, bool selected);
 
   void integrationRequestedSignal(const BasePlotContext &context);
 
   void plottableDestructionRequestedSignal(BasePlotWidget *base_plot_widget_p,
                                            QCPAbstractPlottable *plottable_p,
                                            const pappso::BasePlotContext &context);
 
   void beforeReplotSignal();
   void afterLayoutSignal();
   void afterReplotSignal();
 
   protected:
   //! Name of the plot widget.
   QString m_name = "NOT_SET";
 
   //! Description of the plot widget.
   QString m_desc = "NOT_SET";
 
   //! The name of the data file from which the mass data were read.
   QString m_fileName;
 
   QString m_axisLabelX;
   QString m_axisLabelY;
 
   BasePlotContext m_context;
 
   int m_leftMousePseudoButtonKey  = Qt::Key_Less;
   int m_rightMousePseudoButtonKey = Qt::Key_Greater;
 
   //! Rectangle defining the borders of zoomed-in/out data.
   // QCPItemRect *mp_zoomRectItem = nullptr;
 
   // The four lines that are needed to craft the selection rectangle.
   QCPItemLine *mp_selectionRectangeLine1 = nullptr;
   QCPItemLine *mp_selectionRectangeLine2 = nullptr;
   QCPItemLine *mp_selectionRectangeLine3 = nullptr;
   QCPItemLine *mp_selectionRectangeLine4 = nullptr;
 
   //! Text describing the x-axis delta value during a drag operation.
   QCPItemText *mp_xDeltaTextItem = nullptr;
   QCPItemText *mp_yDeltaTextItem = nullptr;
 
   //! Tells if the tracers should be visible.
   bool m_shouldTracersBeVisible = true;
 
   //! Horizontal position tracer
   QCPItemLine *mp_hPosTracerItem = nullptr;
 
   //! Vertical position tracer
   QCPItemLine *mp_vPosTracerItem = nullptr;
 
   //! Vertical selection start tracer (typically in green).
   QCPItemLine *mp_vStartTracerItem = nullptr;
 
   //! Vertical selection end tracer (typically in red).
   QCPItemLine *mp_vEndTracerItem = nullptr /*only vertical*/;
 
   //! Index of the last axis range history item.
   /*!
 
     Each time the user modifies the ranges (x/y axis) during panning or
     zooming of the graph, the new axis ranges are stored in a axis ranges
     history list. This index allows to point to the last range of that
     history.
 
 */
   std::size_t m_lastAxisRangeHistoryIndex = 0;
 
   //! List of x axis ranges occurring during the panning zooming actions.
   std::vector<QCPRange *> m_xAxisRangeHistory;
 
   //! List of y axis ranges occurring during the panning zooming actions.
   std::vector<QCPRange *> m_yAxisRangeHistory;
 
   //! How many mouse move events must be skipped */
   /*!
 
     when the data are so massive that the graph panning becomes sluggish. By
     default, the value is 10 events to be skipped before accounting one. The
     "fat data" mouse movement handler mechanism is actuated by using a
     keyboard key combination. There is no automatic shift between normal
     processing and "fat data" processing.
 
 */
   int m_mouseMoveHandlerSkipAmount = 10;
 
   //! Counter to handle the "fat data" mouse move event handling.
   /*!
 
     \sa m_mouseMoveHandlerSkipAmount.
 
 */
   int m_mouseMoveHandlerSkipCount = 0;
 
   // QColor m_unfocusedColor = QColor(Qt::lightGray);
   // QColor m_unfocusedColor = QColor(230, 230, 230, 255);
 
   //! Color used for the background of unfocused plot.
   QColor m_unfocusedColor = QColor("lightgray");
   //! Color used for the background of unfocused plot.
   QBrush m_unfocusedBrush = QBrush(m_unfocusedColor);
 
   //! Color used for the background of focused plot.
   QColor m_focusedColor = QColor(Qt::transparent);
   //! Color used for the background of focused plot.
   QBrush m_focusedBrush = QBrush(m_focusedColor);
 
   //! Pen used to draw the graph and textual elements in the plot widget.
   QPen m_pen;
 
   virtual void createAllAncillaryItems();
   virtual void updateIntegrationScope(bool for_integration = false);
   virtual void updateIntegrationScopeRect(bool for_integration = false);
   virtual void updateIntegrationScopeHorizontalRhomb(bool for_integration = false);
   virtual void updateIntegrationScopeVerticalRhomb(bool for_integration = false);
   virtual void updateIntegrationScopeRhomb(bool for_integration = false);
   virtual QString allLayerNamesToString() const;
   virtual QString layerableLayerName(QCPLayerable *layerable_p) const;
   virtual int layerableLayerIndex(QCPLayerable *layerable_p) const;
 };
 
 
} // namespace pappso
 
 
Q_DECLARE_METATYPE(pappso::BasePlotContext);
extern int basePlotContextMetaTypeId;
 
Q_DECLARE_METATYPE(pappso::BasePlotContext *);
extern int basePlotContextPtrMetaTypeId;