pappso::BasePlotWidget Class Reference

#include <baseplotwidget.h>

Inheritance diagram for pappso::BasePlotWidget:

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	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	mouseMoveHandler (QMouseEvent *event)
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 (PlotAxis 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, PlotAxis whichAxis)
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	drawRectangleAndPrepareZoom ()
virtual void	prepareXDeltaLineAndMeasure ()
virtual void	drawXDeltaLineAndMeasure ()
virtual void	drawXDeltaLineForIntegration ()
virtual void	calculateDragDeltas ()
virtual void	calculateDragDeltasAndUnSortedRegionCorners ()
virtual bool	isProperSelectionRectangle ()
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	updateContextRanges ()
virtual const BasePlotContext &	getContext () 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
QCPItemRect *	mp_zoomRectItem = nullptr
	Rectangle defining the borders of zoomed-in/out data. More...
QCPItemLine *	mp_selectLineItem = nullptr
	Line that is printed when the user selects a range. More...
QCPItemText *	mp_xDeltaTextItem = nullptr
	Text describing the x-axis delta value during a drag operation. More...
bool	m_shouldTracersBeVisible = true
	Tells if the tracers should be visible. More...
QCPItemLine *	mp_hPosTracerItem
	Horizontal position tracer. More...
QCPItemLine *	mp_vPosTracerItem
	Vertical position tracer. More...
QCPItemLine *	mp_vStartTracerItem
	Vertical selection start tracer (typically in green). More...
QCPItemLine *	mp_vEndTracerItem
	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 135 of file baseplotwidget.h.

Constructor & Destructor Documentation

BasePlotWidget() [1/2]

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

explicit

Definition at line 111 of file baseplotwidget.cpp.

                                              : QCustomPlot(parent)
{
  // qDebug();
 
  if(parent == nullptr)
    qFatal("Programming error.");
 
  // Default settings for the pen used to graph the data.
  m_pen.setStyle(Qt::SolidLine);
  m_pen.setBrush(Qt::black);
  m_pen.setWidth(1);
 
  if(!setupWidget())
    qFatal("Programming error.");
 
  show();
}

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 130 of file baseplotwidget.cpp.

  : QCustomPlot(parent), m_axisLabelX(x_axis_label), m_axisLabelY(y_axis_label)
{
  // qDebug();
 
  if(parent == nullptr)
    qFatal("Programming error.");
 
  // Default settings for the pen used to graph the data.
  m_pen.setStyle(Qt::SolidLine);
  m_pen.setBrush(Qt::black);
  m_pen.setWidth(1);
 
  xAxis->setLabel(x_axis_label);
  yAxis->setLabel(y_axis_label);
 
  if(!setupWidget())
    qFatal("Programming error.");
 
  show();
}

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.

{
  // qDebug() << "In the destructor of plot widget:" << this;
 
  m_xAxisRangeHistory.clear();
  m_yAxisRangeHistory.clear();
}

References m_xAxisRangeHistory, and m_yAxisRangeHistory.

Member Function Documentation

axisDoubleClickHandler()

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

virtual

Reimplemented in pappso::BaseTracePlotWidget.

Definition at line 1343 of file baseplotwidget.cpp.

{
 
  m_context.keyboardModifiers = QGuiApplication::queryKeyboardModifiers();
 
  if(m_context.keyboardModifiers & Qt::ControlModifier)
    {
 
      // If the Ctrl modifiers is active, then both axes are to be reset. Also
      // the histories are reset also.
 
      rescaleAxes();
      resetAxesRangeHistory();
    }
  else
    {
      // Only the axis passed as parameter is to be rescaled.
      // Reset the range of that axis to the max view possible.
 
      axis->rescale();
 
      updateAxesRangeHistory();
 
      event->accept();
    }
 
  // The double-click event does not cancel the mouse press event. That is, if
  // left-double-clicking, at the end of the operation the button still
  // "pressed". We need to remove manually the button from the pressed buttons
  // context member.
 
  m_context.pressedMouseButtons ^= event->button();
 
  updateContextRanges();
 
  emit plotRangesChangedSignal(m_context);
 
  replot();
}

References pappso::BasePlotContext::keyboardModifiers, m_context, plotRangesChangedSignal(), pappso::BasePlotContext::pressedMouseButtons, resetAxesRangeHistory(), updateAxesRangeHistory(), and updateContextRanges().

Referenced by setupWidget().

axisPan()

void pappso::BasePlotWidget::axisPan ( )

virtual

Reimplemented in pappso::BaseTracePlotWidget.

Definition at line 1852 of file baseplotwidget.cpp.

{
  if(m_context.wasClickOnXAxis)
    {
      xAxis->setRange(m_context.xRange.lower - m_context.xDelta,
                      m_context.xRange.upper - m_context.xDelta);
    }
 
  if(m_context.wasClickOnYAxis)
    {
      yAxis->setRange(m_context.yRange.lower - m_context.yDelta,
                      m_context.yRange.upper - m_context.yDelta);
    }
 
  updateContextRanges();
 
  // We cannot store the new ranges in the history, because the pan operation
  // involved a huge quantity of micro-movements elicited upon each mouse move
  // cursor event so we would have a huge history.
  // updateAxesRangeHistory();
 
  // Now that the contex has the right range values, we can emit the
  // signal that will be used by this plot widget users, typically to
  // abide by the x/y range lock required by the user.
 
  emit plotRangesChangedSignal(m_context);
 
  replot();
}

References m_context, plotRangesChangedSignal(), updateContextRanges(), pappso::BasePlotContext::wasClickOnXAxis, pappso::BasePlotContext::wasClickOnYAxis, pappso::BasePlotContext::xDelta, pappso::BasePlotContext::xRange, pappso::BasePlotContext::yDelta, and pappso::BasePlotContext::yRange.

Referenced by mouseMoveHandlerLeftButtonDraggingCursor().

axisReframe()

void pappso::BasePlotWidget::axisReframe ( )

virtual

Reimplemented in pappso::BaseTracePlotWidget.

Definition at line 1795 of file baseplotwidget.cpp.

{
 
  // double sorted_start_drag_point_x =
  // std::min(m_context.startDragPoint.x(), m_context.currentDragPoint.x());
 
  // xAxis->setRange(sorted_start_drag_point_x,
  // sorted_start_drag_point_x + fabs(m_context.xDelta));
 
  xAxis->setRange(
    QCPRange(m_context.xRegionRangeStart, m_context.xRegionRangeEnd));
 
  // Note that the y axis should be rescaled from current lower value to new
  // upper value matching the y-axis position of the cursor when the mouse
  // button was released.
 
  yAxis->setRange(
    xAxis->range().lower,
    std::max<double>(m_context.yRegionRangeStart, m_context.yRegionRangeEnd));
 
  // qDebug() << "xaxis:" << xAxis->range().lower << "-" <<
  // xAxis->range().upper
  //<< "yaxis:" << yAxis->range().lower << "-" << yAxis->range().upper;
 
  updateContextRanges();
 
  updateAxesRangeHistory();
  emit plotRangesChangedSignal(m_context);
 
  replot();
}

References m_context, plotRangesChangedSignal(), updateAxesRangeHistory(), updateContextRanges(), pappso::BasePlotContext::xRegionRangeEnd, pappso::BasePlotContext::xRegionRangeStart, pappso::BasePlotContext::yRegionRangeEnd, and pappso::BasePlotContext::yRegionRangeStart.

Referenced by mouseReleaseHandlerLeftButton().

axisRescale()

void pappso::BasePlotWidget::axisRescale ( )

virtual

RANGE-related functions.

PLOTTING / REPLOTTING functions

Reimplemented in pappso::BaseTracePlotWidget.

Definition at line 1713 of file baseplotwidget.cpp.

{
  double xLower = xAxis->range().lower;
  double xUpper = xAxis->range().upper;
 
  // Get the current y lower/upper range.
  double yLower = yAxis->range().lower;
  double yUpper = yAxis->range().upper;
 
  // This function is called only when the user has clicked on the x/y axis or
  // when the user has dragged the left mouse button with the Ctrl key
  // modifier. The m_context.wasClickOnXAxis is then simulated in the mouse
  // move handler. So we need to test which axis was clicked-on.
 
  if(m_context.wasClickOnXAxis)
    {
 
      // We are changing the range of the X axis.
 
      // What is the x delta ?
      double xDelta =
        m_context.currentDragPoint.x() - m_context.startDragPoint.x();
 
      // If xDelta is < 0, the  we were dragging from right to left, we are
      // compressing the view on the x axis, by adding new data to the right
      // hand size of the graph. So we add xDelta to the upper bound of the
      // range. Otherwise we are uncompressing the view on the x axis and
      // remove the xDelta from the upper bound of the range. This is why we
      // have the
      // '-'
      // and not '+' below;
 
      // qDebug() << "Setting xaxis:" << xLower << "--" << xUpper - xDelta;
 
      xAxis->setRange(xLower, xUpper - xDelta);
    }
  // End of
  // if(m_context.wasClickOnXAxis)
  else // that is, if(m_context.wasClickOnYAxis)
    {
      // We are changing the range of the Y axis.
 
      // What is the y delta ?
      double yDelta =
        m_context.currentDragPoint.y() - m_context.startDragPoint.y();
 
      // See above for an explanation of the computation.
 
      yAxis->setRange(yLower, yUpper - yDelta);
 
      // Old version
      // if(yDelta < 0)
      //{
      //// The dragging operation was from top to bottom, we are enlarging
      //// the range (thus, we are unzooming the view, since the widget
      //// always has the same size).
 
      // yAxis->setRange(yLower, yUpper + fabs(yDelta));
      //}
      // else
      //{
      //// The dragging operation was from bottom to top, we are reducing
      //// the range (thus, we are zooming the view, since the widget
      //// always has the same size).
 
      // yAxis->setRange(yLower, yUpper - fabs(yDelta));
      //}
    }
  // End of
  // else // that is, if(m_context.wasClickOnYAxis)
 
  // Update the context with the current axes ranges
 
  updateContextRanges();
 
  emit plotRangesChangedSignal(m_context);
 
  replot();
}

References pappso::BasePlotContext::currentDragPoint, m_context, plotRangesChangedSignal(), pappso::BasePlotContext::startDragPoint, updateContextRanges(), and pappso::BasePlotContext::wasClickOnXAxis.

Referenced by mouseMoveHandlerLeftButtonDraggingCursor().

axisZoom()

void pappso::BasePlotWidget::axisZoom ( )

virtual

Reimplemented in pappso::BaseTracePlotWidget.

Definition at line 1829 of file baseplotwidget.cpp.

{
 
  // Use the m_context.xRegionRangeStart/End values, but we need to sort the
  // values before using them, because now we want to really have the lower x
  // value. Simply craft a QCPRange that will swap the values if lower is not
  // < than upper QCustomPlot calls this normalization).
 
  xAxis->setRange(
    QCPRange(m_context.xRegionRangeStart, m_context.xRegionRangeEnd));
 
  yAxis->setRange(
    QCPRange(m_context.yRegionRangeStart, m_context.yRegionRangeEnd));
 
  updateContextRanges();
 
  updateAxesRangeHistory();
  emit plotRangesChangedSignal(m_context);
 
  replot();
}

References m_context, plotRangesChangedSignal(), updateAxesRangeHistory(), updateContextRanges(), pappso::BasePlotContext::xRegionRangeEnd, pappso::BasePlotContext::xRegionRangeStart, pappso::BasePlotContext::yRegionRangeEnd, and pappso::BasePlotContext::yRegionRangeStart.

Referenced by mouseReleaseHandlerLeftButton().

calculateDragDeltas()

void pappso::BasePlotWidget::calculateDragDeltas ( )

virtual

Definition at line 2122 of file baseplotwidget.cpp.

{
 
  // We compute signed differentials. If the user does not want the sign,
  // fabs(double) is their friend.
 
  // Compute the xAxis differential:
 
  m_context.xDelta =
    m_context.currentDragPoint.x() - m_context.startDragPoint.x();
 
  // Same with the Y-axis range:
 
  m_context.yDelta =
    m_context.currentDragPoint.y() - m_context.startDragPoint.y();
 
  // qDebug() << "xDelta:" << m_context.xDelta
  //<< "and yDelta:" << m_context.yDelta;
 
  return;
}

References pappso::BasePlotContext::currentDragPoint, m_context, pappso::BasePlotContext::startDragPoint, pappso::BasePlotContext::xDelta, and pappso::BasePlotContext::yDelta.

Referenced by calculateDragDeltasAndUnSortedRegionCorners().

calculateDragDeltasAndUnSortedRegionCorners()

void pappso::BasePlotWidget::calculateDragDeltasAndUnSortedRegionCorners ( )

virtual

Definition at line 2146 of file baseplotwidget.cpp.

{
 
  calculateDragDeltas();
 
  // Note that we do not sort the x value nor the y values. If the user of the
  // ranges need them to be sorted, they can use the sortAscendingRange().
 
  m_context.xRegionRangeStart = m_context.startDragPoint.x();
  m_context.xRegionRangeEnd   = m_context.currentDragPoint.x();
 
  m_context.yRegionRangeStart = m_context.startDragPoint.y();
  m_context.yRegionRangeEnd   = m_context.currentDragPoint.y();
 
  return;
}

References calculateDragDeltas(), pappso::BasePlotContext::currentDragPoint, m_context, pappso::BasePlotContext::startDragPoint, pappso::BasePlotContext::xRegionRangeEnd, pappso::BasePlotContext::xRegionRangeStart, pappso::BasePlotContext::yRegionRangeEnd, and pappso::BasePlotContext::yRegionRangeStart.

Referenced by mouseMoveHandlerDraggingCursor(), and mouseReleaseHandler().

directionKeyPressEvent()

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

virtual

Definition at line 647 of file baseplotwidget.cpp.

{
  // qDebug() << "event key:" << event->key();
 
  // The user is trying to move the positional cursor/markers. There are
  // multiple way they can do that:
  //
  // 1.a. Hitting the arrow left/right keys alone will search for next pixel.
  // 1.b. Hitting the arrow left/right keys with Alt modifier will search for a
  // multiple of pixels that might be equivalent to one 20th of the pixel width
  // of the plot widget.
  // 1.c Hitting the left/right keys with Alt and Shift modifiers will search
  // for a multiple of pixels that might be the equivalent to half of the pixel
  // width.
  //
  // 2. Hitting the Control modifier will move the cursor to the next data point
  // of the graph.
 
  int pixel_increment = 0;
 
  if(m_context.keyboardModifiers == Qt::NoModifier)
    pixel_increment = 1;
  else if(m_context.keyboardModifiers == Qt::AltModifier)
    pixel_increment = 50;
 
  // The user is moving the positional markers. This is equivalent to a
  // non-dragging cursor movement to the next pixel. Note that the origin is
  // located at the top left, so key down increments and key up decrements.
 
  if(event->key() == Qt::Key_Left)
    horizontalMoveMouseCursorCountPixels(-pixel_increment);
  else if(event->key() == Qt::Key_Right)
    horizontalMoveMouseCursorCountPixels(pixel_increment);
  else if(event->key() == Qt::Key_Up)
    verticalMoveMouseCursorCountPixels(-pixel_increment);
  else if(event->key() == Qt::Key_Down)
    verticalMoveMouseCursorCountPixels(pixel_increment);
 
  event->accept();
}

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

Referenced by keyPressEvent().

directionKeyReleaseEvent()

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

virtual

Definition at line 690 of file baseplotwidget.cpp.

{
  // qDebug() << "event key:" << event->key();
  event->accept();
}

Referenced by keyReleaseEvent().

dragDirection()

int pappso::BasePlotWidget::dragDirection

(

)

MOUSE-related EVENTS.

MOUSE MOVEMENTS mouse/keyboard-triggered

Definition at line 1445 of file baseplotwidget.cpp.

{
  // The user is dragging the mouse, probably to rescale the axes, but we need
  // to sort out in which direction the drag is happening.
 
  // This function should be called after calculateDragDeltas, so that
  // m_context has the proper x/y delta values that we'll compare.
 
  // Note that we cannot compare simply x or y deltas because the y axis might
  // have a different scale that the x axis. So we first need to convert the
  // positions to pixels.
 
  double x_delta_pixel =
    fabs(xAxis->coordToPixel(m_context.currentDragPoint.x()) -
         xAxis->coordToPixel(m_context.startDragPoint.x()));
 
  double y_delta_pixel =
    fabs(yAxis->coordToPixel(m_context.currentDragPoint.y()) -
         yAxis->coordToPixel(m_context.startDragPoint.y()));
 
  if(x_delta_pixel > y_delta_pixel)
    return Qt::Horizontal;
 
  return Qt::Vertical;
}

References pappso::BasePlotContext::currentDragPoint, m_context, and pappso::BasePlotContext::startDragPoint.

drawRectangleAndPrepareZoom()

void pappso::BasePlotWidget::drawRectangleAndPrepareZoom ( )

virtual

Definition at line 1985 of file baseplotwidget.cpp.

{
  // The user has drawn the mouse left button on the graph, which means he is
  // willing to draw a zoom rectangle.
 
  mp_selectLineItem->setVisible(false);
 
  mp_xDeltaTextItem->setVisible(false);
 
  mp_zoomRectItem->topLeft->setCoords(m_context.startDragPoint.x(),
                                      m_context.startDragPoint.y());
  mp_zoomRectItem->bottomRight->setCoords(m_context.currentDragPoint.x(),
                                          m_context.currentDragPoint.y());
 
  mp_zoomRectItem->setVisible(true);
 
  // Now set the geometry of the rectangle to the context so that upon the
  // mouse button release, if the zoom rectanble is visible we know how to
  // reframe the plot axes. Note that we do not sort the values, if that is
  // required the user needs to use the sortAscendingRange() function.
 
  m_context.xRegionRangeStart = m_context.startDragPoint.x();
  m_context.xRegionRangeEnd   = m_context.currentDragPoint.x();
 
  m_context.yRegionRangeStart = m_context.startDragPoint.y();
  m_context.yRegionRangeEnd   = m_context.currentDragPoint.y();
 
  // Note that if we draw a zoom rectangle, then we are certainly not
  // measuring anything. So set the boolean value to false so that the user of
  // this widget or derived classes know that there is nothing to perform upon
  // (like deconvolution, for example).
 
  m_context.isMeasuringDistance = false;
 
  // Also remove the delta value from the pipeline by sending a simple
  // distance without measurement signal.
 
  emit xAxisMeasurementSignal(m_context, false);
 
  replot();
}

References pappso::BasePlotContext::currentDragPoint, pappso::BasePlotContext::isMeasuringDistance, m_context, mp_selectLineItem, mp_xDeltaTextItem, mp_zoomRectItem, pappso::BasePlotContext::startDragPoint, xAxisMeasurementSignal(), pappso::BasePlotContext::xRegionRangeEnd, pappso::BasePlotContext::xRegionRangeStart, pappso::BasePlotContext::yRegionRangeEnd, and pappso::BasePlotContext::yRegionRangeStart.

Referenced by mouseMoveHandlerLeftButtonDraggingCursor().

drawXDeltaLineAndMeasure()

void pappso::BasePlotWidget::drawXDeltaLineAndMeasure ( )

virtual

Definition at line 2088 of file baseplotwidget.cpp.

{
  prepareXDeltaLineAndMeasure();
 
  // Also, we do not want arrows, because we are not integrating anything
  // here.
  mp_selectLineItem->setHead(QCPLineEnding::esNone);
  mp_selectLineItem->setTail(QCPLineEnding::esNone);
 
  replot();
 
  // Let the caller know that we were measuring something.
  emit xAxisMeasurementSignal(m_context, true);
}

References m_context, mp_selectLineItem, prepareXDeltaLineAndMeasure(), and xAxisMeasurementSignal().

Referenced by mouseMoveHandlerLeftButtonDraggingCursor().

drawXDeltaLineForIntegration()

void pappso::BasePlotWidget::drawXDeltaLineForIntegration ( )

virtual

Definition at line 2105 of file baseplotwidget.cpp.

{
  prepareXDeltaLineAndMeasure();
 
  // Since we draw the selection line with the xDelta text for integration, we
  // let the user guess it by the arrows at the ends of the line.
  mp_selectLineItem->setHead(QCPLineEnding::esSpikeArrow);
  mp_selectLineItem->setTail(QCPLineEnding::esSpikeArrow);
 
  replot();
 
  // Let the caller know that we were measuring something.
  emit xAxisMeasurementSignal(m_context, true);
}

References m_context, mp_selectLineItem, prepareXDeltaLineAndMeasure(), and xAxisMeasurementSignal().

Referenced by mouseMoveHandlerRightButtonDraggingCursor().

getContext()

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

virtual

Definition at line 2228 of file baseplotwidget.cpp.

{
  return m_context;
}

References m_context.

getInnermostRangeX()

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

virtual

Definition at line 1678 of file baseplotwidget.cpp.

{
 
  return getRange(PlotAxis::x_axis, RangeType::innermost, found_range);
}

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

getInnermostRangeY()

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

virtual

Definition at line 1693 of file baseplotwidget.cpp.

{
 
  return getRange(PlotAxis::y_axis, RangeType::innermost, found_range);
}

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

getOutermostRangeX()

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

virtual

Definition at line 1686 of file baseplotwidget.cpp.

{
  return getRange(PlotAxis::x_axis, RangeType::outermost, found_range);
}

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

getOutermostRangeY()

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

virtual

Definition at line 1701 of file baseplotwidget.cpp.

{
  return getRange(PlotAxis::y_axis, RangeType::outermost, found_range);
}

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

getPen()

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

virtual

Definition at line 288 of file baseplotwidget.cpp.

{
  return m_pen;
}

References m_pen.

getPlottingColor() [1/2]

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

virtual

Reimplemented in pappso::BaseColorMapPlotWidget.

Definition at line 338 of file baseplotwidget.cpp.

{
  QCPGraph *graph_p = graph(index);
 
  if(graph_p == nullptr)
    qFatal("Programming error.");
 
  return getPlottingColor(graph_p);
}

References getPlottingColor().

getPlottingColor() [2/2]

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

virtual

Definition at line 328 of file baseplotwidget.cpp.

{
  if(plottable_p == nullptr)
    qFatal("Programming error.");
 
  return plottable_p->pen().color();
}

Referenced by getPlottingColor().

getRange()

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

Definition at line 1586 of file baseplotwidget.cpp.

{
 
  // Iterate in all the graphs in this widget and return a QCPRange that has
  // its lower member as the greatest lower value of all
  // its upper member as the smallest upper value of all
 
  if(!graphCount())
    {
      found_range = false;
 
      return QCPRange(0, 1);
    }
 
  if(graphCount() == 1)
    return graph()->getKeyRange(found_range);
 
  bool found_at_least_one_range = false;
 
  // Create an invalid range.
  QCPRange result_range(QCPRange::minRange + 1, QCPRange::maxRange + 1);
 
  for(int iter = 0; iter < graphCount(); ++iter)
    {
      QCPRange temp_range;
 
      bool found_range_for_iter = false;
 
      QCPGraph *graph_p = graph(iter);
 
      // Depending on the axis param, select the key or value range.
 
      if(axis == PlotAxis::x_axis)
        temp_range = graph_p->getKeyRange(found_range_for_iter);
      else if(axis == PlotAxis::y_axis)
        temp_range = graph_p->getValueRange(found_range_for_iter);
      else
        qFatal("Cannot reach this point. Programming error.");
 
      // Was a range found for the iterated graph ? If not skip this
      // iteration.
 
      if(!found_range_for_iter)
        continue;
 
      // While the innermost_range is invalid, we need to seed it with a good
      // one. So check this.
 
      if(!QCPRange::validRange(result_range))
        qFatal("The obtained range is invalid !");
 
      // At this point we know the obtained range is OK.
      result_range = temp_range;
 
      // We found at least one valid range!
      found_at_least_one_range = true;
 
      // At this point we have two valid ranges to compare. Depending on
      // range_type, we need to perform distinct comparisons.
 
      if(range_type == RangeType::innermost)
        {
          if(temp_range.lower > result_range.lower)
            result_range.lower = temp_range.lower;
          if(temp_range.upper < result_range.upper)
            result_range.upper = temp_range.upper;
        }
      else if(range_type == RangeType::outermost)
        {
          if(temp_range.lower < result_range.lower)
            result_range.lower = temp_range.lower;
          if(temp_range.upper > result_range.upper)
            result_range.upper = temp_range.upper;
        }
      else
        qFatal("Cannot reach this point. Programming error.");
 
      // Continue to next graph, if any.
    }
  // End of
  // for(int iter = 0; iter < graphCount(); ++iter)
 
  // Let the caller know if we found at least one range.
  found_range = found_at_least_one_range;
 
  return result_range;
}

References pappso::innermost, pappso::outermost, pappso::x_axis, and pappso::y_axis.

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 1562 of file baseplotwidget.cpp.

{
  QCPGraph *graph_p = graph(index);
 
  if(graph_p == nullptr)
    qFatal("Programming error.");
 
  return graph_p->getKeyRange(found_range);
}

getRangeY()

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

virtual

Definition at line 1574 of file baseplotwidget.cpp.

{
  QCPGraph *graph_p = graph(index);
 
  if(graph_p == nullptr)
    qFatal("Programming error.");
 
  return graph_p->getValueRange(found_range);
}

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 1935 of file baseplotwidget.cpp.

{
  mp_selectLineItem->setVisible(false);
 
  mp_xDeltaTextItem->setVisible(false);
 
  mp_zoomRectItem->setVisible(false);
 
  // Force a replot to make sure the action is immediately visible by the
  // user, even without moving the mouse.
  replot();
}

References mp_selectLineItem, mp_xDeltaTextItem, and mp_zoomRectItem.

Referenced by restoreAxesRangeHistory().

hideTracers()

void pappso::BasePlotWidget::hideTracers ( )

virtual

Hide the traces (vertical and horizontal).

Definition at line 1969 of file baseplotwidget.cpp.

{
  m_shouldTracersBeVisible = false;
  mp_hPosTracerItem->setVisible(false);
  mp_vPosTracerItem->setVisible(false);
 
  mp_vStartTracerItem->setVisible(false);
  mp_vEndTracerItem->setVisible(false);
 
  // Force a replot to make sure the action is immediately visible by the
  // user, even without moving the mouse.
  replot();
}

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 1509 of file baseplotwidget.cpp.

{
  QPointF pixel_coordinates(
    xAxis->coordToPixel(m_context.lastCursorHoveredPoint.x()) + pixel_count,
    yAxis->coordToPixel(m_context.lastCursorHoveredPoint.y()));
 
  // Now convert back to local coordinates.
 
  QPointF graph_coordinates(xAxis->pixelToCoord(pixel_coordinates.x()),
                            yAxis->pixelToCoord(pixel_coordinates.y()));
 
  return graph_coordinates;
}

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

Referenced by horizontalMoveMouseCursorCountPixels().

horizontalMoveMouseCursorCountPixels()

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

virtual

Definition at line 1493 of file baseplotwidget.cpp.

{
  QPointF graph_coord = horizontalGetGraphCoordNewPointCountPixels(pixel_count);
 
  QPointF pixel_coord(xAxis->coordToPixel(graph_coord.x()),
                      yAxis->coordToPixel(graph_coord.y()));
 
  // Now we need ton convert the new coordinates to the global position system
  // and to move the cursor to that new position. That will create an event to
  // move the mouse cursor.
 
  moveMouseCursorPixelCoordToGlobal(pixel_coord.toPoint());
}

References horizontalGetGraphCoordNewPointCountPixels(), and moveMouseCursorPixelCoordToGlobal().

Referenced by directionKeyPressEvent().

integrationRequestedSignal

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

signal

Referenced by mouseReleaseHandlerRightButton().

isClickOntoXAxis()

bool pappso::BasePlotWidget::isClickOntoXAxis

(

const QPointF &

mousePoint

)

Definition at line 1387 of file baseplotwidget.cpp.

{
  QCPLayoutElement *layoutElement = layoutElementAt(mousePoint);
 
  if(layoutElement &&
     layoutElement == dynamic_cast<QCPLayoutElement *>(axisRect()))
    {
      // The graph is *inside* the axisRect that is the outermost envelope of
      // the graph. Thus, if we want to know if the click was indeed on an
      // axis, we need to check what selectable part of the the axisRect we
      // were
      // clicking:
      QCPAxis::SelectablePart selectablePart;
 
      selectablePart = xAxis->getPartAt(mousePoint);
 
      if(selectablePart == QCPAxis::spAxisLabel ||
         selectablePart == QCPAxis::spAxis ||
         selectablePart == QCPAxis::spTickLabels)
        return true;
    }
 
  return false;
}

Referenced by mousePressHandler().

isClickOntoYAxis()

bool pappso::BasePlotWidget::isClickOntoYAxis

(

const QPointF &

mousePoint

)

Definition at line 1414 of file baseplotwidget.cpp.

{
  QCPLayoutElement *layoutElement = layoutElementAt(mousePoint);
 
  if(layoutElement &&
     layoutElement == dynamic_cast<QCPLayoutElement *>(axisRect()))
    {
      // The graph is *inside* the axisRect that is the outermost envelope of
      // the graph. Thus, if we want to know if the click was indeed on an
      // axis, we need to check what selectable part of the the axisRect we
      // were
      // clicking:
      QCPAxis::SelectablePart selectablePart;
 
      selectablePart = yAxis->getPartAt(mousePoint);
 
      if(selectablePart == QCPAxis::spAxisLabel ||
         selectablePart == QCPAxis::spAxis ||
         selectablePart == QCPAxis::spTickLabels)
        return true;
    }
 
  return false;
}

Referenced by mousePressHandler().

isProperSelectionRectangle()

bool pappso::BasePlotWidget::isProperSelectionRectangle ( )

virtual

Definition at line 2165 of file baseplotwidget.cpp.

{
  // First get the height of the plot.
  double plotHeight = yAxis->range().upper - yAxis->range().lower;
 
  double heightDiff =
    fabs(m_context.startDragPoint.y() - m_context.currentDragPoint.y());
 
  double heightDiffRatio = (heightDiff / plotHeight) * 100;
 
  if(heightDiffRatio > 10)
    return true;
 
  return false;
}

References pappso::BasePlotContext::currentDragPoint, m_context, and pappso::BasePlotContext::startDragPoint.

Referenced by mouseMoveHandlerLeftButtonDraggingCursor().

keyPressEvent()

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

virtual

KEYBOARD-related EVENTS.

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

Definition at line 491 of file baseplotwidget.cpp.

{
  // qDebug() << "ENTER";
 
  // We need this because some keys modify our behaviour.
  m_context.pressedKeyCode    = event->key();
  m_context.keyboardModifiers = QGuiApplication::queryKeyboardModifiers();
 
  if(event->key() == Qt::Key_Left || event->key() == Qt::Key_Right ||
     event->key() == Qt::Key_Up || event->key() == Qt::Key_Down)
    {
      return directionKeyPressEvent(event);
    }
  else if(event->key() == m_leftMousePseudoButtonKey ||
          event->key() == m_rightMousePseudoButtonKey)
    {
      return mousePseudoButtonKeyPressEvent(event);
    }
 
  // Do not do anything here, because this function is used by derived classes
  // that will emit the signal below. Otherwise there are going to be multiple
  // signals sent.
  // qDebug() << "Going to emit keyPressEventSignal(m_context);";
  // emit keyPressEventSignal(m_context);
}

References directionKeyPressEvent(), pappso::BasePlotContext::keyboardModifiers, m_context, m_leftMousePseudoButtonKey, m_rightMousePseudoButtonKey, mousePseudoButtonKeyPressEvent(), and pappso::BasePlotContext::pressedKeyCode.

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

keyPressEventSignal

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

signal

Referenced by pappso::DriftSpecTracePlotWidget::keyPressEvent(), and pappso::TicXicChromTracePlotWidget::keyPressEvent().

keyReleaseEvent()

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

virtual

Handle specific key codes and trigger respective actions.

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

Definition at line 520 of file baseplotwidget.cpp.

{
  m_context.releasedKeyCode = event->key();
 
  // The keyboard key is being released, set the key code to 0.
  m_context.pressedKeyCode    = 0;
  m_context.keyboardModifiers = QGuiApplication::queryKeyboardModifiers();
 
  // Now test if the key that was released is one of the housekeeping keys.
  if(event->key() == Qt::Key_Backspace)
    {
      // The user wants to iterate back in the x/y axis range history.
      restorePreviousAxesRangeHistory();
 
      event->accept();
    }
  else if(event->key() == Qt::Key_Space)
    {
      return spaceKeyReleaseEvent(event);
    }
  else if(event->key() == Qt::Key_Delete)
    {
      // The user wants to delete a graph. What graph is to be determined
      // programmatically:
 
      // If there is a single graph, then that is the graph to be removed.
      // If there are more than one graph, then only the ones that are selected
      // are to be removed.
 
      // Note that the user of this widget might want to provide the user with
      // the ability to specify if all the children graph needs to be removed
      // also. This can be coded in key modifiers. So provide the context.
 
      int graph_count = plottableCount();
 
      if(!graph_count)
        {
          // qDebug() << "Not a single graph in the plot widget. Doing
          // nothing.";
 
          event->accept();
          return;
        }
 
      if(graph_count == 1)
        {
          // qDebug() << "A single graph is in the plot widget. Emitting a graph
          // " "destruction requested signal for it:"
          //<< graph();
 
          emit plottableDestructionRequestedSignal(this, graph(), m_context);
        }
      else
        {
          // At this point we know there are more than one graph in the plot
          // widget. We need to get the selected one (if any).
          QList<QCPGraph *> selected_graph_list;
 
          selected_graph_list = selectedGraphs();
 
          if(!selected_graph_list.size())
            {
              event->accept();
              return;
            }
 
          // qDebug() << "Number of selected graphs to be destrobyed:"
          //<< selected_graph_list.size();
 
          for(int iter = 0; iter < selected_graph_list.size(); ++iter)
            {
              // qDebug()
              //<< "Emitting a graph destruction requested signal for graph:"
              //<< selected_graph_list.at(iter);
 
              emit plottableDestructionRequestedSignal(
                this, selected_graph_list.at(iter), m_context);
 
              // We do not do this, because we want the slot called by the
              // signal above to handle that removal. Remember that it is not
              // possible to delete graphs manually.
              //
              // removeGraph(selected_graph_list.at(iter));
            }
          event->accept();
        }
    }
  // End of
  // else if(event->key() == Qt::Key_Delete)
  else if(event->key() == Qt::Key_T)
    {
      // The user wants to toggle the visibiity of the tracers.
      m_shouldTracersBeVisible = !m_shouldTracersBeVisible;
 
      if(!m_shouldTracersBeVisible)
        hideTracers();
      else
        showTracers();
 
      event->accept();
    }
  else if(event->key() == Qt::Key_Left || event->key() == Qt::Key_Right ||
          event->key() == Qt::Key_Up || event->key() == Qt::Key_Down)
    {
      return directionKeyReleaseEvent(event);
    }
  else if(event->key() == m_leftMousePseudoButtonKey ||
          event->key() == m_rightMousePseudoButtonKey)
    {
      return mousePseudoButtonKeyReleaseEvent(event);
    }
 
  // At this point emit the signal, since we did not treat it. Maybe the
  // consumer widget wants to know that the keyboard key was released.
 
  emit keyReleaseEventSignal(m_context);
}

References directionKeyReleaseEvent(), hideTracers(), pappso::BasePlotContext::keyboardModifiers, keyReleaseEventSignal(), m_context, m_leftMousePseudoButtonKey, m_rightMousePseudoButtonKey, m_shouldTracersBeVisible, mousePseudoButtonKeyReleaseEvent(), plottableDestructionRequestedSignal(), pappso::BasePlotContext::pressedKeyCode, pappso::BasePlotContext::releasedKeyCode, restorePreviousAxesRangeHistory(), showTracers(), and spaceKeyReleaseEvent().

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

keyReleaseEventSignal

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

signal

Referenced by keyReleaseEvent().

lastCursorHoveredPointSignal

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

signal

Referenced by mouseMoveHandlerNotDraggingCursor().

mouseMoveHandler()

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

virtual

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

Definition at line 1070 of file baseplotwidget.cpp.

{
 
  // If we have no focus, then get it. See setFocus() to understand why asking
  // for focus is cosly and thus why we want to make this decision first.
  if(!hasFocus())
    setFocus();
 
  // The event->button() must be by Qt instructions considered to be 0.
 
  // Whatever happens, we want to store the plot coordinates of the current
  // mouse cursor position (will be useful later for countless needs).
 
  QPointF mousePoint = event->localPos();
 
  // qDebug() << "local mousePoint position in pixels:" << mousePoint;
 
  m_context.lastCursorHoveredPoint.setX(xAxis->pixelToCoord(mousePoint.x()));
  m_context.lastCursorHoveredPoint.setY(yAxis->pixelToCoord(mousePoint.y()));
 
  // qDebug() << "lastCursorHoveredPoint coord:"
  //<< m_context.lastCursorHoveredPoint;
 
  // Now, depending on the button(s) (if any) that are pressed or not, we have
  // a different processing.
 
  if(m_context.pressedMouseButtons & Qt::LeftButton ||
     m_context.pressedMouseButtons & Qt::RightButton)
    mouseMoveHandlerDraggingCursor();
  else
    mouseMoveHandlerNotDraggingCursor();
 
  event->accept();
}

References pappso::BasePlotContext::lastCursorHoveredPoint, m_context, mouseMoveHandlerDraggingCursor(), mouseMoveHandlerNotDraggingCursor(), pappso::BasePlotContext::pressedMouseButtons, and setFocus().

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

mouseMoveHandlerDraggingCursor()

void pappso::BasePlotWidget::mouseMoveHandlerDraggingCursor ( )

virtual

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

Definition at line 1153 of file baseplotwidget.cpp.

{
 
  m_context.isMouseDragging = true;
 
  // Now store the mouse position data into the the current drag point
  // member datum, that will be used in countless occasions later.
  m_context.currentDragPoint  = m_context.lastCursorHoveredPoint;
  m_context.keyboardModifiers = QGuiApplication::queryKeyboardModifiers();
 
  // When we drag (either keyboard or mouse), we hide the position markers
  // (black) and we show the start and end vertical markers for the region.
  // Then, we draw the horizontal region range marker that delimits
  // horizontally the dragged-over region.
 
  mp_hPosTracerItem->setVisible(false);
  mp_vPosTracerItem->setVisible(false);
 
  // Only bother with the tracers if the user wants them to be visible.
  if(m_shouldTracersBeVisible)
    {
 
      // The vertical end tracer position must be refreshed.
      mp_vEndTracerItem->start->setCoords(m_context.currentDragPoint.x(),
                                          yAxis->range().upper);
 
      mp_vEndTracerItem->end->setCoords(m_context.currentDragPoint.x(),
                                        yAxis->range().lower);
 
      mp_vEndTracerItem->setVisible(true);
    }
 
  // Whatever the button, when we are dealing with the axes, we do not
  // want to show any of the tracers.
 
  if(m_context.wasClickOnXAxis || m_context.wasClickOnYAxis)
    {
      mp_hPosTracerItem->setVisible(false);
      mp_vPosTracerItem->setVisible(false);
 
      mp_vStartTracerItem->setVisible(false);
      mp_vEndTracerItem->setVisible(false);
    }
 
  // We will need the axes ranges matching the region being selected by the
  // user while left-mouse-dragging the cursor.
 
  calculateDragDeltasAndUnSortedRegionCorners();
 
  // Now deal with the BUTTON-SPECIFIC CODE.
 
  if(m_context.mouseButtonsAtMousePress & Qt::LeftButton)
    {
      return mouseMoveHandlerLeftButtonDraggingCursor();
    }
  else if(m_context.mouseButtonsAtMousePress & Qt::RightButton)
    {
      return mouseMoveHandlerRightButtonDraggingCursor();
    }
}

References calculateDragDeltasAndUnSortedRegionCorners(), pappso::BasePlotContext::currentDragPoint, pappso::BasePlotContext::isMouseDragging, pappso::BasePlotContext::keyboardModifiers, pappso::BasePlotContext::lastCursorHoveredPoint, m_context, m_shouldTracersBeVisible, pappso::BasePlotContext::mouseButtonsAtMousePress, mouseMoveHandlerLeftButtonDraggingCursor(), mouseMoveHandlerRightButtonDraggingCursor(), mp_hPosTracerItem, mp_vEndTracerItem, mp_vPosTracerItem, mp_vStartTracerItem, pappso::BasePlotContext::wasClickOnXAxis, and pappso::BasePlotContext::wasClickOnYAxis.

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

mouseMoveHandlerLeftButtonDraggingCursor()

void pappso::BasePlotWidget::mouseMoveHandlerLeftButtonDraggingCursor ( )

virtual

Definition at line 1216 of file baseplotwidget.cpp.

{
  // qDebug() << "the left button is dragging.";
 
  // Set the context.isMeasuringDistance to false, which later might be set to
  // true if effectively we are measuring a distance. This is required because
  // the derived widget classes might want to know if they have to perform
  // some action on the basis that context is measuring a distance, for
  // example the mass spectrum-specific widget might want to compute
  // deconvolutions.
 
  m_context.isMeasuringDistance = false;
 
  // Let's first check if the mouse drag operation originated on either
  // axis. In that case, the user is performing axis reframing or rescaling.
 
  if(m_context.wasClickOnXAxis || m_context.wasClickOnYAxis)
    {
      // qDebug() << __FILE__ << __LINE__ << "Click was on one of the axes.";
 
      if(m_context.keyboardModifiers & Qt::ControlModifier)
        {
          // The user is asking a rescale of the plot.
 
          // We know that we do not want the tracers when we perform axis
          // rescaling operations.
 
          mp_hPosTracerItem->setVisible(false);
          mp_vPosTracerItem->setVisible(false);
 
          mp_vStartTracerItem->setVisible(false);
          mp_vEndTracerItem->setVisible(false);
 
          // This operation is particularly intensive, thus we want to
          // reduce the number of calculations by skipping this calculation
          // a number of times. The user can ask for this feature by
          // clicking the 'Q' letter.
 
          if(m_context.pressedKeyCode == Qt::Key_Q)
            {
              if(m_mouseMoveHandlerSkipCount < m_mouseMoveHandlerSkipAmount)
                {
                  m_mouseMoveHandlerSkipCount++;
                  return;
                }
              else
                {
                  m_mouseMoveHandlerSkipCount = 0;
                }
            }
 
          // qDebug() << "Asking that the axes be rescaled.";
 
          axisRescale();
        }
      else
        {
          // The user was simply dragging the axis. Just pan, that is slide
          // the plot in the same direction as the mouse movement and with the
          // same amplitude.
 
          // qDebug() << "Asking that the axes be panned.";
 
          axisPan();
        }
 
      return;
    }
 
  // At this point we understand that the user was not performing any
  // panning/rescaling operation by clicking on any one of the axes.. Go on
  // with other possibilities.
 
  // Let's check if the user is actually drawing a rectangle (covering a
  // real area) or is drawing a line.
 
  // qDebug() << "The mouse dragging did not originate on an axis.";
 
  if(isProperSelectionRectangle())
    {
      // qDebug() << "Apparently the selection is a real rectangle.";
 
      // When we draw a rectangle the tracers are of no use.
 
      mp_hPosTracerItem->setVisible(false);
      mp_vPosTracerItem->setVisible(false);
 
      mp_vStartTracerItem->setVisible(false);
      mp_vEndTracerItem->setVisible(false);
 
      drawRectangleAndPrepareZoom();
    }
  else
    {
      // qDebug() << "Apparently we are measuring a delta.";
 
      // The pure position tracers should be hidden.
      mp_hPosTracerItem->setVisible(true);
      mp_vPosTracerItem->setVisible(true);
 
      // Then, make sure the region range vertical tracers are visible.
      mp_vStartTracerItem->setVisible(true);
      mp_vEndTracerItem->setVisible(true);
 
      drawXDeltaLineAndMeasure();
    }
}

References axisPan(), axisRescale(), drawRectangleAndPrepareZoom(), drawXDeltaLineAndMeasure(), pappso::BasePlotContext::isMeasuringDistance, isProperSelectionRectangle(), pappso::BasePlotContext::keyboardModifiers, m_context, m_mouseMoveHandlerSkipAmount, m_mouseMoveHandlerSkipCount, mp_hPosTracerItem, mp_vEndTracerItem, mp_vPosTracerItem, mp_vStartTracerItem, pappso::BasePlotContext::pressedKeyCode, pappso::BasePlotContext::wasClickOnXAxis, and pappso::BasePlotContext::wasClickOnYAxis.

Referenced by mouseMoveHandlerDraggingCursor().

mouseMoveHandlerNotDraggingCursor()

void pappso::BasePlotWidget::mouseMoveHandlerNotDraggingCursor ( )

virtual

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

Definition at line 1107 of file baseplotwidget.cpp.

{
 
  m_context.isMouseDragging = false;
 
  // We are not dragging the mouse (no button pressed), simply let this
  // widget's consumer know the position of the cursor and update the markers.
 
  emit lastCursorHoveredPointSignal(m_context.lastCursorHoveredPoint);
 
  // We are not dragging, so we do not show the region end tracer we only show
  // the anchoring start trace that might be of use if the user starts using
  // the arrow keys to move the cursor.
  mp_vEndTracerItem->setVisible(false);
 
  // Only bother with the tracers if the user wants them to be visible. Their
  // crossing point must be exactly at the last cursor-hovered point.
 
  if(m_shouldTracersBeVisible)
    {
      // We are not dragging, so only show the position markers (v and h);
 
      // Horizontal position tracer.
      mp_hPosTracerItem->setVisible(true);
      mp_hPosTracerItem->start->setCoords(xAxis->range().lower,
                                          m_context.lastCursorHoveredPoint.y());
      mp_hPosTracerItem->end->setCoords(xAxis->range().upper,
                                        m_context.lastCursorHoveredPoint.y());
 
      // Vertical position tracer.
      mp_vPosTracerItem->setVisible(true);
 
      mp_vPosTracerItem->setVisible(true);
      mp_vPosTracerItem->start->setCoords(m_context.lastCursorHoveredPoint.x(),
                                          yAxis->range().upper);
      mp_vPosTracerItem->end->setCoords(m_context.lastCursorHoveredPoint.x(),
                                        yAxis->range().lower);
 
      replot();
    }
 
  return;
}

References pappso::BasePlotContext::isMouseDragging, pappso::BasePlotContext::lastCursorHoveredPoint, lastCursorHoveredPointSignal(), m_context, m_shouldTracersBeVisible, mp_hPosTracerItem, mp_vEndTracerItem, and mp_vPosTracerItem.

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

mouseMoveHandlerRightButtonDraggingCursor()

void pappso::BasePlotWidget::mouseMoveHandlerRightButtonDraggingCursor ( )

virtual

Definition at line 1326 of file baseplotwidget.cpp.

{
  // qDebug() << "the right button is dragging.";
 
  // Set the context.isMeasuringDistance to false, which later might be set to
  // true if effectively we are measuring a distance. This is required because
  // the derived widgets might want to know if they have to perform some
  // action on the basis that context is measuring a distance, for example the
  // mass spectrum-specific widget might want to compute deconvolutions.
 
  m_context.isMeasuringDistance = false;
 
  drawXDeltaLineForIntegration();
}

References drawXDeltaLineForIntegration(), pappso::BasePlotContext::isMeasuringDistance, and m_context.

Referenced by mouseMoveHandlerDraggingCursor().

mousePressHandler()

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

virtual

KEYBOARD-related EVENTS.

MOUSE-related EVENTS

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

Definition at line 772 of file baseplotwidget.cpp.

{
  // When the user clicks this widget it has to take focus.
  setFocus();
 
  QPointF mousePoint = event->localPos();
 
  m_context.lastPressedMouseButton   = event->button();
  m_context.mouseButtonsAtMousePress = event->buttons();
 
  // The pressedMouseButtons must continually inform on the status of pressed
  // buttons so add the pressed button.
  m_context.pressedMouseButtons |= event->button();
 
  // qDebug().noquote() << m_context.toString();
 
  // In all the processing of the events, we need to know if the user is
  // clicking somewhere with the intent to change the plot ranges (reframing
  // or rescaling the plot).
  //
  // Reframing the plot means that the new x and y axes ranges are modified so
  // that they match the region that the user has encompassed by left clicking
  // the mouse and dragging it over the plot. That is we reframe the plot so
  // that it contains only the "selected" region.
  //
  // Rescaling the plot means the the new x|y axis range is modified such that
  // the lower axis range is constant and the upper axis range is moved either
  // left or right by the same amont as the x|y delta encompassed by the user
  // moving the mouse. The axis is thus either compressed (mouse movement is
  // leftwards) or un-compressed (mouse movement is rightwards).
 
  // There are two ways to perform axis range modifications:
  //
  // 1. By clicking on any of the axes
  // 2. By clicking on the plot region but using keyboard key modifiers, like
  // Alt and Ctrl.
  //
  // We need to know both cases separately which is why we need to perform a
  // number of tests below.
 
  // Let's check if the click is on the axes, either X or Y, because that
  // will allow us to take proper actions.
 
  if(isClickOntoXAxis(mousePoint))
    {
      // The X axis was clicked upon, we need to document that:
      // qDebug() << __FILE__ << __LINE__
      //<< "Layout element is axisRect and actually on an X axis part.";
 
      m_context.wasClickOnXAxis = true;
 
      // int currentInteractions = interactions();
      // currentInteractions |= QCP::iRangeDrag;
      // setInteractions((QCP::Interaction)currentInteractions);
      // axisRect()->setRangeDrag(xAxis->orientation());
    }
  else
    m_context.wasClickOnXAxis = false;
 
  if(isClickOntoYAxis(mousePoint))
    {
      // The Y axis was clicked upon, we need to document that:
      // qDebug() << __FILE__ << __LINE__
      //<< "Layout element is axisRect and actually on an Y axis part.";
 
      m_context.wasClickOnYAxis = true;
 
      // int currentInteractions = interactions();
      // currentInteractions |= QCP::iRangeDrag;
      // setInteractions((QCP::Interaction)currentInteractions);
      // axisRect()->setRangeDrag(yAxis->orientation());
    }
  else
    m_context.wasClickOnYAxis = false;
 
  // At this point, let's see if we need to remove the QCP::iRangeDrag bit:
 
  if(!m_context.wasClickOnXAxis && !m_context.wasClickOnYAxis)
    {
      // qDebug() << __FILE__ << __LINE__
      // << "Click outside of axes.";
 
      // int currentInteractions = interactions();
      // currentInteractions     = currentInteractions & ~QCP::iRangeDrag;
      // setInteractions((QCP::Interaction)currentInteractions);
    }
 
  m_context.startDragPoint.setX(xAxis->pixelToCoord(mousePoint.x()));
  m_context.startDragPoint.setY(yAxis->pixelToCoord(mousePoint.y()));
 
  // Now install the vertical start tracer at the last cursor hovered
  // position.
  if(m_shouldTracersBeVisible)
    mp_vStartTracerItem->setVisible(true);
 
  mp_vStartTracerItem->start->setCoords(m_context.lastCursorHoveredPoint.x(),
                                        yAxis->range().upper);
  mp_vStartTracerItem->end->setCoords(m_context.lastCursorHoveredPoint.x(),
                                      yAxis->range().lower);
 
  replot();
}

References isClickOntoXAxis(), isClickOntoYAxis(), pappso::BasePlotContext::lastCursorHoveredPoint, pappso::BasePlotContext::lastPressedMouseButton, m_context, m_shouldTracersBeVisible, pappso::BasePlotContext::mouseButtonsAtMousePress, mp_vStartTracerItem, pappso::BasePlotContext::pressedMouseButtons, setFocus(), pappso::BasePlotContext::startDragPoint, pappso::BasePlotContext::wasClickOnXAxis, and pappso::BasePlotContext::wasClickOnYAxis.

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

mousePseudoButtonKeyPressEvent()

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

virtual

Definition at line 698 of file baseplotwidget.cpp.

{
  // qDebug();
}

Referenced by keyPressEvent().

mousePseudoButtonKeyReleaseEvent()

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

virtual

Definition at line 705 of file baseplotwidget.cpp.

{
 
  QPointF pixel_coordinates(
    xAxis->coordToPixel(m_context.lastCursorHoveredPoint.x()),
    yAxis->coordToPixel(m_context.lastCursorHoveredPoint.y()));
 
  Qt::MouseButton button    = Qt::NoButton;
  QEvent::Type q_event_type = QEvent::MouseButtonPress;
 
  if(event->key() == m_leftMousePseudoButtonKey)
    {
      // Toggles the left mouse button on/off
 
      button = Qt::LeftButton;
 
      m_context.isLeftPseudoButtonKeyPressed =
        !m_context.isLeftPseudoButtonKeyPressed;
 
      if(m_context.isLeftPseudoButtonKeyPressed)
        q_event_type = QEvent::MouseButtonPress;
      else
        q_event_type = QEvent::MouseButtonRelease;
    }
  else if(event->key() == m_rightMousePseudoButtonKey)
    {
      // Toggles the right mouse button.
 
      button = Qt::RightButton;
 
      m_context.isRightPseudoButtonKeyPressed =
        !m_context.isRightPseudoButtonKeyPressed;
 
      if(m_context.isRightPseudoButtonKeyPressed)
        q_event_type = QEvent::MouseButtonPress;
      else
        q_event_type = QEvent::MouseButtonRelease;
    }
 
  // qDebug() << "pressed/released pseudo button:" << button
  //<< "q_event_type:" << q_event_type;
 
  // Synthesize a QMouseEvent and use it.
 
  QMouseEvent *mouse_event_p =
    new QMouseEvent(q_event_type,
                    pixel_coordinates,
                    mapToGlobal(pixel_coordinates.toPoint()),
                    mapToGlobal(pixel_coordinates.toPoint()),
                    button,
                    button,
                    m_context.keyboardModifiers,
                    Qt::MouseEventSynthesizedByApplication);
 
  if(q_event_type == QEvent::MouseButtonPress)
    mousePressHandler(mouse_event_p);
  else
    mouseReleaseHandler(mouse_event_p);
 
  // event->accept();
}

References pappso::BasePlotContext::isLeftPseudoButtonKeyPressed, pappso::BasePlotContext::isRightPseudoButtonKeyPressed, pappso::BasePlotContext::keyboardModifiers, pappso::BasePlotContext::lastCursorHoveredPoint, m_context, 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::MassSpecTracePlotWidget, pappso::TicXicChromTracePlotWidget, pappso::DriftSpecTracePlotWidget, pappso::DriftSpecMassSpecColorMapPlotWidget, and pappso::TicXicChromMassSpecColorMapPlotWidget.

Definition at line 877 of file baseplotwidget.cpp.

{
  m_context.lastReleasedMouseButton = event->button();
 
  // The event->buttons() is the description of the buttons that are pressed at
  // the moment the handler is invoked, that is now. If left and right were
  // pressed, and left was released, event->buttons() would be right.
  m_context.mouseButtonsAtMouseRelease = event->buttons();
 
  // The pressedMouseButtons must continually inform on the status of pressed
  // buttons so remove the released button.
  m_context.pressedMouseButtons ^= event->button();
 
  // qDebug().noquote() << m_context.toString();
 
  // We'll need to know if modifiers were pressed a the moment the user
  // released the mouse button.
  m_context.keyboardModifiers = QGuiApplication::keyboardModifiers();
 
  if(!m_context.isMouseDragging)
    {
      // Let the user know that the mouse was *not* being dragged.
      m_context.wasMouseDragging = false;
 
      event->accept();
 
      return;
    }
 
  // Let the user know that the mouse was being dragged.
  m_context.wasMouseDragging = true;
 
  // We cannot hide all items in one go because we rely on their visibility
  // to know what kind of dragging operation we need to perform (line-only
  // X-based zoom or rectangle-based X- and Y-based zoom, for example). The
  // only thing we know is that we can make the text invisible.
 
  // We would not want to still see the selection line item.
  mp_selectLineItem->setVisible(false);
 
  // Same for the x delta text item
  mp_xDeltaTextItem->setVisible(false);
 
  // We do not show the end vertical region range marker.
  mp_vEndTracerItem->setVisible(false);
 
  // Horizontal position tracer.
  mp_hPosTracerItem->setVisible(true);
  mp_hPosTracerItem->start->setCoords(xAxis->range().lower,
                                      m_context.lastCursorHoveredPoint.y());
  mp_hPosTracerItem->end->setCoords(xAxis->range().upper,
                                    m_context.lastCursorHoveredPoint.y());
 
  // Vertical position tracer.
  mp_vPosTracerItem->setVisible(true);
 
  mp_vPosTracerItem->setVisible(true);
  mp_vPosTracerItem->start->setCoords(m_context.lastCursorHoveredPoint.x(),
                                      yAxis->range().upper);
  mp_vPosTracerItem->end->setCoords(m_context.lastCursorHoveredPoint.x(),
                                    yAxis->range().lower);
 
  // Force replot now because later that call might not be performed.
  replot();
 
  // If we were using the "quantum" display for the rescale of the axes
  // using the Ctrl-modified left button click drag in the axes, then reset
  // the count to 0.
  m_mouseMoveHandlerSkipCount = 0;
 
  // Compute the delta values, X and Y, that correspond to the movement that
  // was done by the user while pressing the mouse button, that is get the
  // geometry of the drag movement.
 
  calculateDragDeltasAndUnSortedRegionCorners();
 
  // Now that we have computed the useful ranges, we need to check what to do
  // depending on the button that was pressed.
 
  if(m_context.lastReleasedMouseButton == Qt::LeftButton)
    {
      return mouseReleaseHandlerLeftButton();
    }
  else if(m_context.lastReleasedMouseButton == Qt::RightButton)
    {
      return mouseReleaseHandlerRightButton();
    }
 
 
  // By definition we are stopping the drag operation by releasing the mouse
  // button. Whatever that mouse button was pressed before and if there was
  // one pressed before.  We cannot set that boolean value to false before
  // this place, because we call a number of routines above that need to know
  // that dragging was occurring. Like mouseReleaseHandledEvent(event) for
  // example.
 
  m_context.isMouseDragging = false;
 
  event->accept();
 
  return;
}

References calculateDragDeltasAndUnSortedRegionCorners(), pappso::BasePlotContext::isMouseDragging, pappso::BasePlotContext::keyboardModifiers, pappso::BasePlotContext::lastCursorHoveredPoint, pappso::BasePlotContext::lastReleasedMouseButton, m_context, m_mouseMoveHandlerSkipCount, pappso::BasePlotContext::mouseButtonsAtMouseRelease, mouseReleaseHandlerLeftButton(), mouseReleaseHandlerRightButton(), mp_hPosTracerItem, mp_selectLineItem, mp_vEndTracerItem, mp_vPosTracerItem, mp_xDeltaTextItem, pappso::BasePlotContext::pressedMouseButtons, and pappso::BasePlotContext::wasMouseDragging.

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

mouseReleaseHandlerLeftButton()

void pappso::BasePlotWidget::mouseReleaseHandlerLeftButton ( )

virtual

Definition at line 982 of file baseplotwidget.cpp.

{
 
  if(m_context.wasClickOnXAxis || m_context.wasClickOnYAxis)
    {
 
      // When the mouse move handler pans the plot, we cannot store each axes
      // range history element that would mean store a huge amount of such
      // elements, as many element as there are mouse move event handled by
      // the Qt event queue. But we can store an axis range history element
      // for the last situation of the mouse move: when the button is
      // released:
 
      updateAxesRangeHistory();
 
      emit plotRangesChangedSignal(m_context);
 
      replot();
 
      // Nothing else to do.
      return;
    }
 
  // Start handling the zoom rectangle so that we can skip any keyboard
  // modified, like Ctrl that would not mean anything anyway.
  if(mp_zoomRectItem->visible())
    {
 
      // If we were dragging with the left button pressed and could draw a
      // rectangle, then we were preparing a zoom operation. Let's bring
      // that operation to an end.
 
      mp_zoomRectItem->setVisible(false);
 
      axisZoom();
 
      return;
    }
 
  // If the user started by clicking in the plot region, dragged the mouse
  // cursor with the left button and pressed the Ctrl modifier, then that
  // means that they wanted to do a rescale over the x-axis in the form of a
  // reframing.
 
  if(m_context.keyboardModifiers & Qt::ControlModifier)
    {
      return axisReframe();
    }
}

References axisReframe(), axisZoom(), pappso::BasePlotContext::keyboardModifiers, m_context, mp_zoomRectItem, plotRangesChangedSignal(), updateAxesRangeHistory(), pappso::BasePlotContext::wasClickOnXAxis, and pappso::BasePlotContext::wasClickOnYAxis.

Referenced by mouseReleaseHandler().

mouseReleaseHandlerRightButton()

void pappso::BasePlotWidget::mouseReleaseHandlerRightButton ( )

virtual

Definition at line 1034 of file baseplotwidget.cpp.

{
 
  // The right button is used for the integrations. Not for axis range
  // operations. So all we have to do is remove the various graphics items and
  // send a signal with the context that contains all the data required by the
  // user to perform the integrations over the right plot regions.
 
  // Whatever we were doing we need to make the selection line invisible:
 
  if(mp_selectLineItem->visible())
    mp_selectLineItem->setVisible(false);
 
  if(mp_xDeltaTextItem->visible())
    mp_xDeltaTextItem->setVisible(false);
 
  // Also make the vertical end tracer invisible.
  mp_vEndTracerItem->setVisible(false);
 
  // Force replot now because later that call might not be performed.
  replot();
 
    // Note that we only request an integration if the x-axis delta is enough.
 
  double x_delta_pixel =
    fabs(xAxis->coordToPixel(m_context.currentDragPoint.x()) -
         xAxis->coordToPixel(m_context.startDragPoint.x()));
 
    if(x_delta_pixel > 3)
        emit integrationRequestedSignal(m_context);
    //else
        //qDebug() << "Not asking for integration.";
}

References pappso::BasePlotContext::currentDragPoint, integrationRequestedSignal(), m_context, mp_selectLineItem, mp_vEndTracerItem, mp_xDeltaTextItem, and pappso::BasePlotContext::startDragPoint.

Referenced by mouseReleaseHandler().

moveMouseCursorGraphCoordToGlobal()

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

virtual

Definition at line 1473 of file baseplotwidget.cpp.

{
  // First convert the graph coordinates to pixel coordinates.
 
  QPointF pixels_coordinates(xAxis->coordToPixel(graph_coordinates.x()),
                             yAxis->coordToPixel(graph_coordinates.y()));
 
  moveMouseCursorPixelCoordToGlobal(pixels_coordinates.toPoint());
}

References moveMouseCursorPixelCoordToGlobal().

moveMouseCursorPixelCoordToGlobal()

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

virtual

Definition at line 1485 of file baseplotwidget.cpp.

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

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

plotRangesChangedSignal

void pappso::BasePlotWidget::plotRangesChangedSignal ( const BasePlotContext &  context )

signal

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

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

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

prepareXDeltaLineAndMeasure()

void pappso::BasePlotWidget::prepareXDeltaLineAndMeasure ( )

virtual

Definition at line 2029 of file baseplotwidget.cpp.

{
  // The user has dragged the mouse left button on the graph in such a way
  // that the xDelta is big and the yDelta is almost nothing, that
  // means that he does not want to draw a rectangle but a line to
  // measure the delta between two points of the graph.
 
  mp_zoomRectItem->setVisible(false);
 
  // We also want to show the span as a text item.
 
  // m_context.xDelta is not an absolute value.
  double m_xDeltaHalf = fabs(m_context.xDelta / 2);
 
  // Use the m_context.xRegionRangeStart/End values, but we need to sort the
  // values before using them, because now we want to really have the lower x
  // value. Simply craft a QCPRange that will swap the values if lower is not
  // < than upper QCustomPlot calls this normalization).
 
  QCPRange sorted_range(m_context.xRegionRangeStart, m_context.xRegionRangeEnd);
 
  // qDebug() << "sorted range:" << sorted_range.lower << "-" <<
  // sorted_range.upper
  //<< "xrangedeltahalf:" << m_xDeltaHalf;
 
  mp_xDeltaTextItem->position->setCoords(sorted_range.lower + m_xDeltaHalf,
                                         m_context.currentDragPoint.y());
 
  mp_xDeltaTextItem->setText(QString("%1").arg(m_context.xDelta, 0, 'f', 3));
 
  mp_xDeltaTextItem->setFont(QFont(font().family(), 7));
 
  mp_xDeltaTextItem->setVisible(true);
 
  // We do not want to show the position markers because the only horiontal
  // line to be visible must be contained between the start and end vertiacal
  // tracer items.
  mp_hPosTracerItem->setVisible(false);
  mp_vPosTracerItem->setVisible(false);
 
  mp_selectLineItem->setVisible(true);
 
  mp_selectLineItem->start->setCoords(m_context.startDragPoint.x(),
                                      m_context.startDragPoint.y());
  // But we want the line to be horizontal, thus we keep the original y
  // value.
  mp_selectLineItem->end->setCoords(m_context.currentDragPoint.x(),
                                    m_context.startDragPoint.y());
 
  // Set the boolean to true so that derived widgets know that something is
  // being measured, and they can act accordingly, for example by computing
  // deconvolutions in a mass spectrum.
  m_context.isMeasuringDistance = true;
 
  return;
}

References pappso::BasePlotContext::currentDragPoint, pappso::BasePlotContext::isMeasuringDistance, m_context, mp_hPosTracerItem, mp_selectLineItem, mp_vPosTracerItem, mp_xDeltaTextItem, mp_zoomRectItem, pappso::BasePlotContext::startDragPoint, pappso::BasePlotContext::xDelta, pappso::BasePlotContext::xRegionRangeEnd, and pappso::BasePlotContext::xRegionRangeStart.

Referenced by drawXDeltaLineAndMeasure(), and drawXDeltaLineForIntegration().

redrawPlotBackground()

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

virtual

Redraw the background of the focusedPlotWidget plot widget.

Definition at line 2197 of file baseplotwidget.cpp.

{
  if(focusedPlotWidget == nullptr)
    qFatal("Fatal error at %s@%d. Program aborted.", __FILE__, __LINE__);
 
  if(dynamic_cast<QWidget *>(this) != focusedPlotWidget)
    {
      // The focused widget is not *this widget. We should make sure that
      // we were not the one that had the focus, because in this case we
      // need to redraw an unfocused background.
 
      axisRect()->setBackground(m_unfocusedBrush);
    }
  else
    {
      axisRect()->setBackground(m_focusedBrush);
    }
 
  replot();
}

References m_focusedBrush, and m_unfocusedBrush.

replotWithAxesRanges()

void pappso::BasePlotWidget::replotWithAxesRanges ( QCPRange  xAxisRange, QCPRange  yAxisRange, PlotAxis  whichAxis  )

virtual

Definition at line 1884 of file baseplotwidget.cpp.

{
  if(static_cast<int>(axis) & static_cast<int>(PlotAxis::x_axis))
    {
      xAxis->setRange(xAxisRange.lower, xAxisRange.upper);
    }
 
  if(static_cast<int>(axis) & static_cast<int>(PlotAxis::y_axis))
    {
      yAxis->setRange(yAxisRange.lower, yAxisRange.upper);
    }
 
  // We do not want to update the history, because there would be way too
  // much history items, since this function is called upon mouse moving
  // handling and not only during mouse release events.
  // updateAxesRangeHistory();
 
  replot();
}

References pappso::x_axis, and pappso::y_axis.

replotWithAxisRangeX()

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

virtual

Definition at line 1908 of file baseplotwidget.cpp.

{
  // qDebug();
 
  xAxis->setRange(lower, upper);
 
  replot();
}

replotWithAxisRangeY()

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

virtual

Definition at line 1919 of file baseplotwidget.cpp.

{
  // qDebug();
 
  yAxis->setRange(lower, upper);
 
  replot();
}

resetAxesRangeHistory()

void pappso::BasePlotWidget::resetAxesRangeHistory ( )

virtual

Definition at line 365 of file baseplotwidget.cpp.

{
  m_xAxisRangeHistory.clear();
  m_yAxisRangeHistory.clear();
 
  m_xAxisRangeHistory.push_back(new QCPRange(xAxis->range()));
  m_yAxisRangeHistory.push_back(new QCPRange(yAxis->range()));
 
  // qDebug() << "size of history:" << m_xAxisRangeHistory.size()
  //<< "setting index to 0";
 
  // qDebug() << "resetting axes history to values:" << xAxis->range().lower
  //<< "--" << xAxis->range().upper << "and" << yAxis->range().lower
  //<< "--" << yAxis->range().upper;
 
  m_lastAxisRangeHistoryIndex = 0;
}

References m_lastAxisRangeHistoryIndex, m_xAxisRangeHistory, and m_yAxisRangeHistory.

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

restoreAxesRangeHistory()

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

virtual

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

Parameters

index

index at which to select the axis history item.

See also

updateAxesRangeHistory().

Definition at line 443 of file baseplotwidget.cpp.

{
  // qDebug() << "axes history size:" << m_xAxisRangeHistory.size()
  //<< "current index:" << m_lastAxisRangeHistoryIndex
  //<< "asking to restore index:" << index;
 
  if(index >= m_xAxisRangeHistory.size())
    {
      // qDebug() << "index >= history size. Returning.";
      return;
    }
 
  xAxis->setRange(*(m_xAxisRangeHistory.at(index)));
  yAxis->setRange(*(m_yAxisRangeHistory.at(index)));
 
  hideAllPlotItems();
 
  mp_vPosTracerItem->setVisible(false);
  mp_hPosTracerItem->setVisible(false);
 
  mp_vStartTracerItem->setVisible(false);
  mp_vEndTracerItem->setVisible(false);
 
 
  // The start trace will keep beeing represented at the last position and last
  // size even if we call this function repetitively. So actually do not show,
  // it will reappare as soon as the mouse is moved.
  // if(m_shouldTracersBeVisible)
  //{
  // mp_vStartTracerItem->setVisible(true);
  //}
 
  replot();
 
  updateContextRanges();
 
  // qDebug() << "restored axes history to index:" << index
  //<< "with values:" << xAxis->range().lower << "--"
  //<< xAxis->range().upper << "and" << yAxis->range().lower << "--"
  //<< yAxis->range().upper;
 
  emit plotRangesChangedSignal(m_context);
}

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

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 415 of file baseplotwidget.cpp.

{
  // qDebug() << "axes history size:" << m_xAxisRangeHistory.size()
  //<< "current index:" << m_lastAxisRangeHistoryIndex;
 
  if(m_lastAxisRangeHistoryIndex == 0)
    {
      // qDebug() << "current index is 0 returning doing nothing";
 
      return;
    }
 
  // qDebug() << "setting index to:" << m_lastAxisRangeHistoryIndex - 1
  //<< "and restoring axes history to that index";
 
  restoreAxesRangeHistory(--m_lastAxisRangeHistoryIndex);
}

References m_lastAxisRangeHistoryIndex, and restoreAxesRangeHistory().

Referenced by keyReleaseEvent().

setAxisLabelX()

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

virtual

Definition at line 350 of file baseplotwidget.cpp.

{
  xAxis->setLabel(label);
}

setAxisLabelY()

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

virtual

Definition at line 357 of file baseplotwidget.cpp.

{
  yAxis->setLabel(label);
}

setFocus()

void pappso::BasePlotWidget::setFocus ( )

virtual

PLOT ITEMS : TRACER TEXT ITEMS...

Definition at line 2183 of file baseplotwidget.cpp.

{
  // qDebug() << "Setting focus to the QCustomPlot:" << this;
 
  QCustomPlot::setFocus();
 
  // qDebug() << "Emitting setFocusSignal().";
 
  emit setFocusSignal();
}

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 281 of file baseplotwidget.cpp.

{
  m_pen = pen;
}

References m_pen.

setPlottingColor() [1/2]

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

virtual

Definition at line 313 of file baseplotwidget.cpp.

{
  if(!new_color.isValid())
    return;
 
  QCPGraph *graph_p = graph(index);
 
  if(graph_p == nullptr)
    qFatal("Programming error.");
 
  return setPlottingColor(graph_p, 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 295 of file baseplotwidget.cpp.

{
  if(plottable_p == nullptr)
    qFatal("Pointer cannot be nullptr.");
 
  // First this single-graph widget
  QPen pen;
 
  pen = plottable_p->pen();
  pen.setColor(new_color);
  plottable_p->setPen(pen);
 
  replot();
}

Referenced by setPlottingColor().

setupWidget()

bool pappso::BasePlotWidget::setupWidget ( )

virtual

Definition at line 172 of file baseplotwidget.cpp.

{
  // qDebug();
 
  // By default the widget comes with a graph. Remove it.
 
  if(graphCount())
    removeGraph(0);
 
  // This is required so that we get the keyboard events.
  setFocusPolicy(Qt::StrongFocus);
  setInteractions(QCP::iRangeZoom | QCP::iSelectPlottables | QCP::iMultiSelect);
 
  // Make a copy of the pen to just change its color and set that color to
  // the tracer line.
  QPen pen = m_pen;
 
  // Create the lines that will act as tracers for position and selection of
  // regions.
  //
  // We have the cross hair that serves as the cursor. That crosshair cursor is
  // made of a vertical line (green, because when click-dragging the mouse it
  // becomes the tracer that is being anchored at the region start. The second
  // line i horizontal and is always black.
 
  pen.setColor(QColor("black"));
 
  // The set of tracers (horizontal and vertical) that track the position of the
  // mouse cursor.
  mp_vPosTracerItem = new QCPItemLine(this);
  mp_vPosTracerItem->setPen(m_pen);
  mp_vPosTracerItem->start->setType(QCPItemPosition::ptPlotCoords);
  mp_vPosTracerItem->end->setType(QCPItemPosition::ptPlotCoords);
  mp_vPosTracerItem->start->setCoords(0, 0);
  mp_vPosTracerItem->end->setCoords(0, 0);
 
  mp_hPosTracerItem = new QCPItemLine(this);
  mp_hPosTracerItem->setPen(m_pen);
  mp_hPosTracerItem->start->setType(QCPItemPosition::ptPlotCoords);
  mp_hPosTracerItem->end->setType(QCPItemPosition::ptPlotCoords);
  mp_hPosTracerItem->start->setCoords(0, 0);
  mp_hPosTracerItem->end->setCoords(0, 0);
 
  // The set of tracers (horizontal only) that track the region
  // spanning/selection regions.
  //
  // The start vertical tracer is colored in greeen.
  pen.setColor(QColor("green"));
 
  mp_vStartTracerItem = new QCPItemLine(this);
  mp_vStartTracerItem->setPen(pen);
  mp_vStartTracerItem->start->setType(QCPItemPosition::ptPlotCoords);
  mp_vStartTracerItem->end->setType(QCPItemPosition::ptPlotCoords);
  mp_vStartTracerItem->start->setCoords(0, 0);
  mp_vStartTracerItem->end->setCoords(0, 0);
 
  // The end vertical tracer is colored in red.
  pen.setColor(QColor("red"));
 
  mp_vEndTracerItem = new QCPItemLine(this);
  mp_vEndTracerItem->setPen(pen);
  mp_vEndTracerItem->start->setType(QCPItemPosition::ptPlotCoords);
  mp_vEndTracerItem->end->setType(QCPItemPosition::ptPlotCoords);
  mp_vEndTracerItem->start->setCoords(0, 0);
  mp_vEndTracerItem->end->setCoords(0, 0);
 
  mp_zoomRectItem = new QCPItemRect(this);
  mp_zoomRectItem->setPen(m_pen);
  mp_zoomRectItem->topLeft->setType(QCPItemPosition::ptPlotCoords);
  mp_zoomRectItem->bottomRight->setType(QCPItemPosition::ptPlotCoords);
  mp_zoomRectItem->setVisible(false);
 
  mp_selectLineItem = new QCPItemLine(this);
  mp_selectLineItem->setPen(m_pen);
  mp_selectLineItem->start->setType(QCPItemPosition::ptPlotCoords);
  mp_selectLineItem->end->setType(QCPItemPosition::ptPlotCoords);
  mp_selectLineItem->setVisible(false);
 
  // When the user click-drags the mouse, the X distance between the drag start
  // point and the drag end point (current point) is the xDelta.
  mp_xDeltaTextItem = new QCPItemText(this);
  mp_xDeltaTextItem->setPositionAlignment(Qt::AlignBottom | Qt::AlignCenter);
  mp_xDeltaTextItem->position->setType(QCPItemPosition::ptPlotCoords);
  mp_xDeltaTextItem->setVisible(false);
 
  // We want to capture the signals emitted by the QCustomPlot base class.
  connect(
    this, &QCustomPlot::mouseMove, this, &BasePlotWidget::mouseMoveHandler);
 
  connect(this,
          &QCustomPlot::mousePress,
          this,
          &BasePlotWidget::mousePressHandler);
 
  connect(this,
          &QCustomPlot::mouseRelease,
          this,
          &BasePlotWidget::mouseReleaseHandler);
 
  connect(this,
          &QCustomPlot::axisDoubleClick,
          this,
          &BasePlotWidget::axisDoubleClickHandler);
 
  return true;
}

References axisDoubleClickHandler(), m_pen, mouseMoveHandler(), mousePressHandler(), mouseReleaseHandler(), mp_hPosTracerItem, mp_selectLineItem, mp_vEndTracerItem, mp_vPosTracerItem, mp_vStartTracerItem, mp_xDeltaTextItem, and mp_zoomRectItem.

Referenced by BasePlotWidget().

showTracers()

void pappso::BasePlotWidget::showTracers ( )

virtual

Show the traces (vertical and horizontal).

Definition at line 1951 of file baseplotwidget.cpp.

{
  m_shouldTracersBeVisible = true;
 
  mp_vPosTracerItem->setVisible(true);
  mp_hPosTracerItem->setVisible(true);
 
  mp_vStartTracerItem->setVisible(true);
  mp_vEndTracerItem->setVisible(true);
 
  // Force a replot to make sure the action is immediately visible by the
  // user, even without moving the mouse.
  replot();
}

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 640 of file baseplotwidget.cpp.

{
  // qDebug();
}

Referenced by keyReleaseEvent().

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 392 of file baseplotwidget.cpp.

{
  m_xAxisRangeHistory.push_back(new QCPRange(xAxis->range()));
  m_yAxisRangeHistory.push_back(new QCPRange(yAxis->range()));
 
  m_lastAxisRangeHistoryIndex = m_xAxisRangeHistory.size() - 1;
 
  // qDebug() << "axes history size:" << m_xAxisRangeHistory.size()
  //<< "current index:" << m_lastAxisRangeHistoryIndex
  //<< xAxis->range().lower << "--" << xAxis->range().upper
  //<< "and"
  //<< yAxis->range().lower << "--" << yAxis->range().upper;
}

References m_lastAxisRangeHistoryIndex, m_xAxisRangeHistory, and m_yAxisRangeHistory.

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

updateContextRanges()

void pappso::BasePlotWidget::updateContextRanges ( )

virtual

Definition at line 2220 of file baseplotwidget.cpp.

{
  m_context.xRange = QCPRange(xAxis->range().lower, xAxis->range().upper);
  m_context.yRange = QCPRange(yAxis->range().lower, yAxis->range().upper);
}

References m_context, pappso::BasePlotContext::xRange, and pappso::BasePlotContext::yRange.

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

verticalGetGraphCoordNewPointCountPixels()

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

virtual

Definition at line 1542 of file baseplotwidget.cpp.

{
  QPointF pixel_coordinates(
    xAxis->coordToPixel(m_context.lastCursorHoveredPoint.x()),
    yAxis->coordToPixel(m_context.lastCursorHoveredPoint.y()) + pixel_count);
 
  // Now convert back to local coordinates.
 
  QPointF graph_coordinates(xAxis->pixelToCoord(pixel_coordinates.x()),
                            yAxis->pixelToCoord(pixel_coordinates.y()));
 
  return graph_coordinates;
}

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

Referenced by verticalMoveMouseCursorCountPixels().

verticalMoveMouseCursorCountPixels()

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

virtual

Definition at line 1525 of file baseplotwidget.cpp.

{
 
  QPointF graph_coord = verticalGetGraphCoordNewPointCountPixels(pixel_count);
 
  QPointF pixel_coord(xAxis->coordToPixel(graph_coord.x()),
                      yAxis->coordToPixel(graph_coord.y()));
 
  // Now we need ton convert the new coordinates to the global position system
  // and to move the cursor to that new position. That will create an event to
  // move the mouse cursor.
 
  moveMouseCursorPixelCoordToGlobal(pixel_coord.toPoint());
}

References moveMouseCursorPixelCoordToGlobal(), and verticalGetGraphCoordNewPointCountPixels().

Referenced by directionKeyPressEvent().

xAxisMeasurementSignal

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

signal

Referenced by drawRectangleAndPrepareZoom(), drawXDeltaLineAndMeasure(), and drawXDeltaLineForIntegration().

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 309 of file baseplotwidget.h.

m_axisLabelY

QString pappso::BasePlotWidget::m_axisLabelY

protected

Definition at line 310 of file baseplotwidget.h.

m_context

BasePlotContext pappso::BasePlotWidget::m_context

protected

Definition at line 312 of file baseplotwidget.h.

Referenced by pappso::BaseTracePlotWidget::axisDoubleClickHandler(), axisDoubleClickHandler(), pappso::BaseTracePlotWidget::axisPan(), axisPan(), pappso::BaseTracePlotWidget::axisReframe(), axisReframe(), pappso::BaseTracePlotWidget::axisRescale(), axisRescale(), pappso::BaseTracePlotWidget::axisZoom(), axisZoom(), calculateDragDeltas(), calculateDragDeltasAndUnSortedRegionCorners(), directionKeyPressEvent(), dragDirection(), drawRectangleAndPrepareZoom(), drawXDeltaLineAndMeasure(), drawXDeltaLineForIntegration(), pappso::DriftSpecTracePlotWidget::DriftSpecTracePlotWidget(), getContext(), horizontalGetGraphCoordNewPointCountPixels(), isProperSelectionRectangle(), pappso::DriftSpecTracePlotWidget::keyPressEvent(), pappso::TicXicChromTracePlotWidget::keyPressEvent(), keyPressEvent(), keyReleaseEvent(), pappso::MassSpecTracePlotWidget::MassSpecTracePlotWidget(), mouseMoveHandler(), mouseMoveHandlerDraggingCursor(), mouseMoveHandlerLeftButtonDraggingCursor(), mouseMoveHandlerNotDraggingCursor(), mouseMoveHandlerRightButtonDraggingCursor(), mousePressHandler(), mousePseudoButtonKeyReleaseEvent(), mouseReleaseHandler(), mouseReleaseHandlerLeftButton(), mouseReleaseHandlerRightButton(), prepareXDeltaLineAndMeasure(), pappso::MassSpecTracePlotWidget::refreshBaseContext(), restoreAxesRangeHistory(), pappso::TicXicChromTracePlotWidget::TicXicChromTracePlotWidget(), updateContextRanges(), and verticalGetGraphCoordNewPointCountPixels().

m_desc

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

protected

Description of the plot widget.

Definition at line 304 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 307 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 389 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 387 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 350 of file baseplotwidget.h.

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

m_leftMousePseudoButtonKey

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

protected

Definition at line 314 of file baseplotwidget.h.

Referenced by keyPressEvent(), keyReleaseEvent(), and mousePseudoButtonKeyReleaseEvent().

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 368 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 376 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 301 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 392 of file baseplotwidget.h.

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

m_rightMousePseudoButtonKey

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

protected

Definition at line 315 of file baseplotwidget.h.

Referenced by keyPressEvent(), keyReleaseEvent(), and mousePseudoButtonKeyReleaseEvent().

m_shouldTracersBeVisible

bool pappso::BasePlotWidget::m_shouldTracersBeVisible = true

protected

Tells if the tracers should be visible.

Definition at line 327 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 384 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 382 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 353 of file baseplotwidget.h.

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

m_yAxisRangeHistory

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

protected

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

Definition at line 356 of file baseplotwidget.h.

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

mp_hPosTracerItem

QCPItemLine* pappso::BasePlotWidget::mp_hPosTracerItem

protected

Horizontal position tracer.

Definition at line 330 of file baseplotwidget.h.

Referenced by hideTracers(), mouseMoveHandlerDraggingCursor(), mouseMoveHandlerLeftButtonDraggingCursor(), mouseMoveHandlerNotDraggingCursor(), mouseReleaseHandler(), prepareXDeltaLineAndMeasure(), restoreAxesRangeHistory(), setupWidget(), and showTracers().

mp_selectLineItem

QCPItemLine* pappso::BasePlotWidget::mp_selectLineItem = nullptr

protected

Line that is printed when the user selects a range.

Definition at line 321 of file baseplotwidget.h.

Referenced by drawRectangleAndPrepareZoom(), drawXDeltaLineAndMeasure(), drawXDeltaLineForIntegration(), hideAllPlotItems(), mouseReleaseHandler(), mouseReleaseHandlerRightButton(), prepareXDeltaLineAndMeasure(), and setupWidget().

mp_vEndTracerItem

QCPItemLine* pappso::BasePlotWidget::mp_vEndTracerItem

protected

Vertical selection end tracer (typically in red).

Definition at line 339 of file baseplotwidget.h.

Referenced by hideTracers(), mouseMoveHandlerDraggingCursor(), mouseMoveHandlerLeftButtonDraggingCursor(), mouseMoveHandlerNotDraggingCursor(), mouseReleaseHandler(), mouseReleaseHandlerRightButton(), restoreAxesRangeHistory(), setupWidget(), and showTracers().

mp_vPosTracerItem

QCPItemLine* pappso::BasePlotWidget::mp_vPosTracerItem

protected

Vertical position tracer.

Definition at line 333 of file baseplotwidget.h.

Referenced by hideTracers(), mouseMoveHandlerDraggingCursor(), mouseMoveHandlerLeftButtonDraggingCursor(), mouseMoveHandlerNotDraggingCursor(), mouseReleaseHandler(), prepareXDeltaLineAndMeasure(), restoreAxesRangeHistory(), setupWidget(), and showTracers().

mp_vStartTracerItem

QCPItemLine* pappso::BasePlotWidget::mp_vStartTracerItem

protected

Vertical selection start tracer (typically in green).

Definition at line 336 of file baseplotwidget.h.

Referenced by hideTracers(), mouseMoveHandlerDraggingCursor(), mouseMoveHandlerLeftButtonDraggingCursor(), mousePressHandler(), restoreAxesRangeHistory(), setupWidget(), and showTracers().

mp_xDeltaTextItem

QCPItemText* pappso::BasePlotWidget::mp_xDeltaTextItem = nullptr

protected

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

Definition at line 324 of file baseplotwidget.h.

Referenced by drawRectangleAndPrepareZoom(), hideAllPlotItems(), mouseReleaseHandler(), mouseReleaseHandlerRightButton(), prepareXDeltaLineAndMeasure(), and setupWidget().

mp_zoomRectItem

QCPItemRect* pappso::BasePlotWidget::mp_zoomRectItem = nullptr

protected

Rectangle defining the borders of zoomed-in/out data.

Definition at line 318 of file baseplotwidget.h.

Referenced by drawRectangleAndPrepareZoom(), hideAllPlotItems(), mouseReleaseHandlerLeftButton(), prepareXDeltaLineAndMeasure(), and setupWidget().

---

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

• pappsomspp/widget/plotwidget/baseplotwidget.h
• pappsomspp/widget/plotwidget/baseplotwidget.cpp