libpappsomspp
Library for mass spectrometry
pappso::BasePlotWidget Class Reference

#include <baseplotwidget.h>

Inheritance diagram for pappso::BasePlotWidget:
pappso::BaseColorMapPlotWidget pappso::BaseTracePlotWidget pappso::DriftSpecMassSpecColorMapPlotWidget pappso::TicXicChromDriftSpecColorMapPlotWidget pappso::TicXicChromMassSpecColorMapPlotWidget pappso::DriftSpecTracePlotWidget pappso::MassSpecTracePlotWidget pappso::TicXicChromTracePlotWidget

Signals

void setFocusSignal ()
 
void lastCursorHoveredPointSignal (const QPointF &pointf)
 
void plotRangesChangedSignal (const BasePlotContext &context)
 
void xAxisMeasurementSignal (const BasePlotContext &context, bool with_delta)
 
void keyPressEventSignal (const BasePlotContext &context)
 
void keyReleaseEventSignal (const BasePlotContext &context)
 
void mouseReleaseEventSignal (const BasePlotContext &context)
 
void mouseWheelEventSignal (const 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 BasePlotContext &context)
 

Public Member Functions

 BasePlotWidget (QWidget *parent)
 
 BasePlotWidget (QWidget *parent, const QString &x_axis_label, const QString &y_axis_label)
 
virtual ~BasePlotWidget ()
 Destruct this BasePlotWidget instance. More...
 
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)
 
virtual void resetAxesRangeHistory ()
 
virtual void updateAxesRangeHistory ()
 Create new axis range history items and append them to the history. More...
 
virtual void restorePreviousAxesRangeHistory ()
 Go up one history element in the axis history. More...
 
virtual void restoreAxesRangeHistory (std::size_t index)
 Get the axis histories at index index and update the plot ranges. More...
 
virtual void keyPressEvent (QKeyEvent *event)
 KEYBOARD-related EVENTS. More...
 
virtual void keyReleaseEvent (QKeyEvent *event)
 Handle specific key codes and trigger respective actions. More...
 
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)
 
virtual void mousePressHandler (QMouseEvent *event)
 KEYBOARD-related EVENTS. More...
 
virtual void mouseReleaseHandler (QMouseEvent *event)
 
virtual void mouseReleaseHandlerLeftButton ()
 
virtual void mouseReleaseHandlerRightButton ()
 
virtual void mouseWheelHandler (QWheelEvent *event)
 
virtual void mouseMoveHandler (QMouseEvent *event)
 KEYBOARD-related EVENTS. More...
 
virtual void mouseMoveHandlerNotDraggingCursor ()
 
virtual void mouseMoveHandlerDraggingCursor ()
 
virtual void mouseMoveHandlerLeftButtonDraggingCursor ()
 
virtual void mouseMoveHandlerRightButtonDraggingCursor ()
 
virtual void axisDoubleClickHandler (QCPAxis *axis, QCPAxis::SelectablePart part, QMouseEvent *event)
 
bool isClickOntoXAxis (const QPointF &mousePoint)
 
bool isClickOntoYAxis (const QPointF &mousePoint)
 
int dragDirection ()
 MOUSE-related EVENTS. More...
 
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)
 
virtual QCPRange getRangeX (bool &found_range, int index) const
 MOUSE MOVEMENTS mouse/keyboard-triggered. More...
 
virtual QCPRange getRangeY (bool &found_range, int index) const
 
QCPRange getRange (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)
 
virtual void axisRescale ()
 RANGE-related functions. More...
 
virtual void axisReframe ()
 
virtual void axisZoom ()
 
virtual void axisPan ()
 
virtual void replotWithAxesRanges (QCPRange xAxisRange, QCPRange yAxisRange, Axis axis)
 
virtual void replotWithAxisRangeX (double lower, double upper)
 
virtual void replotWithAxisRangeY (double lower, double upper)
 
virtual void hideAllPlotItems ()
 PLOTTING / REPLOTTING functions. More...
 
virtual void showTracers ()
 Show the traces (vertical and horizontal). More...
 
virtual void hideTracers ()
 Hide the traces (vertical and horizontal). More...
 
virtual void drawXDeltaFeatures ()
 
virtual void drawYDeltaFeatures ()
 
virtual void calculateDragDeltas ()
 
virtual bool isVerticalDisplacementAboveThreshold ()
 
virtual void drawSelectionRectangleAndPrepareZoom (bool as_line_segment=false, bool for_integration=false)
 
virtual void updateSelectionRectangle (bool as_line_segment=false, bool for_integration=false)
 
virtual void resetSelectionRectangle ()
 
virtual void hideSelectionRectangle (bool reset_values=false)
 
virtual bool isSelectionRectangleVisible ()
 
virtual PolygonType whatIsVisibleOfTheSelectionRectangle ()
 
virtual void setFocus ()
 PLOT ITEMS : TRACER TEXT ITEMS... More...
 
virtual void redrawPlotBackground (QWidget *focusedPlotWidget)
 Redraw the background of the focusedPlotWidget plot widget. More...
 
virtual void updateContextXandYAxisRanges ()
 
virtual const BasePlotContextgetContext () const
 

Protected Member Functions

virtual void createAllAncillaryItems ()
 
virtual void update1DSelectionRectangle (bool for_integration=false)
 
virtual void update2DSelectionRectangleSquare (bool for_integration=false)
 
virtual void update2DSelectionRectangleSkewed (bool for_integration=false)
 
virtual QString allLayerNamesToString () const
 
virtual QString layerableLayerName (QCPLayerable *layerable_p) const
 
virtual int layerableLayerIndex (QCPLayerable *layerable_p) const
 

Protected Attributes

QString m_name = "NOT_SET"
 Name of the plot widget. More...
 
QString m_desc = "NOT_SET"
 Description of the plot widget. More...
 
QString m_fileName
 The name of the data file from which the mass data were read. More...
 
QString m_axisLabelX
 
QString m_axisLabelY
 
BasePlotContext m_context
 
int m_leftMousePseudoButtonKey = Qt::Key_Less
 
int m_rightMousePseudoButtonKey = Qt::Key_Greater
 
QCPItemLine * mp_selectionRectangeLine1 = nullptr
 Rectangle defining the borders of zoomed-in/out data. More...
 
QCPItemLine * mp_selectionRectangeLine2 = nullptr
 
QCPItemLine * mp_selectionRectangeLine3 = nullptr
 
QCPItemLine * mp_selectionRectangeLine4 = nullptr
 
QCPItemText * mp_xDeltaTextItem = nullptr
 Text describing the x-axis delta value during a drag operation. More...
 
QCPItemText * mp_yDeltaTextItem = nullptr
 
bool m_shouldTracersBeVisible = true
 Tells if the tracers should be visible. More...
 
QCPItemLine * mp_hPosTracerItem = nullptr
 Horizontal position tracer. More...
 
QCPItemLine * mp_vPosTracerItem = nullptr
 Vertical position tracer. More...
 
QCPItemLine * mp_vStartTracerItem = nullptr
 Vertical selection start tracer (typically in green). More...
 
QCPItemLine * mp_vEndTracerItem = nullptr
 Vertical selection end tracer (typically in red). More...
 
std::size_t m_lastAxisRangeHistoryIndex = 0
 Index of the last axis range history item. More...
 
std::vector< QCPRange * > m_xAxisRangeHistory
 List of x axis ranges occurring during the panning zooming actions. More...
 
std::vector< QCPRange * > m_yAxisRangeHistory
 List of y axis ranges occurring during the panning zooming actions. More...
 
int m_mouseMoveHandlerSkipAmount = 10
 How many mouse move events must be skipped *‍/. More...
 
int m_mouseMoveHandlerSkipCount = 0
 Counter to handle the "fat data" mouse move event handling. More...
 
QColor m_unfocusedColor = QColor("lightgray")
 Color used for the background of unfocused plot. More...
 
QBrush m_unfocusedBrush = QBrush(m_unfocusedColor)
 Color used for the background of unfocused plot. More...
 
QColor m_focusedColor = QColor(Qt::transparent)
 Color used for the background of focused plot. More...
 
QBrush m_focusedBrush = QBrush(m_focusedColor)
 Color used for the background of focused plot. More...
 
QPen m_pen
 Pen used to draw the graph and textual elements in the plot widget. More...
 

Detailed Description

Definition at line 66 of file baseplotwidget.h.

Constructor & Destructor Documentation

◆ BasePlotWidget() [1/2]

pappso::BasePlotWidget::BasePlotWidget ( QWidget *  parent)
explicit

Definition at line 49 of file baseplotwidget.cpp.

49 : QCustomPlot(parent)
50{
51 if(parent == nullptr)
52 qFatal("Programming error.");
53
54 // Default settings for the pen used to graph the data.
55 m_pen.setStyle(Qt::SolidLine);
56 m_pen.setBrush(Qt::black);
57 m_pen.setWidth(1);
58
59 // qDebug() << "Created new BasePlotWidget with" << layerCount()
60 //<< "layers before setting up widget.";
61 // qDebug().noquote() << "All layer names:\n" << allLayerNamesToString();
62
63 // As of today 20210313, the QCustomPlot is created with the following 6
64 // layers:
65 //
66 // All layers' name:
67 //
68 // Layer index 0 name: background
69 // Layer index 1 name: grid
70 // Layer index 2 name: main
71 // Layer index 3 name: axes
72 // Layer index 4 name: legend
73 // Layer index 5 name: overlay
74
75 if(!setupWidget())
76 qFatal("Programming error.");
77
78 // Do not call createAllAncillaryItems() in this base class because all the
79 // items will have been created *before* the addition of plots and then the
80 // rendering order will hide them to the viewer, since the rendering order is
81 // according to the order in which the items have been created.
82 //
83 // The fact that the ancillary items are created before trace plots is not a
84 // problem because the trace plots are sparse and do not effectively hide the
85 // data.
86 //
87 // But, in the color map plot widgets, we cannot afford to create the
88 // ancillary items *before* the plot itself because then, the rendering of the
89 // plot (created after) would screen off the ancillary items (created before).
90 //
91 // So, the createAllAncillaryItems() function needs to be called in the
92 // derived classes at the most appropriate moment in the setting up of the
93 // widget.
94 //
95 // All this is only a workaround of a bug in QCustomPlot. See
96 // https://www.qcustomplot.com/index.php/support/forum/2283.
97 //
98 // I initially wanted to have a plots layer on top of the default background
99 // layer and a items layer on top of it. But that setting prevented the
100 // selection of graphs.
101
102 // qDebug() << "Created new BasePlotWidget with" << layerCount()
103 //<< "layers after setting up widget.";
104 // qDebug().noquote() << "All layer names:\n" << allLayerNamesToString();
105
106 show();
107}
virtual bool setupWidget()
QPen m_pen
Pen used to draw the graph and textual elements in the plot widget.

References m_pen, and setupWidget().

◆ BasePlotWidget() [2/2]

pappso::BasePlotWidget::BasePlotWidget ( QWidget *  parent,
const QString &  x_axis_label,
const QString &  y_axis_label 
)
explicit

Definition at line 110 of file baseplotwidget.cpp.

113 : QCustomPlot(parent), m_axisLabelX(x_axis_label), m_axisLabelY(y_axis_label)
114{
115 // qDebug();
116
117 if(parent == nullptr)
118 qFatal("Programming error.");
119
120 // Default settings for the pen used to graph the data.
121 m_pen.setStyle(Qt::SolidLine);
122 m_pen.setBrush(Qt::black);
123 m_pen.setWidth(1);
124
125 xAxis->setLabel(x_axis_label);
126 yAxis->setLabel(y_axis_label);
127
128 // qDebug() << "Created new BasePlotWidget with" << layerCount()
129 //<< "layers before setting up widget.";
130 // qDebug().noquote() << "All layer names:\n" << allLayerNamesToString();
131
132 // As of today 20210313, the QCustomPlot is created with the following 6
133 // layers:
134 //
135 // All layers' name:
136 //
137 // Layer index 0 name: background
138 // Layer index 1 name: grid
139 // Layer index 2 name: main
140 // Layer index 3 name: axes
141 // Layer index 4 name: legend
142 // Layer index 5 name: overlay
143
144 if(!setupWidget())
145 qFatal("Programming error.");
146
147 // qDebug() << "Created new BasePlotWidget with" << layerCount()
148 //<< "layers after setting up widget.";
149 // qDebug().noquote() << "All layer names:\n" << allLayerNamesToString();
150
151 show();
152}

References m_pen, and setupWidget().

◆ ~BasePlotWidget()

pappso::BasePlotWidget::~BasePlotWidget ( )
virtual

Destruct this BasePlotWidget instance.

The destruction involves clearing the history, deleting all the axis range history items for x and y axes.

Definition at line 162 of file baseplotwidget.cpp.

163{
164 // qDebug() << "In the destructor of plot widget:" << this;
165
166 m_xAxisRangeHistory.clear();
167 m_yAxisRangeHistory.clear();
168
169 // Note that the QCustomPlot xxxItem objects are allocated with (this) which
170 // means their destruction is automatically handled upon *this' destruction.
171}
std::vector< QCPRange * > m_yAxisRangeHistory
List of y axis ranges occurring during the panning zooming actions.
std::vector< QCPRange * > m_xAxisRangeHistory
List of x axis ranges occurring during the panning zooming actions.

References m_xAxisRangeHistory, and m_yAxisRangeHistory.

Member Function Documentation

◆ allLayerNamesToString()

QString pappso::BasePlotWidget::allLayerNamesToString ( ) const
protectedvirtual

Definition at line 175 of file baseplotwidget.cpp.

176{
177
178 QString text;
179
180 for(int iter = 0; iter < layerCount(); ++iter)
181 {
182 text +=
183 QString("Layer index %1: %2\n").arg(iter).arg(layer(iter)->name());
184 }
185
186 return text;
187}

◆ axisDoubleClickHandler()

void pappso::BasePlotWidget::axisDoubleClickHandler ( QCPAxis *  axis,
QCPAxis::SelectablePart  part,
QMouseEvent *  event 
)
virtual

Reimplemented in pappso::BaseTracePlotWidget.

Definition at line 1660 of file baseplotwidget.cpp.

1664{
1665 // qDebug();
1666
1667 m_context.m_keyboardModifiers = QGuiApplication::queryKeyboardModifiers();
1668
1669 if(m_context.m_keyboardModifiers & Qt::ControlModifier)
1670 {
1671 // qDebug();
1672
1673 // If the Ctrl modifiers is active, then both axes are to be reset. Also
1674 // the histories are reset also.
1675
1676 rescaleAxes();
1678 }
1679 else
1680 {
1681 // qDebug();
1682
1683 // Only the axis passed as parameter is to be rescaled.
1684 // Reset the range of that axis to the max view possible.
1685
1686 axis->rescale();
1687
1689
1690 event->accept();
1691 }
1692
1693 // The double-click event does not cancel the mouse press event. That is, if
1694 // left-double-clicking, at the end of the operation the button still
1695 // "pressed". We need to remove manually the button from the pressed buttons
1696 // context member.
1697
1698 m_context.m_pressedMouseButtons ^= event->button();
1699
1701
1703
1704 replot();
1705}
Qt::KeyboardModifiers m_keyboardModifiers
Qt::MouseButtons m_pressedMouseButtons
virtual void updateAxesRangeHistory()
Create new axis range history items and append them to the history.
virtual void resetAxesRangeHistory()
virtual void updateContextXandYAxisRanges()
void plotRangesChangedSignal(const BasePlotContext &context)
BasePlotContext m_context

References m_context, pappso::BasePlotContext::m_keyboardModifiers, pappso::BasePlotContext::m_pressedMouseButtons, plotRangesChangedSignal(), resetAxesRangeHistory(), updateAxesRangeHistory(), and updateContextXandYAxisRanges().

Referenced by setupWidget().

◆ axisPan()

void pappso::BasePlotWidget::axisPan ( )
virtual

Reimplemented in pappso::BaseTracePlotWidget.

Definition at line 2178 of file baseplotwidget.cpp.

2179{
2180 qDebug();
2181
2182 // Sanity check
2184 qFatal(
2185 "This function can only be called if the mouse click was on one of the "
2186 "axes");
2187
2189 {
2190 xAxis->setRange(m_context.m_xRange.lower - m_context.m_xDelta,
2192 }
2193
2195 {
2196 yAxis->setRange(m_context.m_yRange.lower - m_context.m_yDelta,
2198 }
2199
2201
2202 // qDebug() << "The updated context:" << m_context.toString();
2203
2204 // We cannot store the new ranges in the history, because the pan operation
2205 // involved a huge quantity of micro-movements elicited upon each mouse move
2206 // cursor event so we would have a huge history.
2207 // updateAxesRangeHistory();
2208
2209 // Now that the context has the right range values, we can emit the
2210 // signal that will be used by this plot widget users, typically to
2211 // abide by the x/y range lock required by the user.
2212
2214
2215 replot();
2216}

References m_context, pappso::BasePlotContext::m_wasClickOnXAxis, pappso::BasePlotContext::m_wasClickOnYAxis, pappso::BasePlotContext::m_xDelta, pappso::BasePlotContext::m_xRange, pappso::BasePlotContext::m_yDelta, pappso::BasePlotContext::m_yRange, plotRangesChangedSignal(), and updateContextXandYAxisRanges().

Referenced by mouseMoveHandlerLeftButtonDraggingCursor().

◆ axisReframe()

void pappso::BasePlotWidget::axisReframe ( )
virtual

Reimplemented in pappso::BaseTracePlotWidget.

Definition at line 2120 of file baseplotwidget.cpp.

2121{
2122
2123 // double sorted_start_drag_point_x =
2124 // std::min(m_context.m_startDragPoint.x(), m_context.m_currentDragPoint.x());
2125
2126 // xAxis->setRange(sorted_start_drag_point_x,
2127 // sorted_start_drag_point_x + fabs(m_context.m_xDelta));
2128
2129 xAxis->setRange(
2131
2132 // Note that the y axis should be rescaled from current lower value to new
2133 // upper value matching the y-axis position of the cursor when the mouse
2134 // button was released.
2135
2136 yAxis->setRange(xAxis->range().lower,
2137 std::max<double>(m_context.m_yRegionRangeStart,
2139
2140 // qDebug() << "xaxis:" << xAxis->range().lower << "-" <<
2141 // xAxis->range().upper
2142 //<< "yaxis:" << yAxis->range().lower << "-" << yAxis->range().upper;
2143
2145
2148
2149 replot();
2150}

References m_context, pappso::BasePlotContext::m_xRegionRangeEnd, pappso::BasePlotContext::m_xRegionRangeStart, pappso::BasePlotContext::m_yRegionRangeEnd, pappso::BasePlotContext::m_yRegionRangeStart, plotRangesChangedSignal(), updateAxesRangeHistory(), and updateContextXandYAxisRanges().

Referenced by mouseReleaseHandlerLeftButton().

◆ axisRescale()

void pappso::BasePlotWidget::axisRescale ( )
virtual

RANGE-related functions.

PLOTTING / REPLOTTING functions

Reimplemented in pappso::BaseTracePlotWidget.

Definition at line 2035 of file baseplotwidget.cpp.

2036{
2037 // Get the current x lower/upper range, that is, leftmost/rightmost x
2038 // coordinate.
2039 double xLower = xAxis->range().lower;
2040 double xUpper = xAxis->range().upper;
2041
2042 // Get the current y lower/upper range, that is, bottommost/topmost y
2043 // coordinate.
2044 double yLower = yAxis->range().lower;
2045 double yUpper = yAxis->range().upper;
2046
2047 // This function is called only when the user has clicked on the x/y axis or
2048 // when the user has dragged the left mouse button with the Ctrl key
2049 // modifier. The m_context.m_wasClickOnXAxis is then simulated in the mouse
2050 // move handler. So we need to test which axis was clicked-on.
2051
2053 {
2054
2055 // We are changing the range of the X axis.
2056
2057 // What is the x delta ?
2058 double xDelta =
2060
2061 // If xDelta is < 0, the we were dragging from right to left, we are
2062 // compressing the view on the x axis, by adding new data to the right
2063 // hand size of the graph. So we add xDelta to the upper bound of the
2064 // range. Otherwise we are uncompressing the view on the x axis and
2065 // remove the xDelta from the upper bound of the range. This is why we
2066 // have the
2067 // '-'
2068 // and not '+' below;
2069
2070 // qDebug() << "Setting xaxis:" << xLower << "--" << xUpper - xDelta;
2071
2072 xAxis->setRange(xLower, xUpper - xDelta);
2073 }
2074 // End of
2075 // if(m_context.m_wasClickOnXAxis)
2076 else // that is, if(m_context.m_wasClickOnYAxis)
2077 {
2078 // We are changing the range of the Y axis.
2079
2080 // What is the y delta ?
2081 double yDelta =
2083
2084 // See above for an explanation of the computation.
2085
2086 yAxis->setRange(yLower, yUpper - yDelta);
2087
2088 // Old version
2089 // if(yDelta < 0)
2090 //{
2091 //// The dragging operation was from top to bottom, we are enlarging
2092 //// the range (thus, we are unzooming the view, since the widget
2093 //// always has the same size).
2094
2095 // yAxis->setRange(yLower, yUpper + fabs(yDelta));
2096 //}
2097 // else
2098 //{
2099 //// The dragging operation was from bottom to top, we are reducing
2100 //// the range (thus, we are zooming the view, since the widget
2101 //// always has the same size).
2102
2103 // yAxis->setRange(yLower, yUpper - fabs(yDelta));
2104 //}
2105 }
2106 // End of
2107 // else // that is, if(m_context.m_wasClickOnYAxis)
2108
2109 // Update the context with the current axes ranges
2110
2112
2114
2115 replot();
2116}

References m_context, pappso::BasePlotContext::m_currentDragPoint, pappso::BasePlotContext::m_startDragPoint, pappso::BasePlotContext::m_wasClickOnXAxis, plotRangesChangedSignal(), and updateContextXandYAxisRanges().

Referenced by mouseMoveHandlerLeftButtonDraggingCursor().

◆ axisZoom()

void pappso::BasePlotWidget::axisZoom ( )
virtual

Reimplemented in pappso::BaseTracePlotWidget.

Definition at line 2154 of file baseplotwidget.cpp.

2155{
2156
2157 // Use the m_context.m_xRegionRangeStart/End values, but we need to sort the
2158 // values before using them, because now we want to really have the lower x
2159 // value. Simply craft a QCPRange that will swap the values if lower is not
2160 // < than upper QCustomPlot calls this normalization).
2161
2162 xAxis->setRange(
2164
2165 yAxis->setRange(
2167
2169
2172
2173 replot();
2174}

References m_context, pappso::BasePlotContext::m_xRegionRangeEnd, pappso::BasePlotContext::m_xRegionRangeStart, pappso::BasePlotContext::m_yRegionRangeEnd, pappso::BasePlotContext::m_yRegionRangeStart, plotRangesChangedSignal(), updateAxesRangeHistory(), and updateContextXandYAxisRanges().

Referenced by mouseReleaseHandlerLeftButton().

◆ calculateDragDeltas()

void pappso::BasePlotWidget::calculateDragDeltas ( )
virtual

Definition at line 2511 of file baseplotwidget.cpp.

2512{
2513
2514 // We compute signed differentials. If the user does not want the sign,
2515 // fabs(double) is their friend.
2516
2517 // Compute the xAxis differential:
2518
2521
2522 // Same with the Y-axis range:
2523
2526
2527 // qDebug() << "xDelta:" << m_context.m_xDelta
2528 //<< "and yDelta:" << m_context.m_yDelta;
2529
2530 return;
2531}

References m_context, pappso::BasePlotContext::m_currentDragPoint, pappso::BasePlotContext::m_startDragPoint, pappso::BasePlotContext::m_xDelta, and pappso::BasePlotContext::m_yDelta.

Referenced by mouseMoveHandlerDraggingCursor().

◆ createAllAncillaryItems()

void pappso::BasePlotWidget::createAllAncillaryItems ( )
protectedvirtual

Definition at line 221 of file baseplotwidget.cpp.

222{
223 // Make a copy of the pen to just change its color and set that color to
224 // the tracer line.
225 QPen pen = m_pen;
226
227 // Create the lines that will act as tracers for position and selection of
228 // regions.
229 //
230 // We have the cross hair that serves as the cursor. That crosshair cursor is
231 // made of a vertical line (green, because when click-dragging the mouse it
232 // becomes the tracer that is being anchored at the region start. The second
233 // line i horizontal and is always black.
234
235 pen.setColor(QColor("steelblue"));
236
237 // The set of tracers (horizontal and vertical) that track the position of the
238 // mouse cursor.
239
240 mp_vPosTracerItem = new QCPItemLine(this);
241 mp_vPosTracerItem->setLayer("plotsLayer");
242 mp_vPosTracerItem->setPen(pen);
243 mp_vPosTracerItem->start->setType(QCPItemPosition::ptPlotCoords);
244 mp_vPosTracerItem->end->setType(QCPItemPosition::ptPlotCoords);
245 mp_vPosTracerItem->start->setCoords(0, 0);
246 mp_vPosTracerItem->end->setCoords(0, 0);
247
248 mp_hPosTracerItem = new QCPItemLine(this);
249 mp_hPosTracerItem->setLayer("plotsLayer");
250 mp_hPosTracerItem->setPen(pen);
251 mp_hPosTracerItem->start->setType(QCPItemPosition::ptPlotCoords);
252 mp_hPosTracerItem->end->setType(QCPItemPosition::ptPlotCoords);
253 mp_hPosTracerItem->start->setCoords(0, 0);
254 mp_hPosTracerItem->end->setCoords(0, 0);
255
256 // The set of tracers (horizontal only) that track the region
257 // spanning/selection regions.
258 //
259 // The start vertical tracer is colored in greeen.
260 pen.setColor(QColor("green"));
261
262 mp_vStartTracerItem = new QCPItemLine(this);
263 mp_vStartTracerItem->setLayer("plotsLayer");
264 mp_vStartTracerItem->setPen(pen);
265 mp_vStartTracerItem->start->setType(QCPItemPosition::ptPlotCoords);
266 mp_vStartTracerItem->end->setType(QCPItemPosition::ptPlotCoords);
267 mp_vStartTracerItem->start->setCoords(0, 0);
268 mp_vStartTracerItem->end->setCoords(0, 0);
269
270 // The end vertical tracer is colored in red.
271 pen.setColor(QColor("red"));
272
273 mp_vEndTracerItem = new QCPItemLine(this);
274 mp_vEndTracerItem->setLayer("plotsLayer");
275 mp_vEndTracerItem->setPen(pen);
276 mp_vEndTracerItem->start->setType(QCPItemPosition::ptPlotCoords);
277 mp_vEndTracerItem->end->setType(QCPItemPosition::ptPlotCoords);
278 mp_vEndTracerItem->start->setCoords(0, 0);
279 mp_vEndTracerItem->end->setCoords(0, 0);
280
281 // When the user click-drags the mouse, the X distance between the drag start
282 // point and the drag end point (current point) is the xDelta.
283 mp_xDeltaTextItem = new QCPItemText(this);
284 mp_xDeltaTextItem->setLayer("plotsLayer");
285 mp_xDeltaTextItem->setColor(QColor("steelblue"));
286 mp_xDeltaTextItem->setPositionAlignment(Qt::AlignBottom | Qt::AlignCenter);
287 mp_xDeltaTextItem->position->setType(QCPItemPosition::ptPlotCoords);
288 mp_xDeltaTextItem->setVisible(false);
289
290 // Same for the y delta
291 mp_yDeltaTextItem = new QCPItemText(this);
292 mp_yDeltaTextItem->setLayer("plotsLayer");
293 mp_yDeltaTextItem->setColor(QColor("steelblue"));
294 mp_yDeltaTextItem->setPositionAlignment(Qt::AlignBottom | Qt::AlignCenter);
295 mp_yDeltaTextItem->position->setType(QCPItemPosition::ptPlotCoords);
296 mp_yDeltaTextItem->setVisible(false);
297
298 // Make sure we prepare the four lines that will be needed to
299 // draw the selection rectangle.
300 pen = m_pen;
301
302 pen.setColor("steelblue");
303
304 mp_selectionRectangeLine1 = new QCPItemLine(this);
305 mp_selectionRectangeLine1->setLayer("plotsLayer");
306 mp_selectionRectangeLine1->setPen(pen);
307 mp_selectionRectangeLine1->start->setType(QCPItemPosition::ptPlotCoords);
308 mp_selectionRectangeLine1->end->setType(QCPItemPosition::ptPlotCoords);
309 mp_selectionRectangeLine1->start->setCoords(0, 0);
310 mp_selectionRectangeLine1->end->setCoords(0, 0);
311 mp_selectionRectangeLine1->setVisible(false);
312
313 mp_selectionRectangeLine2 = new QCPItemLine(this);
314 mp_selectionRectangeLine2->setLayer("plotsLayer");
315 mp_selectionRectangeLine2->setPen(pen);
316 mp_selectionRectangeLine2->start->setType(QCPItemPosition::ptPlotCoords);
317 mp_selectionRectangeLine2->end->setType(QCPItemPosition::ptPlotCoords);
318 mp_selectionRectangeLine2->start->setCoords(0, 0);
319 mp_selectionRectangeLine2->end->setCoords(0, 0);
320 mp_selectionRectangeLine2->setVisible(false);
321
322 mp_selectionRectangeLine3 = new QCPItemLine(this);
323 mp_selectionRectangeLine3->setLayer("plotsLayer");
324 mp_selectionRectangeLine3->setPen(pen);
325 mp_selectionRectangeLine3->start->setType(QCPItemPosition::ptPlotCoords);
326 mp_selectionRectangeLine3->end->setType(QCPItemPosition::ptPlotCoords);
327 mp_selectionRectangeLine3->start->setCoords(0, 0);
328 mp_selectionRectangeLine3->end->setCoords(0, 0);
329 mp_selectionRectangeLine3->setVisible(false);
330
331 mp_selectionRectangeLine4 = new QCPItemLine(this);
332 mp_selectionRectangeLine4->setLayer("plotsLayer");
333 mp_selectionRectangeLine4->setPen(pen);
334 mp_selectionRectangeLine4->start->setType(QCPItemPosition::ptPlotCoords);
335 mp_selectionRectangeLine4->end->setType(QCPItemPosition::ptPlotCoords);
336 mp_selectionRectangeLine4->start->setCoords(0, 0);
337 mp_selectionRectangeLine4->end->setCoords(0, 0);
338 mp_selectionRectangeLine4->setVisible(false);
339}
QCPItemText * mp_yDeltaTextItem
QCPItemLine * mp_selectionRectangeLine1
Rectangle defining the borders of zoomed-in/out data.
QCPItemLine * mp_selectionRectangeLine2
QCPItemText * mp_xDeltaTextItem
Text describing the x-axis delta value during a drag operation.
QCPItemLine * mp_hPosTracerItem
Horizontal position tracer.
QCPItemLine * mp_vPosTracerItem
Vertical position tracer.
QCPItemLine * mp_selectionRectangeLine4
QCPItemLine * mp_vStartTracerItem
Vertical selection start tracer (typically in green).
QCPItemLine * mp_selectionRectangeLine3
QCPItemLine * mp_vEndTracerItem
Vertical selection end tracer (typically in red).

References m_pen, mp_hPosTracerItem, mp_selectionRectangeLine1, mp_selectionRectangeLine2, mp_selectionRectangeLine3, mp_selectionRectangeLine4, mp_vEndTracerItem, mp_vPosTracerItem, mp_vStartTracerItem, mp_xDeltaTextItem, and mp_yDeltaTextItem.

Referenced by pappso::BaseTracePlotWidget::BaseTracePlotWidget(), and pappso::BaseColorMapPlotWidget::addColorMap().

◆ directionKeyPressEvent()

void pappso::BasePlotWidget::directionKeyPressEvent ( QKeyEvent *  event)
virtual

Definition at line 788 of file baseplotwidget.cpp.

789{
790 // qDebug() << "event key:" << event->key();
791
792 // The user is trying to move the positional cursor/markers. There are
793 // multiple way they can do that:
794 //
795 // 1.a. Hitting the arrow left/right keys alone will search for next pixel.
796 // 1.b. Hitting the arrow left/right keys with Alt modifier will search for a
797 // multiple of pixels that might be equivalent to one 20th of the pixel width
798 // of the plot widget.
799 // 1.c Hitting the left/right keys with Alt and Shift modifiers will search
800 // for a multiple of pixels that might be the equivalent to half of the pixel
801 // width.
802 //
803 // 2. Hitting the Control modifier will move the cursor to the next data point
804 // of the graph.
805
806 int pixel_increment = 0;
807
808 if(m_context.m_keyboardModifiers == Qt::NoModifier)
809 pixel_increment = 1;
810 else if(m_context.m_keyboardModifiers == Qt::AltModifier)
811 pixel_increment = 50;
812
813 // The user is moving the positional markers. This is equivalent to a
814 // non-dragging cursor movement to the next pixel. Note that the origin is
815 // located at the top left, so key down increments and key up decrements.
816
817 if(event->key() == Qt::Key_Left)
818 horizontalMoveMouseCursorCountPixels(-pixel_increment);
819 else if(event->key() == Qt::Key_Right)
821 else if(event->key() == Qt::Key_Up)
822 verticalMoveMouseCursorCountPixels(-pixel_increment);
823 else if(event->key() == Qt::Key_Down)
824 verticalMoveMouseCursorCountPixels(pixel_increment);
825
826 event->accept();
827}
virtual void verticalMoveMouseCursorCountPixels(int pixel_count)
virtual void horizontalMoveMouseCursorCountPixels(int pixel_count)

References horizontalMoveMouseCursorCountPixels(), m_context, pappso::BasePlotContext::m_keyboardModifiers, and verticalMoveMouseCursorCountPixels().

Referenced by keyPressEvent().

◆ directionKeyReleaseEvent()

void pappso::BasePlotWidget::directionKeyReleaseEvent ( QKeyEvent *  event)
virtual

Definition at line 831 of file baseplotwidget.cpp.

832{
833 // qDebug() << "event key:" << event->key();
834 event->accept();
835}

Referenced by keyReleaseEvent().

◆ dragDirection()

int pappso::BasePlotWidget::dragDirection ( )

MOUSE-related EVENTS.

MOUSE MOVEMENTS mouse/keyboard-triggered

Definition at line 1767 of file baseplotwidget.cpp.

1768{
1769 // The user is dragging the mouse, probably to rescale the axes, but we need
1770 // to sort out in which direction the drag is happening.
1771
1772 // This function should be called after calculateDragDeltas, so that
1773 // m_context has the proper x/y delta values that we'll compare.
1774
1775 // Note that we cannot compare simply x or y deltas because the y axis might
1776 // have a different scale that the x axis. So we first need to convert the
1777 // positions to pixels.
1778
1779 double x_delta_pixel =
1780 fabs(xAxis->coordToPixel(m_context.m_currentDragPoint.x()) -
1781 xAxis->coordToPixel(m_context.m_startDragPoint.x()));
1782
1783 double y_delta_pixel =
1784 fabs(yAxis->coordToPixel(m_context.m_currentDragPoint.y()) -
1785 yAxis->coordToPixel(m_context.m_startDragPoint.y()));
1786
1787 if(x_delta_pixel > y_delta_pixel)
1788 return Qt::Horizontal;
1789
1790 return Qt::Vertical;
1791}

References m_context, pappso::BasePlotContext::m_currentDragPoint, and pappso::BasePlotContext::m_startDragPoint.

◆ drawSelectionRectangleAndPrepareZoom()

void pappso::BasePlotWidget::drawSelectionRectangleAndPrepareZoom ( bool  as_line_segment = false,
bool  for_integration = false 
)
virtual

Definition at line 2323 of file baseplotwidget.cpp.

2325{
2326 // The user has dragged the mouse left button on the graph, which means he
2327 // is willing to draw a selection rectangle, either for zooming-in or for
2328 // integration.
2329
2330 if(mp_xDeltaTextItem != nullptr)
2331 mp_xDeltaTextItem->setVisible(false);
2332 if(mp_yDeltaTextItem != nullptr)
2333 mp_yDeltaTextItem->setVisible(false);
2334
2335 // Ensure the right selection rectangle is drawn.
2336
2337 updateSelectionRectangle(as_line_segment, for_integration);
2338
2339 // Note that if we draw a zoom rectangle, then we are certainly not
2340 // measuring anything. So set the boolean value to false so that the user of
2341 // this widget or derived classes know that there is nothing to perform upon
2342 // (like deconvolution, for example).
2343
2345
2346 // Also remove the delta value from the pipeline by sending a simple
2347 // distance without measurement signal.
2348
2349 emit xAxisMeasurementSignal(m_context, false);
2350
2351 replot();
2352}
virtual void updateSelectionRectangle(bool as_line_segment=false, bool for_integration=false)
void xAxisMeasurementSignal(const BasePlotContext &context, bool with_delta)

References m_context, pappso::BasePlotContext::m_isMeasuringDistance, mp_xDeltaTextItem, mp_yDeltaTextItem, updateSelectionRectangle(), and xAxisMeasurementSignal().

Referenced by mouseMoveHandlerLeftButtonDraggingCursor(), and mouseMoveHandlerRightButtonDraggingCursor().

◆ drawXDeltaFeatures()

void pappso::BasePlotWidget::drawXDeltaFeatures ( )
virtual

Definition at line 2356 of file baseplotwidget.cpp.

2357{
2358 // The user is dragging the mouse over the graph and we want them to know what
2359 // is the x delta value, that is the span between the point at the start of
2360 // the drag and the current drag position.
2361
2362 // FIXME: is this still true?
2363 //
2364 // We do not want to show the position markers because the only horiontal
2365 // line to be visible must be contained between the start and end vertiacal
2366 // tracer items.
2367 if(mp_hPosTracerItem != nullptr)
2368 mp_hPosTracerItem->setVisible(false);
2369 if(mp_vPosTracerItem != nullptr)
2370 mp_vPosTracerItem->setVisible(false);
2371
2372 // We want to draw the text in the middle position of the leftmost-rightmost
2373 // point, even with skewed rectangle selection.
2374
2375 QPointF leftmost_point = m_context.m_selectionPolygon.getLeftMostPoint();
2376
2377 // qDebug() << "leftmost_point:" << leftmost_point;
2378
2379 QPointF rightmost_point = m_context.m_selectionPolygon.getRightMostPoint();
2380
2381 // qDebug() << "rightmost_point:" << rightmost_point;
2382
2383 double x_axis_center_position =
2384 leftmost_point.x() + (rightmost_point.x() - leftmost_point.x()) / 2;
2385
2386 // qDebug() << "x_axis_center_position:" << x_axis_center_position;
2387
2388 // We want the text to print inside the rectangle, always at the current drag
2389 // point so the eye can follow the delta value while looking where to drag the
2390 // mouse. To position the text inside the rectangle, we need to know what is
2391 // the drag direction.
2392
2393 // Set aside a point instance to store the pixel coordinates of the text.
2394 QPointF pixel_coordinates;
2395
2396 // What is the distance between the rectangle line at current drag point and
2397 // the text itself.
2398 int pixels_away_from_line = 15;
2399
2400 // ATTENTION: the pixel coordinates for the vertical direction go in reverse
2401 // order with respect to the y axis values !!! That is pixel(0,0) is top left
2402 // of the graph.
2403 if(static_cast<int>(m_context.m_dragDirections) &
2404 static_cast<int>(DragDirections::TOP_TO_BOTTOM))
2405 {
2406 // We need to print inside the rectangle, that is pixels_above_line pixels
2407 // to the bottom, so with pixel y value decremented of that
2408 // pixels_above_line value (one would have expected to increment that
2409 // value, along the y axis, but the coordinates in pixel go in reverse
2410 // order).
2411
2412 pixels_away_from_line *= -1;
2413 }
2414
2415 double y_axis_pixel_coordinate =
2416 yAxis->coordToPixel(m_context.m_currentDragPoint.y());
2417
2418 double y_axis_modified_pixel_coordinate =
2419 y_axis_pixel_coordinate + pixels_away_from_line;
2420
2421 pixel_coordinates.setX(x_axis_center_position);
2422 pixel_coordinates.setY(y_axis_modified_pixel_coordinate);
2423
2424 // Now convert back to graph coordinates.
2425
2426 QPointF graph_coordinates(xAxis->pixelToCoord(pixel_coordinates.x()),
2427 yAxis->pixelToCoord(pixel_coordinates.y()));
2428 if(mp_xDeltaTextItem != nullptr)
2429 {
2430 mp_xDeltaTextItem->position->setCoords(x_axis_center_position,
2431 graph_coordinates.y());
2432 mp_xDeltaTextItem->setText(
2433 QString("%1").arg(m_context.m_xDelta, 0, 'f', 3));
2434 mp_xDeltaTextItem->setFont(QFont(font().family(), 9));
2435 mp_xDeltaTextItem->setVisible(true);
2436 }
2437
2438 // Set the boolean to true so that derived widgets know that something is
2439 // being measured, and they can act accordingly, for example by computing
2440 // deconvolutions in a mass spectrum.
2442
2443 replot();
2444
2445 // Let the caller know that we were measuring something.
2447
2448 return;
2449}
SelectionPolygon m_selectionPolygon
DragDirections m_dragDirections
QPointF getRightMostPoint() const
QPointF getLeftMostPoint() const

References pappso::SelectionPolygon::getLeftMostPoint(), pappso::SelectionPolygon::getRightMostPoint(), m_context, pappso::BasePlotContext::m_currentDragPoint, pappso::BasePlotContext::m_dragDirections, pappso::BasePlotContext::m_isMeasuringDistance, pappso::BasePlotContext::m_selectionPolygon, pappso::BasePlotContext::m_xDelta, mp_hPosTracerItem, mp_vPosTracerItem, mp_xDeltaTextItem, pappso::TOP_TO_BOTTOM, and xAxisMeasurementSignal().

Referenced by mouseMoveHandlerLeftButtonDraggingCursor(), mouseMoveHandlerRightButtonDraggingCursor(), and updateSelectionRectangle().

◆ drawYDeltaFeatures()

void pappso::BasePlotWidget::drawYDeltaFeatures ( )
virtual

Definition at line 2453 of file baseplotwidget.cpp.

2454{
2456 return;
2457
2458 // The user is dragging the mouse over the graph and we want them to know what
2459 // is the y delta value, that is the span between the point at the top of
2460 // the selection polygon and the point at its bottom.
2461
2462 // FIXME: is this still true?
2463 //
2464 // We do not want to show the position markers because the only horiontal
2465 // line to be visible must be contained between the start and end vertiacal
2466 // tracer items.
2467 mp_hPosTracerItem->setVisible(false);
2468 mp_vPosTracerItem->setVisible(false);
2469
2470 // We want to draw the text in the middle position of the leftmost-rightmost
2471 // point, even with skewed rectangle selection.
2472
2473 QPointF leftmost_point = m_context.m_selectionPolygon.getLeftMostPoint();
2474 QPointF topmost_point = m_context.m_selectionPolygon.getTopMostPoint();
2475
2476 // qDebug() << "leftmost_point:" << leftmost_point;
2477
2478 QPointF rightmost_point = m_context.m_selectionPolygon.getRightMostPoint();
2479 QPointF bottommost_point = m_context.m_selectionPolygon.getBottomMostPoint();
2480
2481 // qDebug() << "rightmost_point:" << rightmost_point;
2482
2483 double x_axis_center_position =
2484 leftmost_point.x() + (rightmost_point.x() - leftmost_point.x()) / 2;
2485
2486 double y_axis_center_position =
2487 bottommost_point.y() + (topmost_point.y() - bottommost_point.y()) / 2;
2488
2489 // qDebug() << "x_axis_center_position:" << x_axis_center_position;
2490
2491 mp_yDeltaTextItem->position->setCoords(x_axis_center_position,
2492 y_axis_center_position);
2493 mp_yDeltaTextItem->setText(QString("%1").arg(m_context.m_yDelta, 0, 'f', 3));
2494 mp_yDeltaTextItem->setFont(QFont(font().family(), 9));
2495 mp_yDeltaTextItem->setVisible(true);
2496 mp_yDeltaTextItem->setRotation(90);
2497
2498 // Set the boolean to true so that derived widgets know that something is
2499 // being measured, and they can act accordingly, for example by computing
2500 // deconvolutions in a mass spectrum.
2502
2503 replot();
2504
2505 // Let the caller know that we were measuring something.
2507}
QPointF getBottomMostPoint() const

References pappso::SelectionPolygon::getBottomMostPoint(), pappso::SelectionPolygon::getLeftMostPoint(), pappso::SelectionPolygon::getRightMostPoint(), pappso::SelectionPolygon::getTopMostPoint(), pappso::SelectionPolygon::is1D(), m_context, pappso::BasePlotContext::m_isMeasuringDistance, pappso::BasePlotContext::m_selectionPolygon, pappso::BasePlotContext::m_yDelta, mp_hPosTracerItem, mp_vPosTracerItem, mp_yDeltaTextItem, and xAxisMeasurementSignal().

Referenced by mouseMoveHandlerLeftButtonDraggingCursor(), and mouseMoveHandlerRightButtonDraggingCursor().

◆ getContext()

const BasePlotContext & pappso::BasePlotWidget::getContext ( ) const
virtual

Definition at line 3262 of file baseplotwidget.cpp.

3263{
3264 return m_context;
3265}

References m_context.

◆ getInnermostRangeX()

QCPRange pappso::BasePlotWidget::getInnermostRangeX ( bool &  found_range) const
virtual

Definition at line 2000 of file baseplotwidget.cpp.

2001{
2002
2003 return getRange(Axis::x, RangeType::innermost, found_range);
2004}
QCPRange getRange(Axis axis, RangeType range_type, bool &found_range) const

References getRange(), pappso::innermost, and pappso::x.

◆ getInnermostRangeY()

QCPRange pappso::BasePlotWidget::getInnermostRangeY ( bool &  found_range) const
virtual

Definition at line 2015 of file baseplotwidget.cpp.

2016{
2017
2018 return getRange(Axis::y, RangeType::innermost, found_range);
2019}

References getRange(), pappso::innermost, and pappso::y.

◆ getOutermostRangeX()

QCPRange pappso::BasePlotWidget::getOutermostRangeX ( bool &  found_range) const
virtual

Definition at line 2008 of file baseplotwidget.cpp.

2009{
2010 return getRange(Axis::x, RangeType::outermost, found_range);
2011}

References getRange(), pappso::outermost, and pappso::x.

◆ getOutermostRangeY()

QCPRange pappso::BasePlotWidget::getOutermostRangeY ( bool &  found_range) const
virtual

Definition at line 2023 of file baseplotwidget.cpp.

2024{
2025 return getRange(Axis::y, RangeType::outermost, found_range);
2026}

References getRange(), pappso::outermost, and pappso::y.

◆ getPen()

const QPen & pappso::BasePlotWidget::getPen ( ) const
virtual

Definition at line 408 of file baseplotwidget.cpp.

409{
410 return m_pen;
411}

References m_pen.

◆ getPlottingColor() [1/2]

QColor pappso::BasePlotWidget::getPlottingColor ( int  index = 0) const
virtual

Reimplemented in pappso::BaseColorMapPlotWidget.

Definition at line 458 of file baseplotwidget.cpp.

459{
460 QCPGraph *graph_p = graph(index);
461
462 if(graph_p == nullptr)
463 qFatal("Programming error.");
464
465 return getPlottingColor(graph_p);
466}
virtual QColor getPlottingColor(QCPAbstractPlottable *plottable_p) const

References getPlottingColor().

◆ getPlottingColor() [2/2]

QColor pappso::BasePlotWidget::getPlottingColor ( QCPAbstractPlottable *  plottable_p) const
virtual

Definition at line 448 of file baseplotwidget.cpp.

449{
450 if(plottable_p == nullptr)
451 qFatal("Programming error.");
452
453 return plottable_p->pen().color();
454}

Referenced by getPlottingColor().

◆ getRange()

QCPRange pappso::BasePlotWidget::getRange ( Axis  axis,
RangeType  range_type,
bool &  found_range 
) const

Definition at line 1908 of file baseplotwidget.cpp.

1911{
1912
1913 // Iterate in all the graphs in this widget and return a QCPRange that has
1914 // its lower member as the greatest lower value of all
1915 // its upper member as the smallest upper value of all
1916
1917 if(!graphCount())
1918 {
1919 found_range = false;
1920
1921 return QCPRange(0, 1);
1922 }
1923
1924 if(graphCount() == 1)
1925 return graph()->getKeyRange(found_range);
1926
1927 bool found_at_least_one_range = false;
1928
1929 // Create an invalid range.
1930 QCPRange result_range(QCPRange::minRange + 1, QCPRange::maxRange + 1);
1931
1932 for(int iter = 0; iter < graphCount(); ++iter)
1933 {
1934 QCPRange temp_range;
1935
1936 bool found_range_for_iter = false;
1937
1938 QCPGraph *graph_p = graph(iter);
1939
1940 // Depending on the axis param, select the key or value range.
1941
1942 if(axis == Axis::x)
1943 temp_range = graph_p->getKeyRange(found_range_for_iter);
1944 else if(axis == Axis::y)
1945 temp_range = graph_p->getValueRange(found_range_for_iter);
1946 else
1947 qFatal("Cannot reach this point. Programming error.");
1948
1949 // Was a range found for the iterated graph ? If not skip this
1950 // iteration.
1951
1952 if(!found_range_for_iter)
1953 continue;
1954
1955 // While the innermost_range is invalid, we need to seed it with a good
1956 // one. So check this.
1957
1958 if(!QCPRange::validRange(result_range))
1959 qFatal("The obtained range is invalid !");
1960
1961 // At this point we know the obtained range is OK.
1962 result_range = temp_range;
1963
1964 // We found at least one valid range!
1965 found_at_least_one_range = true;
1966
1967 // At this point we have two valid ranges to compare. Depending on
1968 // range_type, we need to perform distinct comparisons.
1969
1970 if(range_type == RangeType::innermost)
1971 {
1972 if(temp_range.lower > result_range.lower)
1973 result_range.lower = temp_range.lower;
1974 if(temp_range.upper < result_range.upper)
1975 result_range.upper = temp_range.upper;
1976 }
1977 else if(range_type == RangeType::outermost)
1978 {
1979 if(temp_range.lower < result_range.lower)
1980 result_range.lower = temp_range.lower;
1981 if(temp_range.upper > result_range.upper)
1982 result_range.upper = temp_range.upper;
1983 }
1984 else
1985 qFatal("Cannot reach this point. Programming error.");
1986
1987 // Continue to next graph, if any.
1988 }
1989 // End of
1990 // for(int iter = 0; iter < graphCount(); ++iter)
1991
1992 // Let the caller know if we found at least one range.
1993 found_range = found_at_least_one_range;
1994
1995 return result_range;
1996}

References pappso::innermost, pappso::outermost, pappso::x, and pappso::y.

Referenced by getInnermostRangeX(), getInnermostRangeY(), getOutermostRangeX(), and getOutermostRangeY().

◆ getRangeX()

QCPRange pappso::BasePlotWidget::getRangeX ( bool &  found_range,
int  index 
) const
virtual

MOUSE MOVEMENTS mouse/keyboard-triggered.

RANGE-related functions

Definition at line 1884 of file baseplotwidget.cpp.

1885{
1886 QCPGraph *graph_p = graph(index);
1887
1888 if(graph_p == nullptr)
1889 qFatal("Programming error.");
1890
1891 return graph_p->getKeyRange(found_range);
1892}

◆ getRangeY()

QCPRange pappso::BasePlotWidget::getRangeY ( bool &  found_range,
int  index 
) const
virtual

Definition at line 1896 of file baseplotwidget.cpp.

1897{
1898 QCPGraph *graph_p = graph(index);
1899
1900 if(graph_p == nullptr)
1901 qFatal("Programming error.");
1902
1903 return graph_p->getValueRange(found_range);
1904}

◆ hideAllPlotItems()

void pappso::BasePlotWidget::hideAllPlotItems ( )
virtual

PLOTTING / REPLOTTING functions.

PLOT ITEMS : TRACER TEXT ITEMS...

PLOT ITEMS : TRACER TEXT ITEMS... Hide the selection line, the xDelta text and the zoom rectangle items.

Definition at line 2273 of file baseplotwidget.cpp.

2274{
2275 mp_xDeltaTextItem->setVisible(false);
2276 mp_yDeltaTextItem->setVisible(false);
2277
2278 // mp_zoomRectItem->setVisible(false);
2280
2281 // Force a replot to make sure the action is immediately visible by the
2282 // user, even without moving the mouse.
2283 replot();
2284}
virtual void hideSelectionRectangle(bool reset_values=false)

References hideSelectionRectangle(), mp_xDeltaTextItem, and mp_yDeltaTextItem.

Referenced by restoreAxesRangeHistory().

◆ hideSelectionRectangle()

void pappso::BasePlotWidget::hideSelectionRectangle ( bool  reset_values = false)
virtual

Definition at line 3137 of file baseplotwidget.cpp.

3138{
3139 mp_selectionRectangeLine1->setVisible(false);
3140 mp_selectionRectangeLine2->setVisible(false);
3141 mp_selectionRectangeLine3->setVisible(false);
3142 mp_selectionRectangeLine4->setVisible(false);
3143
3144 if(reset_values)
3145 {
3147 }
3148}
virtual void resetSelectionRectangle()

References mp_selectionRectangeLine1, mp_selectionRectangeLine2, mp_selectionRectangeLine3, mp_selectionRectangeLine4, and resetSelectionRectangle().

Referenced by hideAllPlotItems(), mouseReleaseHandlerLeftButton(), and mouseReleaseHandlerRightButton().

◆ hideTracers()

void pappso::BasePlotWidget::hideTracers ( )
virtual

Hide the traces (vertical and horizontal).

Definition at line 2307 of file baseplotwidget.cpp.

2308{
2310 mp_hPosTracerItem->setVisible(false);
2311 mp_vPosTracerItem->setVisible(false);
2312
2313 mp_vStartTracerItem->setVisible(false);
2314 mp_vEndTracerItem->setVisible(false);
2315
2316 // Force a replot to make sure the action is immediately visible by the
2317 // user, even without moving the mouse.
2318 replot();
2319}
bool m_shouldTracersBeVisible
Tells if the tracers should be visible.

References m_shouldTracersBeVisible, mp_hPosTracerItem, mp_vEndTracerItem, mp_vPosTracerItem, and mp_vStartTracerItem.

Referenced by keyReleaseEvent().

◆ horizontalGetGraphCoordNewPointCountPixels()

QPointF pappso::BasePlotWidget::horizontalGetGraphCoordNewPointCountPixels ( int  pixel_count)
virtual

Definition at line 1831 of file baseplotwidget.cpp.

1832{
1833 QPointF pixel_coordinates(
1834 xAxis->coordToPixel(m_context.m_lastCursorHoveredPoint.x()) + pixel_count,
1835 yAxis->coordToPixel(m_context.m_lastCursorHoveredPoint.y()));
1836
1837 // Now convert back to local coordinates.
1838
1839 QPointF graph_coordinates(xAxis->pixelToCoord(pixel_coordinates.x()),
1840 yAxis->pixelToCoord(pixel_coordinates.y()));
1841
1842 return graph_coordinates;
1843}

References m_context, and pappso::BasePlotContext::m_lastCursorHoveredPoint.

Referenced by horizontalMoveMouseCursorCountPixels().

◆ horizontalMoveMouseCursorCountPixels()

void pappso::BasePlotWidget::horizontalMoveMouseCursorCountPixels ( int  pixel_count)
virtual

Definition at line 1815 of file baseplotwidget.cpp.

1816{
1817 QPointF graph_coord = horizontalGetGraphCoordNewPointCountPixels(pixel_count);
1818
1819 QPointF pixel_coord(xAxis->coordToPixel(graph_coord.x()),
1820 yAxis->coordToPixel(graph_coord.y()));
1821
1822 // Now we need ton convert the new coordinates to the global position system
1823 // and to move the cursor to that new position. That will create an event to
1824 // move the mouse cursor.
1825
1826 moveMouseCursorPixelCoordToGlobal(pixel_coord.toPoint());
1827}
virtual void moveMouseCursorPixelCoordToGlobal(QPointF local_coordinates)
virtual QPointF horizontalGetGraphCoordNewPointCountPixels(int pixel_count)

References horizontalGetGraphCoordNewPointCountPixels(), and moveMouseCursorPixelCoordToGlobal().

Referenced by directionKeyPressEvent().

◆ integrationRequestedSignal

void pappso::BasePlotWidget::integrationRequestedSignal ( const BasePlotContext context)
signal

◆ isClickOntoXAxis()

bool pappso::BasePlotWidget::isClickOntoXAxis ( const QPointF &  mousePoint)

Definition at line 1709 of file baseplotwidget.cpp.

1710{
1711 QCPLayoutElement *layoutElement = layoutElementAt(mousePoint);
1712
1713 if(layoutElement &&
1714 layoutElement == dynamic_cast<QCPLayoutElement *>(axisRect()))
1715 {
1716 // The graph is *inside* the axisRect that is the outermost envelope of
1717 // the graph. Thus, if we want to know if the click was indeed on an
1718 // axis, we need to check what selectable part of the the axisRect we
1719 // were
1720 // clicking:
1721 QCPAxis::SelectablePart selectablePart;
1722
1723 selectablePart = xAxis->getPartAt(mousePoint);
1724
1725 if(selectablePart == QCPAxis::spAxisLabel ||
1726 selectablePart == QCPAxis::spAxis ||
1727 selectablePart == QCPAxis::spTickLabels)
1728 return true;
1729 }
1730
1731 return false;
1732}

Referenced by mousePressHandler().

◆ isClickOntoYAxis()

bool pappso::BasePlotWidget::isClickOntoYAxis ( const QPointF &  mousePoint)

Definition at line 1736 of file baseplotwidget.cpp.

1737{
1738 QCPLayoutElement *layoutElement = layoutElementAt(mousePoint);
1739
1740 if(layoutElement &&
1741 layoutElement == dynamic_cast<QCPLayoutElement *>(axisRect()))
1742 {
1743 // The graph is *inside* the axisRect that is the outermost envelope of
1744 // the graph. Thus, if we want to know if the click was indeed on an
1745 // axis, we need to check what selectable part of the the axisRect we
1746 // were
1747 // clicking:
1748 QCPAxis::SelectablePart selectablePart;
1749
1750 selectablePart = yAxis->getPartAt(mousePoint);
1751
1752 if(selectablePart == QCPAxis::spAxisLabel ||
1753 selectablePart == QCPAxis::spAxis ||
1754 selectablePart == QCPAxis::spTickLabels)
1755 return true;
1756 }
1757
1758 return false;
1759}

Referenced by mousePressHandler().

◆ isSelectionRectangleVisible()

bool pappso::BasePlotWidget::isSelectionRectangleVisible ( )
virtual

Definition at line 3194 of file baseplotwidget.cpp.

3195{
3196 // Sanity check
3197 int check = 0;
3198
3199 check += mp_selectionRectangeLine1->visible();
3200 check += mp_selectionRectangeLine2->visible();
3201 check += mp_selectionRectangeLine3->visible();
3202 check += mp_selectionRectangeLine4->visible();
3203
3204 if(check > 0)
3205 return true;
3206
3207 return false;
3208}

References mp_selectionRectangeLine1, mp_selectionRectangeLine2, mp_selectionRectangeLine3, and mp_selectionRectangeLine4.

◆ isVerticalDisplacementAboveThreshold()

bool pappso::BasePlotWidget::isVerticalDisplacementAboveThreshold ( )
virtual

Definition at line 2535 of file baseplotwidget.cpp.

2536{
2537 // First get the height of the plot.
2538 double plotHeight = yAxis->range().upper - yAxis->range().lower;
2539
2540 double heightDiff =
2542
2543 double heightDiffRatio = (heightDiff / plotHeight) * 100;
2544
2545 if(heightDiffRatio > 10)
2546 {
2547 // qDebug() << "isVerticalDisplacementAboveThreshold: true";
2548 return true;
2549 }
2550
2551 // qDebug() << "isVerticalDisplacementAboveThreshold: false";
2552 return false;
2553}

References m_context, pappso::BasePlotContext::m_currentDragPoint, and pappso::BasePlotContext::m_startDragPoint.

Referenced by mouseMoveHandlerLeftButtonDraggingCursor(), and mouseMoveHandlerRightButtonDraggingCursor().

◆ keyPressEvent()

void pappso::BasePlotWidget::keyPressEvent ( QKeyEvent *  event)
virtual

KEYBOARD-related EVENTS.

Reimplemented in pappso::DriftSpecMassSpecColorMapPlotWidget, pappso::DriftSpecTracePlotWidget, pappso::MassSpecTracePlotWidget, pappso::TicXicChromDriftSpecColorMapPlotWidget, pappso::TicXicChromMassSpecColorMapPlotWidget, and pappso::TicXicChromTracePlotWidget.

Definition at line 619 of file baseplotwidget.cpp.

620{
621 // qDebug() << "ENTER";
622
623 // We need this because some keys modify our behaviour.
624 m_context.m_pressedKeyCode = event->key();
625 m_context.m_keyboardModifiers = QGuiApplication::queryKeyboardModifiers();
626
627 if(event->key() == Qt::Key_Left || event->key() == Qt::Key_Right ||
628 event->key() == Qt::Key_Up || event->key() == Qt::Key_Down)
629 {
630 return directionKeyPressEvent(event);
631 }
632 else if(event->key() == m_leftMousePseudoButtonKey ||
633 event->key() == m_rightMousePseudoButtonKey)
634 {
635 return mousePseudoButtonKeyPressEvent(event);
636 }
637
638 // Do not do anything here, because this function is used by derived classes
639 // that will emit the signal below. Otherwise there are going to be multiple
640 // signals sent.
641 // qDebug() << "Going to emit keyPressEventSignal(m_context);";
642 // emit keyPressEventSignal(m_context);
643}
virtual void mousePseudoButtonKeyPressEvent(QKeyEvent *event)
virtual void directionKeyPressEvent(QKeyEvent *event)

References directionKeyPressEvent(), m_context, pappso::BasePlotContext::m_keyboardModifiers, m_leftMousePseudoButtonKey, pappso::BasePlotContext::m_pressedKeyCode, m_rightMousePseudoButtonKey, and mousePseudoButtonKeyPressEvent().

Referenced by pappso::DriftSpecMassSpecColorMapPlotWidget::keyPressEvent(), pappso::DriftSpecTracePlotWidget::keyPressEvent(), pappso::MassSpecTracePlotWidget::keyPressEvent(), pappso::TicXicChromDriftSpecColorMapPlotWidget::keyPressEvent(), pappso::TicXicChromMassSpecColorMapPlotWidget::keyPressEvent(), and pappso::TicXicChromTracePlotWidget::keyPressEvent().

◆ keyPressEventSignal

void pappso::BasePlotWidget::keyPressEventSignal ( const BasePlotContext context)
signal

◆ keyReleaseEvent()

void pappso::BasePlotWidget::keyReleaseEvent ( QKeyEvent *  event)
virtual

Handle specific key codes and trigger respective actions.

Reimplemented in pappso::DriftSpecMassSpecColorMapPlotWidget, pappso::DriftSpecTracePlotWidget, pappso::MassSpecTracePlotWidget, pappso::TicXicChromDriftSpecColorMapPlotWidget, pappso::TicXicChromMassSpecColorMapPlotWidget, and pappso::TicXicChromTracePlotWidget.

Definition at line 648 of file baseplotwidget.cpp.

649{
650 m_context.m_releasedKeyCode = event->key();
651
652 // The keyboard key is being released, set the key code to 0.
654
655 m_context.m_keyboardModifiers = QGuiApplication::queryKeyboardModifiers();
656
657 // Now test if the key that was released is one of the housekeeping keys.
658 if(event->key() == Qt::Key_Backspace)
659 {
660 // qDebug();
661
662 // The user wants to iterate back in the x/y axis range history.
664
665 event->accept();
666 }
667 else if(event->key() == Qt::Key_Space)
668 {
669 return spaceKeyReleaseEvent(event);
670 }
671 else if(event->key() == Qt::Key_Delete)
672 {
673 // The user wants to delete a graph. What graph is to be determined
674 // programmatically:
675
676 // If there is a single graph, then that is the graph to be removed.
677 // If there are more than one graph, then only the ones that are selected
678 // are to be removed.
679
680 // Note that the user of this widget might want to provide the user with
681 // the ability to specify if all the children graph needs to be removed
682 // also. This can be coded in key modifiers. So provide the context.
683
684 int graph_count = plottableCount();
685
686 if(!graph_count)
687 {
688 // qDebug() << "Not a single graph in the plot widget. Doing
689 // nothing.";
690
691 event->accept();
692 return;
693 }
694
695 if(graph_count == 1)
696 {
697 // qDebug() << "A single graph is in the plot widget. Emitting a graph
698 // " "destruction requested signal for it:"
699 //<< graph();
700
702 }
703 else
704 {
705 // At this point we know there are more than one graph in the plot
706 // widget. We need to get the selected one (if any).
707 QList<QCPGraph *> selected_graph_list;
708
709 selected_graph_list = selectedGraphs();
710
711 if(!selected_graph_list.size())
712 {
713 event->accept();
714 return;
715 }
716
717 // qDebug() << "Number of selected graphs to be destrobyed:"
718 //<< selected_graph_list.size();
719
720 for(int iter = 0; iter < selected_graph_list.size(); ++iter)
721 {
722 // qDebug()
723 //<< "Emitting a graph destruction requested signal for graph:"
724 //<< selected_graph_list.at(iter);
725
727 this, selected_graph_list.at(iter), m_context);
728
729 // We do not do this, because we want the slot called by the
730 // signal above to handle that removal. Remember that it is not
731 // possible to delete graphs manually.
732 //
733 // removeGraph(selected_graph_list.at(iter));
734 }
735 event->accept();
736 }
737 }
738 // End of
739 // else if(event->key() == Qt::Key_Delete)
740 else if(event->key() == Qt::Key_T)
741 {
742 // The user wants to toggle the visibiity of the tracers.
744
746 hideTracers();
747 else
748 showTracers();
749
750 event->accept();
751 }
752 else if(event->key() == Qt::Key_Left || event->key() == Qt::Key_Right ||
753 event->key() == Qt::Key_Up || event->key() == Qt::Key_Down)
754 {
755 return directionKeyReleaseEvent(event);
756 }
757 else if(event->key() == m_leftMousePseudoButtonKey ||
758 event->key() == m_rightMousePseudoButtonKey)
759 {
761 }
762 else if(event->key() == Qt::Key_S)
763 {
764 // The user has asked to measure the horizontal size of the rectangle and
765 // to start making a skewed selection rectangle.
766
769
770 // qDebug() << "Set m_context.selectRectangleWidth to"
771 //<< m_context.m_selectRectangleWidth << "upon release of S key";
772 }
773 // At this point emit the signal, since we did not treat it. Maybe the
774 // consumer widget wants to know that the keyboard key was released.
775
777}
virtual void directionKeyReleaseEvent(QKeyEvent *event)
void plottableDestructionRequestedSignal(BasePlotWidget *base_plot_widget_p, QCPAbstractPlottable *plottable_p, const BasePlotContext &context)
virtual void spaceKeyReleaseEvent(QKeyEvent *event)
virtual void showTracers()
Show the traces (vertical and horizontal).
void keyReleaseEventSignal(const BasePlotContext &context)
virtual void restorePreviousAxesRangeHistory()
Go up one history element in the axis history.
virtual void hideTracers()
Hide the traces (vertical and horizontal).
virtual void mousePseudoButtonKeyReleaseEvent(QKeyEvent *event)

References directionKeyReleaseEvent(), hideTracers(), keyReleaseEventSignal(), m_context, pappso::BasePlotContext::m_currentDragPoint, pappso::BasePlotContext::m_keyboardModifiers, m_leftMousePseudoButtonKey, pappso::BasePlotContext::m_pressedKeyCode, pappso::BasePlotContext::m_releasedKeyCode, m_rightMousePseudoButtonKey, pappso::BasePlotContext::m_selectRectangleWidth, m_shouldTracersBeVisible, pappso::BasePlotContext::m_startDragPoint, mousePseudoButtonKeyReleaseEvent(), plottableDestructionRequestedSignal(), restorePreviousAxesRangeHistory(), showTracers(), and spaceKeyReleaseEvent().

Referenced by pappso::DriftSpecMassSpecColorMapPlotWidget::keyReleaseEvent(), pappso::DriftSpecTracePlotWidget::keyReleaseEvent(), pappso::MassSpecTracePlotWidget::keyReleaseEvent(), pappso::TicXicChromDriftSpecColorMapPlotWidget::keyReleaseEvent(), pappso::TicXicChromMassSpecColorMapPlotWidget::keyReleaseEvent(), and pappso::TicXicChromTracePlotWidget::keyReleaseEvent().

◆ keyReleaseEventSignal

void pappso::BasePlotWidget::keyReleaseEventSignal ( const BasePlotContext context)
signal

Referenced by keyReleaseEvent().

◆ lastCursorHoveredPointSignal

void pappso::BasePlotWidget::lastCursorHoveredPointSignal ( const QPointF &  pointf)
signal

◆ layerableLayerIndex()

int pappso::BasePlotWidget::layerableLayerIndex ( QCPLayerable *  layerable_p) const
protectedvirtual

Definition at line 203 of file baseplotwidget.cpp.

204{
205 if(layerable_p == nullptr)
206 qFatal("Programming error.");
207
208 QCPLayer *layer_p = layerable_p->layer();
209
210 for(int iter = 0; iter < layerCount(); ++iter)
211 {
212 if(layer(iter) == layer_p)
213 return iter;
214 }
215
216 return -1;
217}

◆ layerableLayerName()

QString pappso::BasePlotWidget::layerableLayerName ( QCPLayerable *  layerable_p) const
protectedvirtual

Definition at line 191 of file baseplotwidget.cpp.

192{
193 if(layerable_p == nullptr)
194 qFatal("Programming error.");
195
196 QCPLayer *layer_p = layerable_p->layer();
197
198 return layer_p->name();
199}

◆ mouseMoveHandler()

void pappso::BasePlotWidget::mouseMoveHandler ( QMouseEvent *  event)
virtual

KEYBOARD-related EVENTS.

MOUSE-related EVENTS

Reimplemented in pappso::DriftSpecMassSpecColorMapPlotWidget, pappso::DriftSpecTracePlotWidget, pappso::MassSpecTracePlotWidget, pappso::TicXicChromDriftSpecColorMapPlotWidget, pappso::TicXicChromMassSpecColorMapPlotWidget, and pappso::TicXicChromTracePlotWidget.

Definition at line 914 of file baseplotwidget.cpp.

915{
916
917 // If we have no focus, then get it. See setFocus() to understand why asking
918 // for focus is cosly and thus why we want to make this decision first.
919 if(!hasFocus())
920 setFocus();
921
922 qDebug() << (graph() != nullptr);
923 // if(graph(0) != nullptr)
924 // { // check if the widget contains some graphs
925
926 // The event->button() must be by Qt instructions considered to be 0.
927
928 // Whatever happens, we want to store the plot coordinates of the current
929 // mouse cursor position (will be useful later for countless needs).
930
931 // Fix from Qt5 to Qt6
932 // QPointF mousePoint = event->localPos();
933 QPointF mousePoint = event->position();
934 qDebug();
935 qDebug() << "local mousePoint position in pixels:" << mousePoint;
936
937 m_context.m_lastCursorHoveredPoint.setX(xAxis->pixelToCoord(mousePoint.x()));
938 qDebug();
939 m_context.m_lastCursorHoveredPoint.setY(yAxis->pixelToCoord(mousePoint.y()));
940 qDebug();
941
942 // qDebug() << "lastCursorHoveredPoint coord:"
943 //<< m_context.lastCursorHoveredPoint;
944
945 // Now, depending on the button(s) (if any) that are pressed or not, we
946 // have a different processing.
947
948 qDebug();
949 if(m_context.m_pressedMouseButtons & Qt::LeftButton ||
950 m_context.m_pressedMouseButtons & Qt::RightButton)
952 else
954 // }
955 qDebug();
956 event->accept();
957}
virtual void mouseMoveHandlerDraggingCursor()
virtual void mouseMoveHandlerNotDraggingCursor()
virtual void setFocus()
PLOT ITEMS : TRACER TEXT ITEMS...

References m_context, pappso::BasePlotContext::m_lastCursorHoveredPoint, pappso::BasePlotContext::m_pressedMouseButtons, mouseMoveHandlerDraggingCursor(), mouseMoveHandlerNotDraggingCursor(), and setFocus().

Referenced by pappso::DriftSpecMassSpecColorMapPlotWidget::mouseMoveHandler(), pappso::DriftSpecTracePlotWidget::mouseMoveHandler(), pappso::MassSpecTracePlotWidget::mouseMoveHandler(), pappso::TicXicChromDriftSpecColorMapPlotWidget::mouseMoveHandler(), pappso::TicXicChromMassSpecColorMapPlotWidget::mouseMoveHandler(), pappso::TicXicChromTracePlotWidget::mouseMoveHandler(), and setupWidget().

◆ mouseMoveHandlerDraggingCursor()

void pappso::BasePlotWidget::mouseMoveHandlerDraggingCursor ( )
virtual

Reimplemented in pappso::DriftSpecMassSpecColorMapPlotWidget, pappso::DriftSpecTracePlotWidget, pappso::MassSpecTracePlotWidget, pappso::TicXicChromDriftSpecColorMapPlotWidget, pappso::TicXicChromMassSpecColorMapPlotWidget, and pappso::TicXicChromTracePlotWidget.

Definition at line 1025 of file baseplotwidget.cpp.

1026{
1027 qDebug();
1029
1030 // Now store the mouse position data into the the current drag point
1031 // member datum, that will be used in countless occasions later.
1033 m_context.m_keyboardModifiers = QGuiApplication::queryKeyboardModifiers();
1034
1035 // When we drag (either keyboard or mouse), we hide the position markers
1036 // (black) and we show the start and end vertical markers for the region.
1037 // Then, we draw the horizontal region range marker that delimits
1038 // horizontally the dragged-over region.
1039
1040 if(mp_hPosTracerItem != nullptr)
1041 mp_hPosTracerItem->setVisible(false);
1042 if(mp_vPosTracerItem != nullptr)
1043 mp_vPosTracerItem->setVisible(false);
1044
1045 // Only bother with the tracers if the user wants them to be visible.
1047 {
1048
1049 // The vertical end tracer position must be refreshed.
1050 mp_vEndTracerItem->start->setCoords(m_context.m_currentDragPoint.x(),
1051 yAxis->range().upper);
1052
1054 yAxis->range().lower);
1055
1056 mp_vEndTracerItem->setVisible(true);
1057 }
1058
1059 // Whatever the button, when we are dealing with the axes, we do not
1060 // want to show any of the tracers.
1061
1063 {
1064 qDebug();
1065 if(mp_hPosTracerItem != nullptr)
1066 mp_hPosTracerItem->setVisible(false);
1067 if(mp_vPosTracerItem != nullptr)
1068 mp_vPosTracerItem->setVisible(false);
1069
1070 if(mp_vStartTracerItem != nullptr)
1071 mp_vStartTracerItem->setVisible(false);
1072 if(mp_vEndTracerItem != nullptr)
1073 mp_vEndTracerItem->setVisible(false);
1074 }
1075 else
1076 {
1077 qDebug();
1078 // Since we are not dragging the mouse cursor over the axes, make sure
1079 // we store the drag directions in the context, as this might be
1080 // useful for later operations.
1081
1083
1084 // qDebug() << m_context.toString();
1085 }
1086
1087 // Because when we drag the mouse button (whatever the button) we need to
1088 // know what is the drag delta (distance between start point and current
1089 // point of the drag operation) on both axes, ask that these x|y deltas be
1090 // computed.
1091 qDebug();
1093
1094 // Now deal with the BUTTON-SPECIFIC CODE.
1095
1096 if(m_context.m_mouseButtonsAtMousePress & Qt::LeftButton)
1097 {
1098 qDebug();
1100 }
1101 else if(m_context.m_mouseButtonsAtMousePress & Qt::RightButton)
1102 {
1103 qDebug();
1105 }
1106
1107 qDebug();
1108}
Qt::MouseButtons m_mouseButtonsAtMousePress
DragDirections recordDragDirections()
virtual void mouseMoveHandlerLeftButtonDraggingCursor()
virtual void calculateDragDeltas()
virtual void mouseMoveHandlerRightButtonDraggingCursor()

References calculateDragDeltas(), m_context, pappso::BasePlotContext::m_currentDragPoint, pappso::BasePlotContext::m_isMouseDragging, pappso::BasePlotContext::m_keyboardModifiers, pappso::BasePlotContext::m_lastCursorHoveredPoint, pappso::BasePlotContext::m_mouseButtonsAtMousePress, m_shouldTracersBeVisible, pappso::BasePlotContext::m_wasClickOnXAxis, pappso::BasePlotContext::m_wasClickOnYAxis, mouseMoveHandlerLeftButtonDraggingCursor(), mouseMoveHandlerRightButtonDraggingCursor(), mp_hPosTracerItem, mp_vEndTracerItem, mp_vPosTracerItem, mp_vStartTracerItem, and pappso::BasePlotContext::recordDragDirections().

Referenced by mouseMoveHandler(), pappso::DriftSpecMassSpecColorMapPlotWidget::mouseMoveHandlerDraggingCursor(), pappso::DriftSpecTracePlotWidget::mouseMoveHandlerDraggingCursor(), pappso::MassSpecTracePlotWidget::mouseMoveHandlerDraggingCursor(), pappso::TicXicChromDriftSpecColorMapPlotWidget::mouseMoveHandlerDraggingCursor(), pappso::TicXicChromMassSpecColorMapPlotWidget::mouseMoveHandlerDraggingCursor(), and pappso::TicXicChromTracePlotWidget::mouseMoveHandlerDraggingCursor().

◆ mouseMoveHandlerLeftButtonDraggingCursor()

void pappso::BasePlotWidget::mouseMoveHandlerLeftButtonDraggingCursor ( )
virtual

Definition at line 1112 of file baseplotwidget.cpp.

1113{
1114 qDebug() << "the left button is dragging.";
1115
1116 // Set the context.m_isMeasuringDistance to false, which later might be set to
1117 // true if effectively we are measuring a distance. This is required because
1118 // the derived widget classes might want to know if they have to perform
1119 // some action on the basis that context is measuring a distance, for
1120 // example the mass spectrum-specific widget might want to compute
1121 // deconvolutions.
1122
1124
1125 // Let's first check if the mouse drag operation originated on either
1126 // axis. In that case, the user is performing axis reframing or rescaling.
1127
1129 {
1130 qDebug() << "Click was on one of the axes.";
1131
1132 if(m_context.m_keyboardModifiers & Qt::ControlModifier)
1133 {
1134 // The user is asking a rescale of the plot.
1135
1136 // We know that we do not want the tracers when we perform axis
1137 // rescaling operations.
1138
1139 if(mp_hPosTracerItem != nullptr)
1140 mp_hPosTracerItem->setVisible(false);
1141 if(mp_vPosTracerItem != nullptr)
1142 mp_vPosTracerItem->setVisible(false);
1143
1144 if(mp_vStartTracerItem != nullptr)
1145 mp_vStartTracerItem->setVisible(false);
1146 if(mp_vEndTracerItem != nullptr)
1147 mp_vEndTracerItem->setVisible(false);
1148
1149 // This operation is particularly intensive, thus we want to
1150 // reduce the number of calculations by skipping this calculation
1151 // a number of times. The user can ask for this feature by
1152 // clicking the 'Q' letter.
1153
1154 if(m_context.m_pressedKeyCode == Qt::Key_Q)
1155 {
1157 {
1159 return;
1160 }
1161 else
1162 {
1164 }
1165 }
1166
1167 qDebug() << "Asking that the axes be rescaled.";
1168
1169 axisRescale();
1170 }
1171 else
1172 {
1173 // The user was simply dragging the axis. Just pan, that is slide
1174 // the plot in the same direction as the mouse movement and with the
1175 // same amplitude.
1176
1177 qDebug() << "Asking that the axes be panned.";
1178
1179 axisPan();
1180 }
1181
1182 return;
1183 }
1184
1185 // At this point we understand that the user was not performing any
1186 // panning/rescaling operation by clicking on any one of the axes.. Go on
1187 // with other possibilities.
1188
1189 // Let's check if the user is actually drawing a rectangle (covering a
1190 // real area) or is drawing a line.
1191
1192 // qDebug() << "The mouse dragging did not originate on an axis.";
1193
1195 {
1196 qDebug() << "Apparently the selection is a real rectangle.";
1197
1198 // When we draw a rectangle the tracers are of no use.
1199
1200 if(mp_hPosTracerItem != nullptr)
1201 mp_hPosTracerItem->setVisible(false);
1202 if(mp_vPosTracerItem != nullptr)
1203 mp_vPosTracerItem->setVisible(false);
1204
1205 if(mp_vStartTracerItem != nullptr)
1206 mp_vStartTracerItem->setVisible(false);
1207 if(mp_vEndTracerItem != nullptr)
1208 mp_vEndTracerItem->setVisible(false);
1209
1210 // Draw the rectangle, false, not as line segment and
1211 // false, not for integration
1213
1214 // Draw the selection width/height text
1217
1218 // qDebug() << "The selection polygon:"
1219 //<< m_context.m_selectionPolygon.toString();
1220 }
1221 else
1222 {
1223 qDebug() << "Apparently we are measuring a delta.";
1224
1225 // Draw the rectangle, true, as line segment and
1226 // false, not for integration
1228
1229 // qDebug() << "The selection polygon:"
1230 //<< m_context.m_selectionPolygon.toString();
1231
1232 // The pure position tracers should be hidden.
1233 if(mp_hPosTracerItem != nullptr)
1234 mp_hPosTracerItem->setVisible(true);
1235 if(mp_vPosTracerItem != nullptr)
1236 mp_vPosTracerItem->setVisible(true);
1237
1238 // Then, make sure the region range vertical tracers are visible.
1239 if(mp_vStartTracerItem != nullptr)
1240 mp_vStartTracerItem->setVisible(true);
1241 if(mp_vEndTracerItem != nullptr)
1242 mp_vEndTracerItem->setVisible(true);
1243
1244 // Draw the selection width text
1246 }
1247 qDebug();
1248}
int m_mouseMoveHandlerSkipAmount
How many mouse move events must be skipped *‍/.
virtual void drawSelectionRectangleAndPrepareZoom(bool as_line_segment=false, bool for_integration=false)
int m_mouseMoveHandlerSkipCount
Counter to handle the "fat data" mouse move event handling.
virtual void drawYDeltaFeatures()
virtual bool isVerticalDisplacementAboveThreshold()
virtual void drawXDeltaFeatures()
virtual void axisRescale()
RANGE-related functions.

References axisPan(), axisRescale(), drawSelectionRectangleAndPrepareZoom(), drawXDeltaFeatures(), drawYDeltaFeatures(), isVerticalDisplacementAboveThreshold(), m_context, pappso::BasePlotContext::m_isMeasuringDistance, pappso::BasePlotContext::m_keyboardModifiers, m_mouseMoveHandlerSkipAmount, m_mouseMoveHandlerSkipCount, pappso::BasePlotContext::m_pressedKeyCode, pappso::BasePlotContext::m_wasClickOnXAxis, pappso::BasePlotContext::m_wasClickOnYAxis, mp_hPosTracerItem, mp_vEndTracerItem, mp_vPosTracerItem, and mp_vStartTracerItem.

Referenced by mouseMoveHandlerDraggingCursor().

◆ mouseMoveHandlerNotDraggingCursor()

void pappso::BasePlotWidget::mouseMoveHandlerNotDraggingCursor ( )
virtual

Reimplemented in pappso::DriftSpecMassSpecColorMapPlotWidget, pappso::DriftSpecTracePlotWidget, pappso::MassSpecTracePlotWidget, pappso::TicXicChromDriftSpecColorMapPlotWidget, pappso::TicXicChromMassSpecColorMapPlotWidget, and pappso::TicXicChromTracePlotWidget.

Definition at line 961 of file baseplotwidget.cpp.

962{
963
964 qDebug();
966
967 qDebug();
968 // We are not dragging the mouse (no button pressed), simply let this
969 // widget's consumer know the position of the cursor and update the markers.
970 // The consumer of this widget will update mouse cursor position at
971 // m_context.m_lastCursorHoveredPoint if so needed.
972
974
975 qDebug();
976
977 // We are not dragging, so we do not show the region end tracer we only
978 // show the anchoring start trace that might be of use if the user starts
979 // using the arrow keys to move the cursor.
980 if(mp_vEndTracerItem != nullptr)
981 mp_vEndTracerItem->setVisible(false);
982
983 qDebug();
984 // Only bother with the tracers if the user wants them to be visible.
985 // Their crossing point must be exactly at the last cursor-hovered point.
986
988 {
989 // We are not dragging, so only show the position markers (v and h);
990
991 qDebug();
992 if(mp_hPosTracerItem != nullptr)
993 {
994 // Horizontal position tracer.
995 mp_hPosTracerItem->setVisible(true);
996 mp_hPosTracerItem->start->setCoords(
997 xAxis->range().lower, m_context.m_lastCursorHoveredPoint.y());
998 mp_hPosTracerItem->end->setCoords(
999 xAxis->range().upper, m_context.m_lastCursorHoveredPoint.y());
1000 }
1001
1002 qDebug();
1003 // Vertical position tracer.
1004 if(mp_vPosTracerItem != nullptr)
1005 {
1006 mp_vPosTracerItem->setVisible(true);
1007
1008 mp_vPosTracerItem->setVisible(true);
1009 mp_vPosTracerItem->start->setCoords(
1010 m_context.m_lastCursorHoveredPoint.x(), yAxis->range().upper);
1011 mp_vPosTracerItem->end->setCoords(
1012 m_context.m_lastCursorHoveredPoint.x(), yAxis->range().lower);
1013 }
1014
1015 qDebug();
1016 replot();
1017 }
1018
1019
1020 return;
1021}
void lastCursorHoveredPointSignal(const QPointF &pointf)

References lastCursorHoveredPointSignal(), m_context, pappso::BasePlotContext::m_isMouseDragging, pappso::BasePlotContext::m_lastCursorHoveredPoint, m_shouldTracersBeVisible, mp_hPosTracerItem, mp_vEndTracerItem, and mp_vPosTracerItem.

Referenced by mouseMoveHandler(), pappso::DriftSpecMassSpecColorMapPlotWidget::mouseMoveHandlerNotDraggingCursor(), pappso::DriftSpecTracePlotWidget::mouseMoveHandlerNotDraggingCursor(), pappso::MassSpecTracePlotWidget::mouseMoveHandlerNotDraggingCursor(), pappso::TicXicChromDriftSpecColorMapPlotWidget::mouseMoveHandlerNotDraggingCursor(), pappso::TicXicChromMassSpecColorMapPlotWidget::mouseMoveHandlerNotDraggingCursor(), and pappso::TicXicChromTracePlotWidget::mouseMoveHandlerNotDraggingCursor().

◆ mouseMoveHandlerRightButtonDraggingCursor()

void pappso::BasePlotWidget::mouseMoveHandlerRightButtonDraggingCursor ( )
virtual

Definition at line 1252 of file baseplotwidget.cpp.

1253{
1254 qDebug() << "the right button is dragging.";
1255
1256 // Set the context.m_isMeasuringDistance to false, which later might be set to
1257 // true if effectively we are measuring a distance. This is required because
1258 // the derived widgets might want to know if they have to perform some
1259 // action on the basis that context is measuring a distance, for example the
1260 // mass spectrum-specific widget might want to compute deconvolutions.
1261
1263
1265 {
1266 // qDebug() << "Apparently the selection is a real rectangle.";
1267
1268 // When we draw a rectangle the tracers are of no use.
1269
1270 if(mp_hPosTracerItem != nullptr)
1271 mp_hPosTracerItem->setVisible(false);
1272 if(mp_vPosTracerItem != nullptr)
1273 mp_vPosTracerItem->setVisible(false);
1274
1275 if(mp_vStartTracerItem != nullptr)
1276 mp_vStartTracerItem->setVisible(false);
1277 if(mp_vEndTracerItem != nullptr)
1278 mp_vEndTracerItem->setVisible(false);
1279
1280 // Draw the rectangle, false for as_line_segment and true, for
1281 // integration.
1283
1284 // Draw the selection width/height text
1287 }
1288 else
1289 {
1290 // qDebug() << "Apparently the selection is a not a rectangle.";
1291
1292 // Draw the rectangle, true, as line segment and
1293 // false, true for integration
1295
1296 // Draw the selection width text
1298 }
1299
1300 // Draw the selection width text
1302}

References drawSelectionRectangleAndPrepareZoom(), drawXDeltaFeatures(), drawYDeltaFeatures(), isVerticalDisplacementAboveThreshold(), m_context, pappso::BasePlotContext::m_isMeasuringDistance, mp_hPosTracerItem, mp_vEndTracerItem, mp_vPosTracerItem, and mp_vStartTracerItem.

Referenced by mouseMoveHandlerDraggingCursor().

◆ mousePressHandler()

void pappso::BasePlotWidget::mousePressHandler ( QMouseEvent *  event)
virtual

KEYBOARD-related EVENTS.

MOUSE-related EVENTS

Reimplemented in pappso::DriftSpecMassSpecColorMapPlotWidget, pappso::DriftSpecTracePlotWidget, pappso::MassSpecTracePlotWidget, pappso::TicXicChromDriftSpecColorMapPlotWidget, pappso::TicXicChromMassSpecColorMapPlotWidget, and pappso::TicXicChromTracePlotWidget.

Definition at line 1306 of file baseplotwidget.cpp.

1307{
1308 // When the user clicks this widget it has to take focus.
1309 setFocus();
1310
1311 // Fix from Qt5 to Qt6
1312 //QPointF mousePoint = event->localPos();
1313 QPointF mousePoint = event->position();
1314
1315
1316 m_context.m_lastPressedMouseButton = event->button();
1317 m_context.m_mouseButtonsAtMousePress = event->buttons();
1318
1319 // The pressedMouseButtons must continually inform on the status of
1320 // pressed buttons so add the pressed button.
1321 m_context.m_pressedMouseButtons |= event->button();
1322
1323 qDebug().noquote() << m_context.toString();
1324
1325 // In all the processing of the events, we need to know if the user is
1326 // clicking somewhere with the intent to change the plot ranges (reframing
1327 // or rescaling the plot).
1328 //
1329 // Reframing the plot means that the new x and y axes ranges are modified
1330 // so that they match the region that the user has encompassed by left
1331 // clicking the mouse and dragging it over the plot. That is we reframe
1332 // the plot so that it contains only the "selected" region.
1333 //
1334 // Rescaling the plot means the the new x|y axis range is modified such
1335 // that the lower axis range is constant and the upper axis range is moved
1336 // either left or right by the same amont as the x|y delta encompassed by
1337 // the user moving the mouse. The axis is thus either compressed (mouse
1338 // movement is leftwards) or un-compressed (mouse movement is rightwards).
1339
1340 // There are two ways to perform axis range modifications:
1341 //
1342 // 1. By clicking on any of the axes
1343 // 2. By clicking on the plot region but using keyboard key modifiers,
1344 // like Alt and Ctrl.
1345 //
1346 // We need to know both cases separately which is why we need to perform a
1347 // number of tests below.
1348
1349 // Let's check if the click is on the axes, either X or Y, because that
1350 // will allow us to take proper actions.
1351
1352 if(isClickOntoXAxis(mousePoint))
1353 {
1354 // The X axis was clicked upon, we need to document that:
1355 // qDebug() << __FILE__ << __LINE__
1356 //<< "Layout element is axisRect and actually on an X axis part.";
1357
1359
1360 // int currentInteractions = interactions();
1361 // currentInteractions |= QCP::iRangeDrag;
1362 // setInteractions((QCP::Interaction)currentInteractions);
1363 // axisRect()->setRangeDrag(xAxis->orientation());
1364 }
1365 else
1367
1368 if(isClickOntoYAxis(mousePoint))
1369 {
1370 // The Y axis was clicked upon, we need to document that:
1371 // qDebug() << __FILE__ << __LINE__
1372 //<< "Layout element is axisRect and actually on an Y axis part.";
1373
1375
1376 // int currentInteractions = interactions();
1377 // currentInteractions |= QCP::iRangeDrag;
1378 // setInteractions((QCP::Interaction)currentInteractions);
1379 // axisRect()->setRangeDrag(yAxis->orientation());
1380 }
1381 else
1383
1384 // At this point, let's see if we need to remove the QCP::iRangeDrag bit:
1385
1387 {
1388 // qDebug() << __FILE__ << __LINE__
1389 // << "Click outside of axes.";
1390
1391 // int currentInteractions = interactions();
1392 // currentInteractions = currentInteractions & ~QCP::iRangeDrag;
1393 // setInteractions((QCP::Interaction)currentInteractions);
1394 }
1395
1396 m_context.m_startDragPoint.setX(xAxis->pixelToCoord(mousePoint.x()));
1397 m_context.m_startDragPoint.setY(yAxis->pixelToCoord(mousePoint.y()));
1398
1399 // Now install the vertical start tracer at the last cursor hovered
1400 // position.
1401 if((m_shouldTracersBeVisible) && (mp_vStartTracerItem != nullptr))
1402 mp_vStartTracerItem->setVisible(true);
1403
1404 if(mp_vStartTracerItem != nullptr)
1405 {
1406 mp_vStartTracerItem->start->setCoords(
1407 m_context.m_lastCursorHoveredPoint.x(), yAxis->range().upper);
1408 mp_vStartTracerItem->end->setCoords(
1409 m_context.m_lastCursorHoveredPoint.x(), yAxis->range().lower);
1410 }
1411
1412 replot();
1413}
Qt::MouseButtons m_lastPressedMouseButton
bool isClickOntoYAxis(const QPointF &mousePoint)
bool isClickOntoXAxis(const QPointF &mousePoint)

References isClickOntoXAxis(), isClickOntoYAxis(), m_context, pappso::BasePlotContext::m_lastCursorHoveredPoint, pappso::BasePlotContext::m_lastPressedMouseButton, pappso::BasePlotContext::m_mouseButtonsAtMousePress, pappso::BasePlotContext::m_pressedMouseButtons, m_shouldTracersBeVisible, pappso::BasePlotContext::m_startDragPoint, pappso::BasePlotContext::m_wasClickOnXAxis, pappso::BasePlotContext::m_wasClickOnYAxis, mp_vStartTracerItem, setFocus(), and pappso::BasePlotContext::toString().

Referenced by pappso::DriftSpecMassSpecColorMapPlotWidget::mousePressHandler(), pappso::DriftSpecTracePlotWidget::mousePressHandler(), pappso::MassSpecTracePlotWidget::mousePressHandler(), pappso::TicXicChromDriftSpecColorMapPlotWidget::mousePressHandler(), pappso::TicXicChromMassSpecColorMapPlotWidget::mousePressHandler(), pappso::TicXicChromTracePlotWidget::mousePressHandler(), mousePseudoButtonKeyReleaseEvent(), and setupWidget().

◆ mousePseudoButtonKeyPressEvent()

void pappso::BasePlotWidget::mousePseudoButtonKeyPressEvent ( QKeyEvent *  event)
virtual

Definition at line 839 of file baseplotwidget.cpp.

841{
842 // qDebug();
843}

Referenced by keyPressEvent().

◆ mousePseudoButtonKeyReleaseEvent()

void pappso::BasePlotWidget::mousePseudoButtonKeyReleaseEvent ( QKeyEvent *  event)
virtual

Definition at line 847 of file baseplotwidget.cpp.

848{
849
850 QPointF pixel_coordinates(
851 xAxis->coordToPixel(m_context.m_lastCursorHoveredPoint.x()),
852 yAxis->coordToPixel(m_context.m_lastCursorHoveredPoint.y()));
853
854 Qt::MouseButton button = Qt::NoButton;
855 QEvent::Type q_event_type = QEvent::MouseButtonPress;
856
857 if(event->key() == m_leftMousePseudoButtonKey)
858 {
859 // Toggles the left mouse button on/off
860
861 button = Qt::LeftButton;
862
865
867 q_event_type = QEvent::MouseButtonPress;
868 else
869 q_event_type = QEvent::MouseButtonRelease;
870 }
871 else if(event->key() == m_rightMousePseudoButtonKey)
872 {
873 // Toggles the right mouse button.
874
875 button = Qt::RightButton;
876
879
881 q_event_type = QEvent::MouseButtonPress;
882 else
883 q_event_type = QEvent::MouseButtonRelease;
884 }
885
886 // qDebug() << "pressed/released pseudo button:" << button
887 //<< "q_event_type:" << q_event_type;
888
889 // Synthesize a QMouseEvent and use it.
890
891 QMouseEvent *mouse_event_p =
892 new QMouseEvent(q_event_type,
893 pixel_coordinates,
894 mapToGlobal(pixel_coordinates.toPoint()),
895 mapToGlobal(pixel_coordinates.toPoint()),
896 button,
897 button,
899 Qt::MouseEventSynthesizedByApplication);
900
901 if(q_event_type == QEvent::MouseButtonPress)
902 mousePressHandler(mouse_event_p);
903 else
904 mouseReleaseHandler(mouse_event_p);
905
906 // event->accept();
907}
virtual void mousePressHandler(QMouseEvent *event)
KEYBOARD-related EVENTS.
virtual void mouseReleaseHandler(QMouseEvent *event)

References m_context, pappso::BasePlotContext::m_isLeftPseudoButtonKeyPressed, pappso::BasePlotContext::m_isRightPseudoButtonKeyPressed, pappso::BasePlotContext::m_keyboardModifiers, pappso::BasePlotContext::m_lastCursorHoveredPoint, m_leftMousePseudoButtonKey, m_rightMousePseudoButtonKey, mousePressHandler(), and mouseReleaseHandler().

Referenced by keyReleaseEvent().

◆ mouseReleaseEventSignal

void pappso::BasePlotWidget::mouseReleaseEventSignal ( const BasePlotContext context)
signal

◆ mouseReleaseHandler()

void pappso::BasePlotWidget::mouseReleaseHandler ( QMouseEvent *  event)
virtual

Reimplemented in pappso::DriftSpecMassSpecColorMapPlotWidget, pappso::DriftSpecTracePlotWidget, pappso::MassSpecTracePlotWidget, pappso::TicXicChromDriftSpecColorMapPlotWidget, pappso::TicXicChromMassSpecColorMapPlotWidget, and pappso::TicXicChromTracePlotWidget.

Definition at line 1417 of file baseplotwidget.cpp.

1418{
1419 // Now the real code of this function.
1420
1421 m_context.m_lastReleasedMouseButton = event->button();
1422
1423 // The event->buttons() is the description of the buttons that are pressed at
1424 // the moment the handler is invoked, that is now. If left and right were
1425 // pressed, and left was released, event->buttons() would be right.
1426 m_context.m_mouseButtonsAtMouseRelease = event->buttons();
1427
1428 // The pressedMouseButtons must continually inform on the status of pressed
1429 // buttons so remove the released button.
1430 m_context.m_pressedMouseButtons ^= event->button();
1431
1432 // qDebug().noquote() << m_context.toString();
1433
1434 // We'll need to know if modifiers were pressed a the moment the user
1435 // released the mouse button.
1436 m_context.m_keyboardModifiers = QGuiApplication::keyboardModifiers();
1437
1439 {
1440 // Let the user know that the mouse was *not* being dragged.
1442
1443 event->accept();
1444
1445 return;
1446 }
1447
1448 // Let the user know that the mouse was being dragged.
1450
1451 // We cannot hide all items in one go because we rely on their visibility
1452 // to know what kind of dragging operation we need to perform (line-only
1453 // X-based zoom or rectangle-based X- and Y-based zoom, for example). The
1454 // only thing we know is that we can make the text invisible.
1455
1456 // Same for the x delta text item
1457 mp_xDeltaTextItem->setVisible(false);
1458 mp_yDeltaTextItem->setVisible(false);
1459
1460 // We do not show the end vertical region range marker.
1461 mp_vEndTracerItem->setVisible(false);
1462
1463 // Horizontal position tracer.
1464 mp_hPosTracerItem->setVisible(true);
1465 mp_hPosTracerItem->start->setCoords(xAxis->range().lower,
1467 mp_hPosTracerItem->end->setCoords(xAxis->range().upper,
1469
1470 // Vertical position tracer.
1471 mp_vPosTracerItem->setVisible(true);
1472
1473 mp_vPosTracerItem->setVisible(true);
1475 yAxis->range().upper);
1477 yAxis->range().lower);
1478
1479 // Force replot now because later that call might not be performed.
1480 replot();
1481
1482 // If we were using the "quantum" display for the rescale of the axes
1483 // using the Ctrl-modified left button click drag in the axes, then reset
1484 // the count to 0.
1486
1487 // Now that we have computed the useful ranges, we need to check what to do
1488 // depending on the button that was pressed.
1489
1490 if(m_context.m_lastReleasedMouseButton == Qt::LeftButton)
1491 {
1493 }
1494 else if(m_context.m_lastReleasedMouseButton == Qt::RightButton)
1495 {
1497 }
1498
1499 // By definition we are stopping the drag operation by releasing the mouse
1500 // button. Whatever that mouse button was pressed before and if there was
1501 // one pressed before. We cannot set that boolean value to false before
1502 // this place, because we call a number of routines above that need to know
1503 // that dragging was occurring. Like mouseReleaseHandledEvent(event) for
1504 // example.
1505
1507
1508 event->accept();
1509
1510 return;
1511}
Qt::MouseButtons m_mouseButtonsAtMouseRelease
Qt::MouseButtons m_lastReleasedMouseButton
virtual void mouseReleaseHandlerRightButton()
virtual void mouseReleaseHandlerLeftButton()

References m_context, pappso::BasePlotContext::m_isMouseDragging, pappso::BasePlotContext::m_keyboardModifiers, pappso::BasePlotContext::m_lastCursorHoveredPoint, pappso::BasePlotContext::m_lastReleasedMouseButton, pappso::BasePlotContext::m_mouseButtonsAtMouseRelease, m_mouseMoveHandlerSkipCount, pappso::BasePlotContext::m_pressedMouseButtons, pappso::BasePlotContext::m_wasMouseDragging, mouseReleaseHandlerLeftButton(), mouseReleaseHandlerRightButton(), mp_hPosTracerItem, mp_vEndTracerItem, mp_vPosTracerItem, mp_xDeltaTextItem, and mp_yDeltaTextItem.

Referenced by mousePseudoButtonKeyReleaseEvent(), pappso::DriftSpecMassSpecColorMapPlotWidget::mouseReleaseHandler(), pappso::DriftSpecTracePlotWidget::mouseReleaseHandler(), pappso::MassSpecTracePlotWidget::mouseReleaseHandler(), pappso::TicXicChromDriftSpecColorMapPlotWidget::mouseReleaseHandler(), pappso::TicXicChromMassSpecColorMapPlotWidget::mouseReleaseHandler(), pappso::TicXicChromTracePlotWidget::mouseReleaseHandler(), and setupWidget().

◆ mouseReleaseHandlerLeftButton()

void pappso::BasePlotWidget::mouseReleaseHandlerLeftButton ( )
virtual

Definition at line 1515 of file baseplotwidget.cpp.

1516{
1517
1519 {
1520
1521 // When the mouse move handler pans the plot, we cannot store each axes
1522 // range history element that would mean store a huge amount of such
1523 // elements, as many element as there are mouse move event handled by
1524 // the Qt event queue. But we can store an axis range history element
1525 // for the last situation of the mouse move: when the button is
1526 // released:
1527
1529
1531
1532 replot();
1533
1534 // Nothing else to do.
1535 return;
1536 }
1537
1538 // There are two possibilities:
1539 //
1540 // 1. The full selection polygon (four lines) were currently drawn, which
1541 // means the user was willing to perform a zoom operation
1542 //
1543 // 2. Only the first top line was drawn, which means the user was dragging
1544 // the cursor horizontally. That might have two ends, as shown below.
1545
1546 // So, first check what is drawn of the selection polygon.
1547
1548 PolygonType current_selection_polygon_type =
1550
1551 // Now that we know what was currently drawn of the selection polygon, we can
1552 // remove it. true to reset the values to 0.
1554
1555 // Force replot now because later that call might not be performed.
1556 replot();
1557
1558 if(current_selection_polygon_type == PolygonType::FULL_POLYGON)
1559 {
1560 // qDebug() << "Yes, the full polygon was visible";
1561
1562 // If we were dragging with the left button pressed and could draw a
1563 // rectangle, then we were preparing a zoom operation. Let's bring that
1564 // operation to its accomplishment.
1565
1566 axisZoom();
1567
1568 // qDebug() << "The selection polygon:"
1569 //<< m_context.m_selectionPolygon.toString();
1570
1571 return;
1572 }
1573 else if(current_selection_polygon_type == PolygonType::TOP_LINE)
1574 {
1575 // qDebug() << "No, only the top line of the full polygon was visible";
1576
1577 // The user was dragging the left mouse cursor and that may mean they were
1578 // measuring a distance or willing to perform a special zoom operation if
1579 // the Ctrl key was down.
1580
1581 // If the user started by clicking in the plot region, dragged the mouse
1582 // cursor with the left button and pressed the Ctrl modifier, then that
1583 // means that they wanted to do a rescale over the x-axis in the form of a
1584 // reframing.
1585
1586 if(m_context.m_keyboardModifiers & Qt::ControlModifier)
1587 {
1588 return axisReframe();
1589
1590 // qDebug() << "The selection polygon:"
1591 //<< m_context.m_selectionPolygon.toString();
1592 }
1593 }
1594 // else
1595 // qDebug() << "Another possibility.";
1596}
virtual PolygonType whatIsVisibleOfTheSelectionRectangle()

References axisReframe(), axisZoom(), pappso::FULL_POLYGON, hideSelectionRectangle(), m_context, pappso::BasePlotContext::m_keyboardModifiers, pappso::BasePlotContext::m_wasClickOnXAxis, pappso::BasePlotContext::m_wasClickOnYAxis, plotRangesChangedSignal(), pappso::TOP_LINE, updateAxesRangeHistory(), and whatIsVisibleOfTheSelectionRectangle().

Referenced by mouseReleaseHandler().

◆ mouseReleaseHandlerRightButton()

void pappso::BasePlotWidget::mouseReleaseHandlerRightButton ( )
virtual

Definition at line 1600 of file baseplotwidget.cpp.

1601{
1602 qDebug();
1603 // The right button is used for the integrations. Not for axis range
1604 // operations. So all we have to do is remove the various graphics items and
1605 // send a signal with the context that contains all the data required by the
1606 // user to perform the integrations over the right plot regions.
1607
1608 // Whatever we were doing we need to make the selection line invisible:
1609
1610 if(mp_xDeltaTextItem->visible())
1611 mp_xDeltaTextItem->setVisible(false);
1612 if(mp_yDeltaTextItem->visible())
1613 mp_yDeltaTextItem->setVisible(false);
1614
1615 // Also make the vertical end tracer invisible.
1616 mp_vEndTracerItem->setVisible(false);
1617
1618 // Once the integration is asked for, then the selection rectangle if of no
1619 // more use.
1621
1622 // Force replot now because later that call might not be performed.
1623 replot();
1624
1625 // Note that we only request an integration if the x-axis delta is enough.
1626
1627 double x_delta_pixel =
1628 fabs(xAxis->coordToPixel(m_context.m_currentDragPoint.x()) -
1629 xAxis->coordToPixel(m_context.m_startDragPoint.x()));
1630
1631 if(x_delta_pixel > 3)
1633 // else
1634 qDebug() << "Not asking for integration.";
1635}
void integrationRequestedSignal(const BasePlotContext &context)

References hideSelectionRectangle(), integrationRequestedSignal(), m_context, pappso::BasePlotContext::m_currentDragPoint, pappso::BasePlotContext::m_startDragPoint, mp_vEndTracerItem, mp_xDeltaTextItem, and mp_yDeltaTextItem.

Referenced by mouseReleaseHandler().

◆ mouseWheelEventSignal

void pappso::BasePlotWidget::mouseWheelEventSignal ( const BasePlotContext context)
signal

Referenced by mouseWheelHandler().

◆ mouseWheelHandler()

void pappso::BasePlotWidget::mouseWheelHandler ( QWheelEvent *  event)
virtual

Definition at line 1639 of file baseplotwidget.cpp.

1640{
1641 // We should record the new range values each time the wheel is used to
1642 // zoom/unzoom.
1643
1644 m_context.m_xRange = QCPRange(xAxis->range());
1645 m_context.m_yRange = QCPRange(yAxis->range());
1646
1647 // qDebug() << "New x range: " << m_context.m_xRange;
1648 // qDebug() << "New y range: " << m_context.m_yRange;
1649
1651
1654
1655 event->accept();
1656}
void mouseWheelEventSignal(const BasePlotContext &context)

References m_context, pappso::BasePlotContext::m_xRange, pappso::BasePlotContext::m_yRange, mouseWheelEventSignal(), plotRangesChangedSignal(), and updateAxesRangeHistory().

Referenced by setupWidget().

◆ moveMouseCursorGraphCoordToGlobal()

void pappso::BasePlotWidget::moveMouseCursorGraphCoordToGlobal ( QPointF  plot_coordinates)
virtual

Definition at line 1795 of file baseplotwidget.cpp.

1796{
1797 // First convert the graph coordinates to pixel coordinates.
1798
1799 QPointF pixels_coordinates(xAxis->coordToPixel(graph_coordinates.x()),
1800 yAxis->coordToPixel(graph_coordinates.y()));
1801
1802 moveMouseCursorPixelCoordToGlobal(pixels_coordinates.toPoint());
1803}

References moveMouseCursorPixelCoordToGlobal().

◆ moveMouseCursorPixelCoordToGlobal()

void pappso::BasePlotWidget::moveMouseCursorPixelCoordToGlobal ( QPointF  local_coordinates)
virtual

Definition at line 1807 of file baseplotwidget.cpp.

1808{
1809 // qDebug() << "Calling set pos with new cursor position.";
1810 QCursor::setPos(mapToGlobal(pixel_coordinates.toPoint()));
1811}

Referenced by horizontalMoveMouseCursorCountPixels(), moveMouseCursorGraphCoordToGlobal(), and verticalMoveMouseCursorCountPixels().

◆ plotRangesChangedSignal

◆ plottableDestructionRequestedSignal

void pappso::BasePlotWidget::plottableDestructionRequestedSignal ( BasePlotWidget base_plot_widget_p,
QCPAbstractPlottable *  plottable_p,
const BasePlotContext context 
)
signal

Referenced by keyReleaseEvent().

◆ plottableSelectionChangedSignal

void pappso::BasePlotWidget::plottableSelectionChangedSignal ( QCPAbstractPlottable *  plottable_p,
bool  selected 
)
signal

◆ redrawPlotBackground()

void pappso::BasePlotWidget::redrawPlotBackground ( QWidget *  focusedPlotWidget)
virtual

Redraw the background of the focusedPlotWidget plot widget.

Definition at line 3226 of file baseplotwidget.cpp.

3227{
3228 if(focusedPlotWidget == nullptr)
3229 throw ExceptionNotPossible(
3230 "baseplotwidget.cpp @ redrawPlotBackground(QWidget *focusedPlotWidget "
3231 "-- "
3232 "ERROR focusedPlotWidget cannot be nullptr.");
3233
3234 if(dynamic_cast<QWidget *>(this) != focusedPlotWidget)
3235 {
3236 // The focused widget is not *this widget. We should make sure that
3237 // we were not the one that had the focus, because in this case we
3238 // need to redraw an unfocused background.
3239
3240 axisRect()->setBackground(m_unfocusedBrush);
3241 }
3242 else
3243 {
3244 axisRect()->setBackground(m_focusedBrush);
3245 }
3246
3247 replot();
3248}
QBrush m_focusedBrush
Color used for the background of focused plot.
QBrush m_unfocusedBrush
Color used for the background of unfocused plot.

References m_focusedBrush, and m_unfocusedBrush.

◆ replotWithAxesRanges()

void pappso::BasePlotWidget::replotWithAxesRanges ( QCPRange  xAxisRange,
QCPRange  yAxisRange,
Axis  axis 
)
virtual

Definition at line 2220 of file baseplotwidget.cpp.

2223{
2224 // qDebug() << "With axis:" << (int)axis;
2225
2226 if(static_cast<int>(axis) & static_cast<int>(Axis::x))
2227 {
2228 xAxis->setRange(xAxisRange.lower, xAxisRange.upper);
2229 }
2230
2231 if(static_cast<int>(axis) & static_cast<int>(Axis::y))
2232 {
2233 yAxis->setRange(yAxisRange.lower, yAxisRange.upper);
2234 }
2235
2236 // We do not want to update the history, because there would be way too
2237 // much history items, since this function is called upon mouse moving
2238 // handling and not only during mouse release events.
2239 // updateAxesRangeHistory();
2240
2241 replot();
2242}

References pappso::x, and pappso::y.

◆ replotWithAxisRangeX()

void pappso::BasePlotWidget::replotWithAxisRangeX ( double  lower,
double  upper 
)
virtual

Definition at line 2246 of file baseplotwidget.cpp.

2247{
2248 // qDebug();
2249
2250 xAxis->setRange(lower, upper);
2251
2252 replot();
2253}

◆ replotWithAxisRangeY()

void pappso::BasePlotWidget::replotWithAxisRangeY ( double  lower,
double  upper 
)
virtual

Definition at line 2257 of file baseplotwidget.cpp.

2258{
2259 // qDebug();
2260
2261 yAxis->setRange(lower, upper);
2262
2263 replot();
2264}

◆ resetAxesRangeHistory()

void pappso::BasePlotWidget::resetAxesRangeHistory ( )
virtual

Definition at line 485 of file baseplotwidget.cpp.

486{
487 m_xAxisRangeHistory.clear();
488 m_yAxisRangeHistory.clear();
489
490 m_xAxisRangeHistory.push_back(new QCPRange(xAxis->range()));
491 m_yAxisRangeHistory.push_back(new QCPRange(yAxis->range()));
492
493 // qDebug() << "size of history:" << m_xAxisRangeHistory.size()
494 //<< "setting index to 0";
495
496 // qDebug() << "resetting axes history to values:" << xAxis->range().lower
497 //<< "--" << xAxis->range().upper << "and" << yAxis->range().lower
498 //<< "--" << yAxis->range().upper;
499
501}
std::size_t m_lastAxisRangeHistoryIndex
Index of the last axis range history item.

References m_lastAxisRangeHistoryIndex, m_xAxisRangeHistory, and m_yAxisRangeHistory.

Referenced by pappso::BaseColorMapPlotWidget::addColorMap(), pappso::BaseTracePlotWidget::addTrace(), axisDoubleClickHandler(), pappso::BaseTracePlotWidget::axisDoubleClickHandler(), pappso::BaseTracePlotWidget::clearGraphData(), and pappso::BaseTracePlotWidget::setGraphData().

◆ resetSelectionRectangle()

void pappso::BasePlotWidget::resetSelectionRectangle ( )
virtual

◆ restoreAxesRangeHistory()

void pappso::BasePlotWidget::restoreAxesRangeHistory ( std::size_t  index)
virtual

Get the axis histories at index index and update the plot ranges.

Parameters
indexindex at which to select the axis history item.
See also
updateAxesRangeHistory().

Definition at line 562 of file baseplotwidget.cpp.

563{
564 // qDebug() << "Axes history size:" << m_xAxisRangeHistory.size()
565 //<< "current index:" << m_lastAxisRangeHistoryIndex
566 //<< "asking to restore index:" << index;
567
568 if(index >= m_xAxisRangeHistory.size())
569 {
570 // qDebug() << "index >= history size. Returning.";
571 return;
572 }
573
574 // We want to go back to the range history item at index, which means we want
575 // to pop back all the items between index+1 and size-1.
576
577 while(m_xAxisRangeHistory.size() > index + 1)
578 m_xAxisRangeHistory.pop_back();
579
580 if(m_xAxisRangeHistory.size() - 1 != index)
581 qFatal("Programming error.");
582
583 xAxis->setRange(*(m_xAxisRangeHistory.at(index)));
584 yAxis->setRange(*(m_yAxisRangeHistory.at(index)));
585
587
588 mp_vPosTracerItem->setVisible(false);
589 mp_hPosTracerItem->setVisible(false);
590
591 mp_vStartTracerItem->setVisible(false);
592 mp_vEndTracerItem->setVisible(false);
593
594
595 // The start tracer will keep beeing represented at the last position and last
596 // size even if we call this function repetitively. So actually do not show,
597 // it will reappare as soon as the mouse is moved.
598 // if(m_shouldTracersBeVisible)
599 //{
600 // mp_vStartTracerItem->setVisible(true);
601 //}
602
603 replot();
604
606
607 // qDebug() << "restored axes history to index:" << index
608 //<< "with values:" << xAxis->range().lower << "--"
609 //<< xAxis->range().upper << "and" << yAxis->range().lower << "--"
610 //<< yAxis->range().upper;
611
613}
virtual void hideAllPlotItems()
PLOTTING / REPLOTTING functions.

References hideAllPlotItems(), m_context, m_xAxisRangeHistory, m_yAxisRangeHistory, mp_hPosTracerItem, mp_vEndTracerItem, mp_vPosTracerItem, mp_vStartTracerItem, plotRangesChangedSignal(), and updateContextXandYAxisRanges().

Referenced by restorePreviousAxesRangeHistory().

◆ restorePreviousAxesRangeHistory()

void pappso::BasePlotWidget::restorePreviousAxesRangeHistory ( )
virtual

Go up one history element in the axis history.

If possible, back up one history item in the axis histories and update the plot's x/y-axis ranges to match that history item.

Definition at line 534 of file baseplotwidget.cpp.

535{
536 // qDebug() << "axes history size:" << m_xAxisRangeHistory.size()
537 //<< "current index:" << m_lastAxisRangeHistoryIndex;
538
540 {
541 // qDebug() << "current index is 0 returning doing nothing";
542
543 return;
544 }
545
546 // qDebug() << "Setting index to:" << m_lastAxisRangeHistoryIndex - 1
547 //<< "and restoring axes history to that index";
548
550}
virtual void restoreAxesRangeHistory(std::size_t index)
Get the axis histories at index index and update the plot ranges.

References m_lastAxisRangeHistoryIndex, and restoreAxesRangeHistory().

Referenced by keyReleaseEvent().

◆ setAxisLabelX()

void pappso::BasePlotWidget::setAxisLabelX ( const QString &  label)
virtual

Definition at line 470 of file baseplotwidget.cpp.

471{
472 xAxis->setLabel(label);
473}

◆ setAxisLabelY()

void pappso::BasePlotWidget::setAxisLabelY ( const QString &  label)
virtual

Definition at line 477 of file baseplotwidget.cpp.

478{
479 yAxis->setLabel(label);
480}

◆ setFocus()

void pappso::BasePlotWidget::setFocus ( )
virtual

PLOT ITEMS : TRACER TEXT ITEMS...

Definition at line 3212 of file baseplotwidget.cpp.

3213{
3214 // qDebug() << "Setting focus to the QCustomPlot:" << this;
3215
3216 QCustomPlot::setFocus();
3217
3218 // qDebug() << "Emitting setFocusSignal().";
3219
3220 emit setFocusSignal();
3221}

References setFocusSignal().

Referenced by mouseMoveHandler(), and mousePressHandler().

◆ setFocusSignal

void pappso::BasePlotWidget::setFocusSignal ( )
signal

Referenced by setFocus().

◆ setPen()

void pappso::BasePlotWidget::setPen ( const QPen &  pen)
virtual

Definition at line 401 of file baseplotwidget.cpp.

402{
403 m_pen = pen;
404}

References m_pen.

◆ setPlottingColor() [1/2]

void pappso::BasePlotWidget::setPlottingColor ( int  index,
const QColor &  new_color 
)
virtual

Definition at line 433 of file baseplotwidget.cpp.

434{
435 if(!new_color.isValid())
436 return;
437
438 QCPGraph *graph_p = graph(index);
439
440 if(graph_p == nullptr)
441 qFatal("Programming error.");
442
443 return setPlottingColor(graph_p, new_color);
444}
virtual void setPlottingColor(QCPAbstractPlottable *plottable_p, const QColor &new_color)

References setPlottingColor().

◆ setPlottingColor() [2/2]

void pappso::BasePlotWidget::setPlottingColor ( QCPAbstractPlottable *  plottable_p,
const QColor &  new_color 
)
virtual

Reimplemented in pappso::BaseColorMapPlotWidget.

Definition at line 415 of file baseplotwidget.cpp.

417{
418 if(plottable_p == nullptr)
419 qFatal("Pointer cannot be nullptr.");
420
421 // First this single-graph widget
422 QPen pen;
423
424 pen = plottable_p->pen();
425 pen.setColor(new_color);
426 plottable_p->setPen(pen);
427
428 replot();
429}

Referenced by setPlottingColor().

◆ setupWidget()

bool pappso::BasePlotWidget::setupWidget ( )
virtual

Definition at line 343 of file baseplotwidget.cpp.

344{
345 // qDebug();
346
347 // By default the widget comes with a graph. Remove it.
348
349 if(graphCount())
350 {
351 // QCPLayer *layer_p = graph(0)->layer();
352 // qDebug() << "The graph was on layer:" << layer_p->name();
353
354 // As of today 20210313, the graph is created on the currentLayer(), that
355 // is "main".
356
357 removeGraph(0);
358 }
359
360 // The general idea is that we do want custom layers for the trace|colormap
361 // plots.
362
363 // qDebug().noquote() << "Right before creating the new layer, layers:\n"
364 //<< allLayerNamesToString();
365
366 // Add the layer that will store all the plots and all the ancillary items.
367 addLayer(
368 "plotsLayer", layer("background"), QCustomPlot::LayerInsertMode::limAbove);
369 // qDebug().noquote() << "Added new plotsLayer, layers:\n"
370 //<< allLayerNamesToString();
371
372 // This is required so that we get the keyboard events.
373 setFocusPolicy(Qt::StrongFocus);
374 setInteractions(QCP::iRangeZoom | QCP::iSelectPlottables | QCP::iMultiSelect);
375
376 // We want to capture the signals emitted by the QCustomPlot base class.
377 connect(
378 this, &QCustomPlot::mouseMove, this, &BasePlotWidget::mouseMoveHandler);
379
380 connect(
381 this, &QCustomPlot::mousePress, this, &BasePlotWidget::mousePressHandler);
382
383 connect(this,
384 &QCustomPlot::mouseRelease,
385 this,
387
388 connect(
389 this, &QCustomPlot::mouseWheel, this, &BasePlotWidget::mouseWheelHandler);
390
391 connect(this,
392 &QCustomPlot::axisDoubleClick,
393 this,
395
396 return true;
397}
virtual void mouseWheelHandler(QWheelEvent *event)
virtual void axisDoubleClickHandler(QCPAxis *axis, QCPAxis::SelectablePart part, QMouseEvent *event)
virtual void mouseMoveHandler(QMouseEvent *event)
KEYBOARD-related EVENTS.

References axisDoubleClickHandler(), mouseMoveHandler(), mousePressHandler(), mouseReleaseHandler(), and mouseWheelHandler().

Referenced by BasePlotWidget().

◆ showTracers()

void pappso::BasePlotWidget::showTracers ( )
virtual

Show the traces (vertical and horizontal).

Definition at line 2289 of file baseplotwidget.cpp.

2290{
2292
2293 mp_vPosTracerItem->setVisible(true);
2294 mp_hPosTracerItem->setVisible(true);
2295
2296 mp_vStartTracerItem->setVisible(true);
2297 mp_vEndTracerItem->setVisible(true);
2298
2299 // Force a replot to make sure the action is immediately visible by the
2300 // user, even without moving the mouse.
2301 replot();
2302}

References m_shouldTracersBeVisible, mp_hPosTracerItem, mp_vEndTracerItem, mp_vPosTracerItem, and mp_vStartTracerItem.

Referenced by keyReleaseEvent().

◆ spaceKeyReleaseEvent()

void pappso::BasePlotWidget::spaceKeyReleaseEvent ( QKeyEvent *  event)
virtual

Definition at line 781 of file baseplotwidget.cpp.

782{
783 // qDebug();
784}

Referenced by keyReleaseEvent().

◆ update1DSelectionRectangle()

void pappso::BasePlotWidget::update1DSelectionRectangle ( bool  for_integration = false)
protectedvirtual

Definition at line 2557 of file baseplotwidget.cpp.

2558{
2559
2560 // if(for_integration)
2561 // qDebug() << "for_integration:" << for_integration;
2562
2563 // When we make a linear selection, the selection polygon is a polygon that
2564 // has the following characteristics:
2565 //
2566 // the x range is the linear selection span
2567 //
2568 // the y range is the widest std::min -> std::max possible.
2569
2570 // This is how the selection polygon logic knows if its is mono-
2571 // two-dimensional.
2572
2573 // We want the top left point to effectively be the top left point, so check
2574 // the direction of the mouse cursor drag.
2575
2576 double x_range_start =
2578 double x_range_end =
2580
2581 double y_position = m_context.m_startDragPoint.y();
2582
2583 m_context.m_selectionPolygon.set1D(x_range_start, x_range_end);
2584
2585 // Top line
2586 mp_selectionRectangeLine1->start->setCoords(
2587 QPointF(x_range_start, y_position));
2588 mp_selectionRectangeLine1->end->setCoords(QPointF(x_range_end, y_position));
2589
2590 // Only if we are drawing a selection rectangle for integration, do we set
2591 // arrow heads to the line.
2592 if(for_integration)
2593 {
2594 mp_selectionRectangeLine1->setHead(QCPLineEnding::esSpikeArrow);
2595 mp_selectionRectangeLine1->setTail(QCPLineEnding::esSpikeArrow);
2596 }
2597 else
2598 {
2599 mp_selectionRectangeLine1->setHead(QCPLineEnding::esNone);
2600 mp_selectionRectangeLine1->setTail(QCPLineEnding::esNone);
2601 }
2602 mp_selectionRectangeLine1->setVisible(true);
2603
2604 // Right line: does not exist, start and end are the same end point of the top
2605 // line.
2606 mp_selectionRectangeLine2->start->setCoords(QPointF(x_range_end, y_position));
2607 mp_selectionRectangeLine2->end->setCoords(QPointF(x_range_end, y_position));
2608 mp_selectionRectangeLine2->setVisible(false);
2609
2610 // Bottom line: identical to the top line, but invisible
2611 mp_selectionRectangeLine3->start->setCoords(
2612 QPointF(x_range_start, y_position));
2613 mp_selectionRectangeLine3->end->setCoords(QPointF(x_range_end, y_position));
2614 mp_selectionRectangeLine3->setVisible(false);
2615
2616 // Left line: does not exist: start and end are the same end point of the top
2617 // line.
2618 mp_selectionRectangeLine4->start->setCoords(QPointF(x_range_end, y_position));
2619 mp_selectionRectangeLine4->end->setCoords(QPointF(x_range_end, y_position));
2620 mp_selectionRectangeLine4->setVisible(false);
2621}
void set1D(double x_range_start, double x_range_end)

References m_context, pappso::BasePlotContext::m_currentDragPoint, pappso::BasePlotContext::m_selectionPolygon, pappso::BasePlotContext::m_startDragPoint, mp_selectionRectangeLine1, mp_selectionRectangeLine2, mp_selectionRectangeLine3, mp_selectionRectangeLine4, and pappso::SelectionPolygon::set1D().

Referenced by updateSelectionRectangle().

◆ update2DSelectionRectangleSkewed()

void pappso::BasePlotWidget::update2DSelectionRectangleSkewed ( bool  for_integration = false)
protectedvirtual

Definition at line 2810 of file baseplotwidget.cpp.

2811{
2812
2813 // if(for_integration)
2814 // qDebug() << "for_integration:" << for_integration;
2815
2816 // We are handling a skewed rectangle, that is a rectangle that is
2817 // tilted either to the left or to the right.
2818
2819 // qDebug() << "m_context.m_selectRectangleWidth: "
2820 //<< m_context.m_selectRectangleWidth;
2821
2822 // Top line
2823 // start
2824
2825 // qDebug() << "m_context.m_startDragPoint: " <<
2826 // m_context.m_startDragPoint.x()
2827 //<< "-" << m_context.m_startDragPoint.y();
2828
2829 // qDebug() << "m_context.m_currentDragPoint: "
2830 //<< m_context.m_currentDragPoint.x() << "-"
2831 //<< m_context.m_currentDragPoint.y();
2832
2834
2836 {
2837 // qDebug() << "Dragging from right to left";
2838
2840 {
2841 // qDebug() << "Dragging from top to bottom";
2842
2847
2848 // m_context.m_selRectTopLeftPoint.setX(
2849 // m_context.m_startDragPoint.x() -
2850 // m_context.m_selectRectangleWidth);
2851 // m_context.m_selRectTopLeftPoint.setY(m_context.m_startDragPoint.y());
2852
2856
2857 // m_context.m_selRectTopRightPoint.setX(m_context.m_startDragPoint.x());
2858 // m_context.m_selRectTopRightPoint.setY(m_context.m_startDragPoint.y());
2859
2864
2865 // m_context.m_selRectBottomRightPoint.setX(
2866 // m_context.m_currentDragPoint.x() +
2867 // m_context.m_selectRectangleWidth);
2868 // m_context.m_selRectBottomRightPoint.setY(
2869 // m_context.m_currentDragPoint.y());
2870
2875
2876 // m_context.m_selRectBottomLeftPoint.setX(
2877 // m_context.m_currentDragPoint.x());
2878 // m_context.m_selRectBottomLeftPoint.setY(
2879 // m_context.m_currentDragPoint.y());
2880 }
2881 else
2882 {
2883 // qDebug() << "Dragging from bottom to top";
2884
2889
2890 // m_context.m_selRectTopLeftPoint.setX(
2891 // m_context.m_currentDragPoint.x());
2892 // m_context.m_selRectTopLeftPoint.setY(
2893 // m_context.m_currentDragPoint.y());
2894
2899
2900 // m_context.m_selRectTopRightPoint.setX(
2901 // m_context.m_currentDragPoint.x() +
2902 // m_context.m_selectRectangleWidth);
2903 // m_context.m_selRectTopRightPoint.setY(
2904 // m_context.m_currentDragPoint.y());
2905
2906
2910
2911 // m_context.m_selRectBottomRightPoint.setX(
2912 // m_context.m_startDragPoint.x());
2913 // m_context.m_selRectBottomRightPoint.setY(
2914 // m_context.m_startDragPoint.y());
2915
2920
2921 // m_context.m_selRectBottomLeftPoint.setX(
2922 // m_context.m_startDragPoint.x() -
2923 // m_context.m_selectRectangleWidth);
2924 // m_context.m_selRectBottomLeftPoint.setY(
2925 // m_context.m_startDragPoint.y());
2926 }
2927 }
2928 // End of
2929 // Dragging from right to left.
2930 else
2931 {
2932 // qDebug() << "Dragging from left to right";
2933
2935 {
2936 // qDebug() << "Dragging from top to bottom";
2937
2941
2942 // m_context.m_selRectTopLeftPoint.setX(m_context.m_startDragPoint.x());
2943 // m_context.m_selRectTopLeftPoint.setY(m_context.m_startDragPoint.y());
2944
2949
2950 // m_context.m_selRectTopRightPoint.setX(
2951 // m_context.m_startDragPoint.x() +
2952 // m_context.m_selectRectangleWidth);
2953 // m_context.m_selRectTopRightPoint.setY(m_context.m_startDragPoint.y());
2954
2959
2960 // m_context.m_selRectBottomRightPoint.setX(
2961 // m_context.m_currentDragPoint.x());
2962 // m_context.m_selRectBottomRightPoint.setY(
2963 // m_context.m_currentDragPoint.y());
2964
2969
2970 // m_context.m_selRectBottomLeftPoint.setX(
2971 // m_context.m_currentDragPoint.x() -
2972 // m_context.m_selectRectangleWidth);
2973 // m_context.m_selRectBottomLeftPoint.setY(
2974 // m_context.m_currentDragPoint.y());
2975 }
2976 else
2977 {
2978 // qDebug() << "Dragging from bottom to top";
2979
2984
2985 // m_context.m_selRectTopLeftPoint.setX(
2986 // m_context.m_currentDragPoint.x() -
2987 // m_context.m_selectRectangleWidth);
2988 // m_context.m_selRectTopLeftPoint.setY(
2989 // m_context.m_currentDragPoint.y());
2990
2995
2996 // m_context.m_selRectTopRightPoint.setX(
2997 // m_context.m_currentDragPoint.x());
2998 // m_context.m_selRectTopRightPoint.setY(
2999 // m_context.m_currentDragPoint.y());
3000
3005
3006 // m_context.m_selRectBottomRightPoint.setX(
3007 // m_context.m_startDragPoint.x() +
3008 // m_context.m_selectRectangleWidth);
3009 // m_context.m_selRectBottomRightPoint.setY(
3010 // m_context.m_startDragPoint.y());
3011
3015
3016 // m_context.m_selRectBottomLeftPoint.setX(
3017 // m_context.m_startDragPoint.x());
3018 // m_context.m_selRectBottomLeftPoint.setY(
3019 // m_context.m_startDragPoint.y());
3020 }
3021 }
3022 // End of Dragging from left to right.
3023
3024 // qDebug() << "Now draw the lines with points:"
3025 //<< m_context.m_selectionPolygon.toString();
3026
3027 // Top line
3028 mp_selectionRectangeLine1->start->setCoords(
3030 mp_selectionRectangeLine1->end->setCoords(
3032
3033 // Only if we are drawing a selection rectangle for integration, do we set
3034 // arrow heads to the line.
3035 if(for_integration)
3036 {
3037 mp_selectionRectangeLine1->setHead(QCPLineEnding::esSpikeArrow);
3038 mp_selectionRectangeLine1->setTail(QCPLineEnding::esSpikeArrow);
3039 }
3040 else
3041 {
3042 mp_selectionRectangeLine1->setHead(QCPLineEnding::esNone);
3043 mp_selectionRectangeLine1->setTail(QCPLineEnding::esNone);
3044 }
3045
3046 mp_selectionRectangeLine1->setVisible(true);
3047
3048 // Right line
3049 mp_selectionRectangeLine2->start->setCoords(
3051 mp_selectionRectangeLine2->end->setCoords(
3053 mp_selectionRectangeLine2->setVisible(true);
3054
3055 // Bottom line
3056 mp_selectionRectangeLine3->start->setCoords(
3058 mp_selectionRectangeLine3->end->setCoords(
3060 mp_selectionRectangeLine3->setVisible(true);
3061
3062 // Left line
3063 mp_selectionRectangeLine4->end->setCoords(
3065 mp_selectionRectangeLine4->start->setCoords(
3067 mp_selectionRectangeLine4->setVisible(true);
3068}
void setPoint(PointSpecs point_spec, double x, double y)
QPointF getPoint(PointSpecs point_spec) const

References pappso::BOTTOM_LEFT_POINT, pappso::BOTTOM_RIGHT_POINT, pappso::SelectionPolygon::getPoint(), m_context, pappso::BasePlotContext::m_currentDragPoint, pappso::BasePlotContext::m_selectionPolygon, pappso::BasePlotContext::m_selectRectangleWidth, pappso::BasePlotContext::m_startDragPoint, mp_selectionRectangeLine1, mp_selectionRectangeLine2, mp_selectionRectangeLine3, mp_selectionRectangeLine4, pappso::SelectionPolygon::resetPoints(), pappso::SelectionPolygon::setPoint(), pappso::TOP_LEFT_POINT, and pappso::TOP_RIGHT_POINT.

Referenced by updateSelectionRectangle().

◆ update2DSelectionRectangleSquare()

void pappso::BasePlotWidget::update2DSelectionRectangleSquare ( bool  for_integration = false)
protectedvirtual

Definition at line 2625 of file baseplotwidget.cpp.

2626{
2627
2628 // if(for_integration)
2629 // qDebug() << "for_integration:" << for_integration;
2630
2631 // We are handling a conventional rectangle. Just create four points
2632 // from top left to bottom right. But we want the top left point to be
2633 // effectively the top left point and the bottom point to be the bottom point.
2634 // So we need to try all four direction combinations, left to right or
2635 // converse versus top to bottom or converse.
2636
2638
2640 {
2641 // qDebug() << "Dragging from right to left";
2642
2644 {
2645 // qDebug() << "Dragging from top to bottom";
2646
2647 // TOP_LEFT_POINT
2652
2653 // TOP_RIGHT_POINT
2657
2658 // BOTTOM_RIGHT_POINT
2663
2664 // BOTTOM_LEFT_POINT
2669 }
2670 // End of
2671 // if(m_context.m_currentDragPoint.y() < m_context.m_startDragPoint.y())
2672 else
2673 {
2674 // qDebug() << "Dragging from bottom to top";
2675
2676 // TOP_LEFT_POINT
2681
2682 // TOP_RIGHT_POINT
2687
2688 // BOTTOM_RIGHT_POINT
2692
2693 // BOTTOM_LEFT_POINT
2698 }
2699 }
2700 // End of
2701 // if(m_context.m_currentDragPoint.x() < m_context.m_startDragPoint.x())
2702 else
2703 {
2704 // qDebug() << "Dragging from left to right";
2705
2707 {
2708 // qDebug() << "Dragging from top to bottom";
2709
2710 // TOP_LEFT_POINT
2714
2715 // TOP_RIGHT_POINT
2720
2721 // BOTTOM_RIGHT_POINT
2726
2727 // BOTTOM_LEFT_POINT
2732 }
2733 else
2734 {
2735 // qDebug() << "Dragging from bottom to top";
2736
2737 // TOP_LEFT_POINT
2742
2743 // TOP_RIGHT_POINT
2748
2749 // BOTTOM_RIGHT_POINT
2754
2755 // BOTTOM_LEFT_POINT
2759 }
2760 }
2761
2762 // qDebug() << "Now draw the lines with points:"
2763 //<< m_context.m_selectionPolygon.toString();
2764
2765 // Top line
2766 mp_selectionRectangeLine1->start->setCoords(
2768 mp_selectionRectangeLine1->end->setCoords(
2770
2771 // Only if we are drawing a selection rectangle for integration, do we
2772 // set arrow heads to the line.
2773 if(for_integration)
2774 {
2775 mp_selectionRectangeLine1->setHead(QCPLineEnding::esSpikeArrow);
2776 mp_selectionRectangeLine1->setTail(QCPLineEnding::esSpikeArrow);
2777 }
2778 else
2779 {
2780 mp_selectionRectangeLine1->setHead(QCPLineEnding::esNone);
2781 mp_selectionRectangeLine1->setTail(QCPLineEnding::esNone);
2782 }
2783
2784 mp_selectionRectangeLine1->setVisible(true);
2785
2786 // Right line
2787 mp_selectionRectangeLine2->start->setCoords(
2789 mp_selectionRectangeLine2->end->setCoords(
2791 mp_selectionRectangeLine2->setVisible(true);
2792
2793 // Bottom line
2794 mp_selectionRectangeLine3->start->setCoords(
2796 mp_selectionRectangeLine3->end->setCoords(
2798 mp_selectionRectangeLine3->setVisible(true);
2799
2800 // Left line
2801 mp_selectionRectangeLine4->start->setCoords(
2803 mp_selectionRectangeLine4->end->setCoords(
2805 mp_selectionRectangeLine4->setVisible(true);
2806}

References pappso::BOTTOM_LEFT_POINT, pappso::BOTTOM_RIGHT_POINT, pappso::SelectionPolygon::getPoint(), m_context, pappso::BasePlotContext::m_currentDragPoint, pappso::BasePlotContext::m_selectionPolygon, pappso::BasePlotContext::m_startDragPoint, mp_selectionRectangeLine1, mp_selectionRectangeLine2, mp_selectionRectangeLine3, mp_selectionRectangeLine4, pappso::SelectionPolygon::resetPoints(), pappso::SelectionPolygon::setPoint(), pappso::TOP_LEFT_POINT, and pappso::TOP_RIGHT_POINT.

Referenced by updateSelectionRectangle().

◆ updateAxesRangeHistory()

void pappso::BasePlotWidget::updateAxesRangeHistory ( )
virtual

Create new axis range history items and append them to the history.

The plot widget is queried to get the current x/y-axis ranges and the current ranges are appended to the history for x-axis and for y-axis.

Definition at line 512 of file baseplotwidget.cpp.

513{
514 m_xAxisRangeHistory.push_back(new QCPRange(xAxis->range()));
515 m_yAxisRangeHistory.push_back(new QCPRange(yAxis->range()));
516
518
519 // qDebug() << "axes history size:" << m_xAxisRangeHistory.size()
520 //<< "current index:" << m_lastAxisRangeHistoryIndex
521 //<< xAxis->range().lower << "--" << xAxis->range().upper << "and"
522 //<< yAxis->range().lower << "--" << yAxis->range().upper;
523}

References m_lastAxisRangeHistoryIndex, m_xAxisRangeHistory, and m_yAxisRangeHistory.

Referenced by axisDoubleClickHandler(), pappso::BaseTracePlotWidget::axisDoubleClickHandler(), axisReframe(), pappso::BaseTracePlotWidget::axisReframe(), axisZoom(), pappso::BaseTracePlotWidget::axisZoom(), mouseReleaseHandlerLeftButton(), and mouseWheelHandler().

◆ updateContextXandYAxisRanges()

void pappso::BasePlotWidget::updateContextXandYAxisRanges ( )
virtual

Definition at line 3252 of file baseplotwidget.cpp.

3253{
3254 m_context.m_xRange = QCPRange(xAxis->range().lower, xAxis->range().upper);
3255 m_context.m_yRange = QCPRange(yAxis->range().lower, yAxis->range().upper);
3256
3257 // qDebug() << "The new updated context: " << m_context.toString();
3258}

References m_context, pappso::BasePlotContext::m_xRange, and pappso::BasePlotContext::m_yRange.

Referenced by axisDoubleClickHandler(), pappso::BaseTracePlotWidget::axisDoubleClickHandler(), axisPan(), pappso::BaseTracePlotWidget::axisPan(), axisReframe(), pappso::BaseTracePlotWidget::axisReframe(), axisRescale(), pappso::BaseTracePlotWidget::axisRescale(), axisZoom(), pappso::BaseTracePlotWidget::axisZoom(), and restoreAxesRangeHistory().

◆ updateSelectionRectangle()

void pappso::BasePlotWidget::updateSelectionRectangle ( bool  as_line_segment = false,
bool  for_integration = false 
)
virtual

Definition at line 3072 of file baseplotwidget.cpp.

3074{
3075
3076 // qDebug() << "as_line_segment:" << as_line_segment;
3077 // qDebug() << "for_integration:" << for_integration;
3078
3079 // We now need to construct the selection rectangle, either for zoom or for
3080 // integration.
3081
3082 // There are two situations :
3083 //
3084 // 1. if the rectangle should look like a line segment
3085 //
3086 // 2. if the rectangle should actually look like a rectangle. In this case,
3087 // there are two sub-situations:
3088 //
3089 // a. if the S key is down, then the rectangle is
3090 // skewed, that is its vertical sides are not parallel to the y axis.
3091 //
3092 // b. otherwise the rectangle is conventional.
3093
3094 if(as_line_segment)
3095 {
3096 update1DSelectionRectangle(for_integration);
3097 }
3098 else
3099 {
3100 if(!(m_context.m_keyboardModifiers & Qt::AltModifier))
3101 {
3102 update2DSelectionRectangleSquare(for_integration);
3103 }
3104 else if(m_context.m_keyboardModifiers & Qt::AltModifier)
3105 {
3106 update2DSelectionRectangleSkewed(for_integration);
3107 }
3108 }
3109
3110 // This code automatically sorts the ranges (range start is always less than
3111 // range end) even if the user actually selects from high to low (right to
3112 // left or bottom to top). This has implications in code that uses the
3113 // m_context data to perform some computations. This is why it is important
3114 // that m_dragDirections be set correctly to establish where the current drag
3115 // point is actually located (at which point).
3116
3121
3126
3127 // At this point, draw the text describing the widths.
3128
3129 // We want the x-delta on the bottom of the rectangle, inside it
3130 // and the y-delta on the vertical side of the rectangle, inside it.
3131
3132 // Draw the selection width text
3134}
virtual void update2DSelectionRectangleSquare(bool for_integration=false)
virtual void update1DSelectionRectangle(bool for_integration=false)
virtual void update2DSelectionRectangleSkewed(bool for_integration=false)

References drawXDeltaFeatures(), pappso::SelectionPolygon::getBottomMostPoint(), pappso::SelectionPolygon::getLeftMostPoint(), pappso::SelectionPolygon::getRightMostPoint(), pappso::SelectionPolygon::getTopMostPoint(), m_context, pappso::BasePlotContext::m_keyboardModifiers, pappso::BasePlotContext::m_selectionPolygon, pappso::BasePlotContext::m_xRegionRangeEnd, pappso::BasePlotContext::m_xRegionRangeStart, pappso::BasePlotContext::m_yRegionRangeEnd, pappso::BasePlotContext::m_yRegionRangeStart, update1DSelectionRectangle(), update2DSelectionRectangleSkewed(), and update2DSelectionRectangleSquare().

Referenced by drawSelectionRectangleAndPrepareZoom().

◆ verticalGetGraphCoordNewPointCountPixels()

QPointF pappso::BasePlotWidget::verticalGetGraphCoordNewPointCountPixels ( int  pixel_count)
virtual

Definition at line 1864 of file baseplotwidget.cpp.

1865{
1866 QPointF pixel_coordinates(
1867 xAxis->coordToPixel(m_context.m_lastCursorHoveredPoint.x()),
1868 yAxis->coordToPixel(m_context.m_lastCursorHoveredPoint.y()) + pixel_count);
1869
1870 // Now convert back to local coordinates.
1871
1872 QPointF graph_coordinates(xAxis->pixelToCoord(pixel_coordinates.x()),
1873 yAxis->pixelToCoord(pixel_coordinates.y()));
1874
1875 return graph_coordinates;
1876}

References m_context, and pappso::BasePlotContext::m_lastCursorHoveredPoint.

Referenced by verticalMoveMouseCursorCountPixels().

◆ verticalMoveMouseCursorCountPixels()

void pappso::BasePlotWidget::verticalMoveMouseCursorCountPixels ( int  pixel_count)
virtual

Definition at line 1847 of file baseplotwidget.cpp.

1848{
1849
1850 QPointF graph_coord = verticalGetGraphCoordNewPointCountPixels(pixel_count);
1851
1852 QPointF pixel_coord(xAxis->coordToPixel(graph_coord.x()),
1853 yAxis->coordToPixel(graph_coord.y()));
1854
1855 // Now we need ton convert the new coordinates to the global position system
1856 // and to move the cursor to that new position. That will create an event to
1857 // move the mouse cursor.
1858
1859 moveMouseCursorPixelCoordToGlobal(pixel_coord.toPoint());
1860}
virtual QPointF verticalGetGraphCoordNewPointCountPixels(int pixel_count)

References moveMouseCursorPixelCoordToGlobal(), and verticalGetGraphCoordNewPointCountPixels().

Referenced by directionKeyPressEvent().

◆ whatIsVisibleOfTheSelectionRectangle()

PolygonType pappso::BasePlotWidget::whatIsVisibleOfTheSelectionRectangle ( )
virtual

Definition at line 3159 of file baseplotwidget.cpp.

3160{
3161 // There are four lines that make the selection polygon. We want to know
3162 // which lines are visible.
3163
3164 int current_selection_polygon = static_cast<int>(PolygonType::NOT_SET);
3165
3166 if(mp_selectionRectangeLine1->visible())
3167 {
3168 current_selection_polygon |= static_cast<int>(PolygonType::TOP_LINE);
3169 // qDebug() << "current_selection_polygon:" << current_selection_polygon;
3170 }
3171 if(mp_selectionRectangeLine2->visible())
3172 {
3173 current_selection_polygon |= static_cast<int>(PolygonType::RIGHT_LINE);
3174 // qDebug() << "current_selection_polygon:" << current_selection_polygon;
3175 }
3176 if(mp_selectionRectangeLine3->visible())
3177 {
3178 current_selection_polygon |= static_cast<int>(PolygonType::BOTTOM_LINE);
3179 // qDebug() << "current_selection_polygon:" << current_selection_polygon;
3180 }
3181 if(mp_selectionRectangeLine4->visible())
3182 {
3183 current_selection_polygon |= static_cast<int>(PolygonType::LEFT_LINE);
3184 // qDebug() << "current_selection_polygon:" << current_selection_polygon;
3185 }
3186
3187 // qDebug() << "returning visibility:" << current_selection_polygon;
3188
3189 return static_cast<PolygonType>(current_selection_polygon);
3190}

References pappso::BOTTOM_LINE, pappso::LEFT_LINE, mp_selectionRectangeLine1, mp_selectionRectangeLine2, mp_selectionRectangeLine3, mp_selectionRectangeLine4, pappso::NOT_SET, pappso::RIGHT_LINE, and pappso::TOP_LINE.

Referenced by mouseReleaseHandlerLeftButton().

◆ xAxisMeasurementSignal

void pappso::BasePlotWidget::xAxisMeasurementSignal ( const BasePlotContext context,
bool  with_delta 
)
signal

◆ yMinMaxOnXAxisCurrentRange() [1/2]

void pappso::BasePlotWidget::yMinMaxOnXAxisCurrentRange ( double &  min,
double &  max,
int  index 
)

◆ yMinMaxOnXAxisCurrentRange() [2/2]

void pappso::BasePlotWidget::yMinMaxOnXAxisCurrentRange ( double &  min,
double &  max,
QCPAbstractPlottable *  plottable_p = nullptr 
)

Member Data Documentation

◆ m_axisLabelX

QString pappso::BasePlotWidget::m_axisLabelX
protected

Definition at line 253 of file baseplotwidget.h.

◆ m_axisLabelY

QString pappso::BasePlotWidget::m_axisLabelY
protected

Definition at line 254 of file baseplotwidget.h.

◆ m_context

BasePlotContext pappso::BasePlotWidget::m_context
protected

Definition at line 256 of file baseplotwidget.h.

Referenced by pappso::DriftSpecTracePlotWidget::DriftSpecTracePlotWidget(), pappso::MassSpecTracePlotWidget::MassSpecTracePlotWidget(), pappso::TicXicChromTracePlotWidget::TicXicChromTracePlotWidget(), axisDoubleClickHandler(), pappso::BaseTracePlotWidget::axisDoubleClickHandler(), axisPan(), pappso::BaseTracePlotWidget::axisPan(), axisReframe(), pappso::BaseTracePlotWidget::axisReframe(), axisRescale(), pappso::BaseTracePlotWidget::axisRescale(), axisZoom(), pappso::BaseTracePlotWidget::axisZoom(), calculateDragDeltas(), pappso::BaseColorMapPlotWidget::currentXaxisRangeIndices(), pappso::BaseColorMapPlotWidget::currentYaxisRangeIndices(), directionKeyPressEvent(), dragDirection(), drawSelectionRectangleAndPrepareZoom(), drawXDeltaFeatures(), drawYDeltaFeatures(), getContext(), horizontalGetGraphCoordNewPointCountPixels(), isVerticalDisplacementAboveThreshold(), keyPressEvent(), pappso::DriftSpecTracePlotWidget::keyPressEvent(), pappso::TicXicChromTracePlotWidget::keyPressEvent(), keyReleaseEvent(), mouseMoveHandler(), mouseMoveHandlerDraggingCursor(), mouseMoveHandlerLeftButtonDraggingCursor(), mouseMoveHandlerNotDraggingCursor(), mouseMoveHandlerRightButtonDraggingCursor(), mousePressHandler(), mousePseudoButtonKeyReleaseEvent(), mouseReleaseHandler(), mouseReleaseHandlerLeftButton(), mouseReleaseHandlerRightButton(), mouseWheelHandler(), pappso::MassSpecTracePlotWidget::refreshBaseContext(), resetSelectionRectangle(), restoreAxesRangeHistory(), update1DSelectionRectangle(), update2DSelectionRectangleSkewed(), update2DSelectionRectangleSquare(), updateContextXandYAxisRanges(), updateSelectionRectangle(), and verticalGetGraphCoordNewPointCountPixels().

◆ m_desc

QString pappso::BasePlotWidget::m_desc = "NOT_SET"
protected

Description of the plot widget.

Definition at line 248 of file baseplotwidget.h.

◆ m_fileName

QString pappso::BasePlotWidget::m_fileName
protected

The name of the data file from which the mass data were read.

Definition at line 251 of file baseplotwidget.h.

◆ m_focusedBrush

QBrush pappso::BasePlotWidget::m_focusedBrush = QBrush(m_focusedColor)
protected

Color used for the background of focused plot.

Definition at line 337 of file baseplotwidget.h.

Referenced by redrawPlotBackground().

◆ m_focusedColor

QColor pappso::BasePlotWidget::m_focusedColor = QColor(Qt::transparent)
protected

Color used for the background of focused plot.

Definition at line 335 of file baseplotwidget.h.

◆ m_lastAxisRangeHistoryIndex

std::size_t pappso::BasePlotWidget::m_lastAxisRangeHistoryIndex = 0
protected

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.

Definition at line 298 of file baseplotwidget.h.

Referenced by resetAxesRangeHistory(), restorePreviousAxesRangeHistory(), and updateAxesRangeHistory().

◆ m_leftMousePseudoButtonKey

int pappso::BasePlotWidget::m_leftMousePseudoButtonKey = Qt::Key_Less
protected

◆ m_mouseMoveHandlerSkipAmount

int pappso::BasePlotWidget::m_mouseMoveHandlerSkipAmount = 10
protected

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.

Definition at line 316 of file baseplotwidget.h.

Referenced by mouseMoveHandlerLeftButtonDraggingCursor().

◆ m_mouseMoveHandlerSkipCount

int pappso::BasePlotWidget::m_mouseMoveHandlerSkipCount = 0
protected

Counter to handle the "fat data" mouse move event handling.

See also
m_mouseMoveHandlerSkipAmount.

Definition at line 324 of file baseplotwidget.h.

Referenced by mouseMoveHandlerLeftButtonDraggingCursor(), and mouseReleaseHandler().

◆ m_name

QString pappso::BasePlotWidget::m_name = "NOT_SET"
protected

Name of the plot widget.

Definition at line 245 of file baseplotwidget.h.

◆ m_pen

QPen pappso::BasePlotWidget::m_pen
protected

Pen used to draw the graph and textual elements in the plot widget.

Definition at line 340 of file baseplotwidget.h.

Referenced by BasePlotWidget(), createAllAncillaryItems(), getPen(), pappso::BaseTracePlotWidget::setGraphData(), and setPen().

◆ m_rightMousePseudoButtonKey

int pappso::BasePlotWidget::m_rightMousePseudoButtonKey = Qt::Key_Greater
protected

◆ m_shouldTracersBeVisible

bool pappso::BasePlotWidget::m_shouldTracersBeVisible = true
protected

Tells if the tracers should be visible.

Definition at line 275 of file baseplotwidget.h.

Referenced by hideTracers(), keyReleaseEvent(), mouseMoveHandlerDraggingCursor(), mouseMoveHandlerNotDraggingCursor(), mousePressHandler(), and showTracers().

◆ m_unfocusedBrush

QBrush pappso::BasePlotWidget::m_unfocusedBrush = QBrush(m_unfocusedColor)
protected

Color used for the background of unfocused plot.

Definition at line 332 of file baseplotwidget.h.

Referenced by redrawPlotBackground().

◆ m_unfocusedColor

QColor pappso::BasePlotWidget::m_unfocusedColor = QColor("lightgray")
protected

Color used for the background of unfocused plot.

Definition at line 330 of file baseplotwidget.h.

◆ m_xAxisRangeHistory

std::vector<QCPRange *> pappso::BasePlotWidget::m_xAxisRangeHistory
protected

List of x axis ranges occurring during the panning zooming actions.

Definition at line 301 of file baseplotwidget.h.

Referenced by ~BasePlotWidget(), resetAxesRangeHistory(), restoreAxesRangeHistory(), and updateAxesRangeHistory().

◆ m_yAxisRangeHistory

std::vector<QCPRange *> pappso::BasePlotWidget::m_yAxisRangeHistory
protected

List of y axis ranges occurring during the panning zooming actions.

Definition at line 304 of file baseplotwidget.h.

Referenced by ~BasePlotWidget(), resetAxesRangeHistory(), restoreAxesRangeHistory(), and updateAxesRangeHistory().

◆ mp_hPosTracerItem

◆ mp_selectionRectangeLine1

QCPItemLine* pappso::BasePlotWidget::mp_selectionRectangeLine1 = nullptr
protected

◆ mp_selectionRectangeLine2

◆ mp_selectionRectangeLine3

◆ mp_selectionRectangeLine4

◆ mp_vEndTracerItem

◆ mp_vPosTracerItem

◆ mp_vStartTracerItem

QCPItemLine* pappso::BasePlotWidget::mp_vStartTracerItem = nullptr
protected

◆ mp_xDeltaTextItem

QCPItemText* pappso::BasePlotWidget::mp_xDeltaTextItem = nullptr
protected

Text describing the x-axis delta value during a drag operation.

Definition at line 271 of file baseplotwidget.h.

Referenced by createAllAncillaryItems(), drawSelectionRectangleAndPrepareZoom(), drawXDeltaFeatures(), hideAllPlotItems(), mouseReleaseHandler(), and mouseReleaseHandlerRightButton().

◆ mp_yDeltaTextItem

QCPItemText* pappso::BasePlotWidget::mp_yDeltaTextItem = nullptr
protected

The documentation for this class was generated from the following files: