|
|
/***************************************************************************
|
|
|
** **
|
|
|
** QCustomPlot, an easy to use, modern plotting widget for Qt **
|
|
|
** Copyright (C) 2011, 2012, 2013, 2014 Emanuel Eichhammer **
|
|
|
** **
|
|
|
** This program is free software: you can redistribute it and/or modify **
|
|
|
** it under the terms of the GNU General Public License as published by **
|
|
|
** the Free Software Foundation, either version 3 of the License, or **
|
|
|
** (at your option) any later version. **
|
|
|
** **
|
|
|
** This program is distributed in the hope that it will be useful, **
|
|
|
** but WITHOUT ANY WARRANTY; without even the implied warranty of **
|
|
|
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the **
|
|
|
** GNU General Public License for more details. **
|
|
|
** **
|
|
|
** You should have received a copy of the GNU General Public License **
|
|
|
** along with this program. If not, see http://www.gnu.org/licenses/. **
|
|
|
** **
|
|
|
****************************************************************************
|
|
|
** Author: Emanuel Eichhammer **
|
|
|
** Website/Contact: http://www.qcustomplot.com/ **
|
|
|
** Date: 07.04.14 **
|
|
|
** Version: 1.2.1 **
|
|
|
****************************************************************************/
|
|
|
|
|
|
#ifndef QCUSTOMPLOT_H
|
|
|
#define QCUSTOMPLOT_H
|
|
|
|
|
|
#include <QObject>
|
|
|
#include <QPointer>
|
|
|
#include <QWidget>
|
|
|
#include <QPainter>
|
|
|
#include <QPaintEvent>
|
|
|
#include <QMouseEvent>
|
|
|
#include <QPixmap>
|
|
|
#include <QVector>
|
|
|
#include <QString>
|
|
|
#include <QDateTime>
|
|
|
#include <QMultiMap>
|
|
|
#include <QFlags>
|
|
|
#include <QDebug>
|
|
|
#include <QVector2D>
|
|
|
#include <QStack>
|
|
|
#include <QCache>
|
|
|
#include <QMargins>
|
|
|
#include <qmath.h>
|
|
|
#include <limits>
|
|
|
#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
|
|
|
# include <qnumeric.h>
|
|
|
# include <QPrinter>
|
|
|
# include <QPrintEngine>
|
|
|
#else
|
|
|
# include <QtNumeric>
|
|
|
# include <QtPrintSupport>
|
|
|
#endif
|
|
|
|
|
|
class QCPPainter;
|
|
|
class QCustomPlot;
|
|
|
class QCPLayerable;
|
|
|
class QCPLayoutElement;
|
|
|
class QCPLayout;
|
|
|
class QCPAxis;
|
|
|
class QCPAxisRect;
|
|
|
class QCPAxisPainterPrivate;
|
|
|
class QCPAbstractPlottable;
|
|
|
class QCPGraph;
|
|
|
class QCPAbstractItem;
|
|
|
class QCPItemPosition;
|
|
|
class QCPLayer;
|
|
|
class QCPPlotTitle;
|
|
|
class QCPLegend;
|
|
|
class QCPAbstractLegendItem;
|
|
|
class QCPColorMap;
|
|
|
class QCPColorScale;
|
|
|
|
|
|
|
|
|
/*! \file */
|
|
|
|
|
|
|
|
|
// decl definitions for shared library compilation/usage:
|
|
|
#if defined(QCUSTOMPLOT_COMPILE_LIBRARY)
|
|
|
# define QCP_LIB_DECL Q_DECL_EXPORT
|
|
|
#elif defined(QCUSTOMPLOT_USE_LIBRARY)
|
|
|
# define QCP_LIB_DECL Q_DECL_IMPORT
|
|
|
#else
|
|
|
# define QCP_LIB_DECL
|
|
|
#endif
|
|
|
|
|
|
/*!
|
|
|
The QCP Namespace contains general enums and QFlags used throughout the QCustomPlot library
|
|
|
*/
|
|
|
namespace QCP
|
|
|
{
|
|
|
/*!
|
|
|
Defines the sides of a rectangular entity to which margins can be applied.
|
|
|
|
|
|
\see QCPLayoutElement::setAutoMargins, QCPAxisRect::setAutoMargins
|
|
|
*/
|
|
|
enum MarginSide { msLeft = 0x01 ///< <tt>0x01</tt> left margin
|
|
|
,msRight = 0x02 ///< <tt>0x02</tt> right margin
|
|
|
,msTop = 0x04 ///< <tt>0x04</tt> top margin
|
|
|
,msBottom = 0x08 ///< <tt>0x08</tt> bottom margin
|
|
|
,msAll = 0xFF ///< <tt>0xFF</tt> all margins
|
|
|
,msNone = 0x00 ///< <tt>0x00</tt> no margin
|
|
|
};
|
|
|
Q_DECLARE_FLAGS(MarginSides, MarginSide)
|
|
|
|
|
|
/*!
|
|
|
Defines what objects of a plot can be forcibly drawn antialiased/not antialiased. If an object is
|
|
|
neither forcibly drawn antialiased nor forcibly drawn not antialiased, it is up to the respective
|
|
|
element how it is drawn. Typically it provides a \a setAntialiased function for this.
|
|
|
|
|
|
\c AntialiasedElements is a flag of or-combined elements of this enum type.
|
|
|
|
|
|
\see QCustomPlot::setAntialiasedElements, QCustomPlot::setNotAntialiasedElements
|
|
|
*/
|
|
|
enum AntialiasedElement { aeAxes = 0x0001 ///< <tt>0x0001</tt> Axis base line and tick marks
|
|
|
,aeGrid = 0x0002 ///< <tt>0x0002</tt> Grid lines
|
|
|
,aeSubGrid = 0x0004 ///< <tt>0x0004</tt> Sub grid lines
|
|
|
,aeLegend = 0x0008 ///< <tt>0x0008</tt> Legend box
|
|
|
,aeLegendItems = 0x0010 ///< <tt>0x0010</tt> Legend items
|
|
|
,aePlottables = 0x0020 ///< <tt>0x0020</tt> Main lines of plottables (excluding error bars, see element \ref aeErrorBars)
|
|
|
,aeItems = 0x0040 ///< <tt>0x0040</tt> Main lines of items
|
|
|
,aeScatters = 0x0080 ///< <tt>0x0080</tt> Scatter symbols of plottables (excluding scatter symbols of type ssPixmap)
|
|
|
,aeErrorBars = 0x0100 ///< <tt>0x0100</tt> Error bars
|
|
|
,aeFills = 0x0200 ///< <tt>0x0200</tt> Borders of fills (e.g. under or between graphs)
|
|
|
,aeZeroLine = 0x0400 ///< <tt>0x0400</tt> Zero-lines, see \ref QCPGrid::setZeroLinePen
|
|
|
,aeAll = 0xFFFF ///< <tt>0xFFFF</tt> All elements
|
|
|
,aeNone = 0x0000 ///< <tt>0x0000</tt> No elements
|
|
|
};
|
|
|
Q_DECLARE_FLAGS(AntialiasedElements, AntialiasedElement)
|
|
|
|
|
|
/*!
|
|
|
Defines plotting hints that control various aspects of the quality and speed of plotting.
|
|
|
|
|
|
\see QCustomPlot::setPlottingHints
|
|
|
*/
|
|
|
enum PlottingHint { phNone = 0x000 ///< <tt>0x000</tt> No hints are set
|
|
|
,phFastPolylines = 0x001 ///< <tt>0x001</tt> Graph/Curve lines are drawn with a faster method. This reduces the quality
|
|
|
///< especially of the line segment joins. (Only relevant for solid line pens.)
|
|
|
,phForceRepaint = 0x002 ///< <tt>0x002</tt> causes an immediate repaint() instead of a soft update() when QCustomPlot::replot() is called with parameter \ref QCustomPlot::rpHint.
|
|
|
///< This is set by default to prevent the plot from freezing on fast consecutive replots (e.g. user drags ranges with mouse).
|
|
|
,phCacheLabels = 0x004 ///< <tt>0x004</tt> axis (tick) labels will be cached as pixmaps, increasing replot performance.
|
|
|
};
|
|
|
Q_DECLARE_FLAGS(PlottingHints, PlottingHint)
|
|
|
|
|
|
/*!
|
|
|
Defines the mouse interactions possible with QCustomPlot.
|
|
|
|
|
|
\c Interactions is a flag of or-combined elements of this enum type.
|
|
|
|
|
|
\see QCustomPlot::setInteractions
|
|
|
*/
|
|
|
enum Interaction { iRangeDrag = 0x001 ///< <tt>0x001</tt> Axis ranges are draggable (see \ref QCPAxisRect::setRangeDrag, \ref QCPAxisRect::setRangeDragAxes)
|
|
|
,iRangeZoom = 0x002 ///< <tt>0x002</tt> Axis ranges are zoomable with the mouse wheel (see \ref QCPAxisRect::setRangeZoom, \ref QCPAxisRect::setRangeZoomAxes)
|
|
|
,iMultiSelect = 0x004 ///< <tt>0x004</tt> The user can select multiple objects by holding the modifier set by \ref QCustomPlot::setMultiSelectModifier while clicking
|
|
|
,iSelectPlottables = 0x008 ///< <tt>0x008</tt> Plottables are selectable (e.g. graphs, curves, bars,... see QCPAbstractPlottable)
|
|
|
,iSelectAxes = 0x010 ///< <tt>0x010</tt> Axes are selectable (or parts of them, see QCPAxis::setSelectableParts)
|
|
|
,iSelectLegend = 0x020 ///< <tt>0x020</tt> Legends are selectable (or their child items, see QCPLegend::setSelectableParts)
|
|
|
,iSelectItems = 0x040 ///< <tt>0x040</tt> Items are selectable (Rectangles, Arrows, Textitems, etc. see \ref QCPAbstractItem)
|
|
|
,iSelectOther = 0x080 ///< <tt>0x080</tt> All other objects are selectable (e.g. your own derived layerables, the plot title,...)
|
|
|
};
|
|
|
Q_DECLARE_FLAGS(Interactions, Interaction)
|
|
|
|
|
|
/*! \internal
|
|
|
|
|
|
Returns whether the specified \a value is considered an invalid data value for plottables (i.e.
|
|
|
is \e nan or \e +/-inf). This function is used to check data validity upon replots, when the
|
|
|
compiler flag \c QCUSTOMPLOT_CHECK_DATA is set.
|
|
|
*/
|
|
|
inline bool isInvalidData(double value)
|
|
|
{
|
|
|
return qIsNaN(value) || qIsInf(value);
|
|
|
}
|
|
|
|
|
|
/*! \internal
|
|
|
\overload
|
|
|
|
|
|
Checks two arguments instead of one.
|
|
|
*/
|
|
|
inline bool isInvalidData(double value1, double value2)
|
|
|
{
|
|
|
return isInvalidData(value1) || isInvalidData(value2);
|
|
|
}
|
|
|
|
|
|
/*! \internal
|
|
|
|
|
|
Sets the specified \a side of \a margins to \a value
|
|
|
|
|
|
\see getMarginValue
|
|
|
*/
|
|
|
inline void setMarginValue(QMargins &margins, QCP::MarginSide side, int value)
|
|
|
{
|
|
|
switch (side)
|
|
|
{
|
|
|
case QCP::msLeft: margins.setLeft(value); break;
|
|
|
case QCP::msRight: margins.setRight(value); break;
|
|
|
case QCP::msTop: margins.setTop(value); break;
|
|
|
case QCP::msBottom: margins.setBottom(value); break;
|
|
|
case QCP::msAll: margins = QMargins(value, value, value, value); break;
|
|
|
default: break;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/*! \internal
|
|
|
|
|
|
Returns the value of the specified \a side of \a margins. If \a side is \ref QCP::msNone or
|
|
|
\ref QCP::msAll, returns 0.
|
|
|
|
|
|
\see setMarginValue
|
|
|
*/
|
|
|
inline int getMarginValue(const QMargins &margins, QCP::MarginSide side)
|
|
|
{
|
|
|
switch (side)
|
|
|
{
|
|
|
case QCP::msLeft: return margins.left();
|
|
|
case QCP::msRight: return margins.right();
|
|
|
case QCP::msTop: return margins.top();
|
|
|
case QCP::msBottom: return margins.bottom();
|
|
|
default: break;
|
|
|
}
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
} // end of namespace QCP
|
|
|
|
|
|
Q_DECLARE_OPERATORS_FOR_FLAGS(QCP::AntialiasedElements)
|
|
|
Q_DECLARE_OPERATORS_FOR_FLAGS(QCP::PlottingHints)
|
|
|
Q_DECLARE_OPERATORS_FOR_FLAGS(QCP::MarginSides)
|
|
|
Q_DECLARE_OPERATORS_FOR_FLAGS(QCP::Interactions)
|
|
|
|
|
|
|
|
|
class QCP_LIB_DECL QCPScatterStyle
|
|
|
{
|
|
|
Q_GADGET
|
|
|
public:
|
|
|
/*!
|
|
|
Defines the shape used for scatter points.
|
|
|
|
|
|
On plottables/items that draw scatters, the sizes of these visualizations (with exception of
|
|
|
\ref ssDot and \ref ssPixmap) can be controlled with the \ref setSize function. Scatters are
|
|
|
drawn with the pen and brush specified with \ref setPen and \ref setBrush.
|
|
|
*/
|
|
|
Q_ENUMS(ScatterShape)
|
|
|
enum ScatterShape { ssNone ///< no scatter symbols are drawn (e.g. in QCPGraph, data only represented with lines)
|
|
|
,ssDot ///< \enumimage{ssDot.png} a single pixel (use \ref ssDisc or \ref ssCircle if you want a round shape with a certain radius)
|
|
|
,ssCross ///< \enumimage{ssCross.png} a cross
|
|
|
,ssPlus ///< \enumimage{ssPlus.png} a plus
|
|
|
,ssCircle ///< \enumimage{ssCircle.png} a circle
|
|
|
,ssDisc ///< \enumimage{ssDisc.png} a circle which is filled with the pen's color (not the brush as with ssCircle)
|
|
|
,ssSquare ///< \enumimage{ssSquare.png} a square
|
|
|
,ssDiamond ///< \enumimage{ssDiamond.png} a diamond
|
|
|
,ssStar ///< \enumimage{ssStar.png} a star with eight arms, i.e. a combination of cross and plus
|
|
|
,ssTriangle ///< \enumimage{ssTriangle.png} an equilateral triangle, standing on baseline
|
|
|
,ssTriangleInverted ///< \enumimage{ssTriangleInverted.png} an equilateral triangle, standing on corner
|
|
|
,ssCrossSquare ///< \enumimage{ssCrossSquare.png} a square with a cross inside
|
|
|
,ssPlusSquare ///< \enumimage{ssPlusSquare.png} a square with a plus inside
|
|
|
,ssCrossCircle ///< \enumimage{ssCrossCircle.png} a circle with a cross inside
|
|
|
,ssPlusCircle ///< \enumimage{ssPlusCircle.png} a circle with a plus inside
|
|
|
,ssPeace ///< \enumimage{ssPeace.png} a circle, with one vertical and two downward diagonal lines
|
|
|
,ssPixmap ///< a custom pixmap specified by \ref setPixmap, centered on the data point coordinates
|
|
|
,ssCustom ///< custom painter operations are performed per scatter (As QPainterPath, see \ref setCustomPath)
|
|
|
};
|
|
|
|
|
|
QCPScatterStyle();
|
|
|
QCPScatterStyle(ScatterShape shape, double size=6);
|
|
|
QCPScatterStyle(ScatterShape shape, const QColor &color, double size);
|
|
|
QCPScatterStyle(ScatterShape shape, const QColor &color, const QColor &fill, double size);
|
|
|
QCPScatterStyle(ScatterShape shape, const QPen &pen, const QBrush &brush, double size);
|
|
|
QCPScatterStyle(const QPixmap &pixmap);
|
|
|
QCPScatterStyle(const QPainterPath &customPath, const QPen &pen, const QBrush &brush=Qt::NoBrush, double size=6);
|
|
|
|
|
|
// getters:
|
|
|
double size() const { return mSize; }
|
|
|
ScatterShape shape() const { return mShape; }
|
|
|
QPen pen() const { return mPen; }
|
|
|
QBrush brush() const { return mBrush; }
|
|
|
QPixmap pixmap() const { return mPixmap; }
|
|
|
QPainterPath customPath() const { return mCustomPath; }
|
|
|
|
|
|
// setters:
|
|
|
void setSize(double size);
|
|
|
void setShape(ScatterShape shape);
|
|
|
void setPen(const QPen &pen);
|
|
|
void setBrush(const QBrush &brush);
|
|
|
void setPixmap(const QPixmap &pixmap);
|
|
|
void setCustomPath(const QPainterPath &customPath);
|
|
|
|
|
|
// non-property methods:
|
|
|
bool isNone() const { return mShape == ssNone; }
|
|
|
bool isPenDefined() const { return mPenDefined; }
|
|
|
void applyTo(QCPPainter *painter, const QPen &defaultPen) const;
|
|
|
void drawShape(QCPPainter *painter, QPointF pos) const;
|
|
|
void drawShape(QCPPainter *painter, double x, double y) const;
|
|
|
|
|
|
protected:
|
|
|
// property members:
|
|
|
double mSize;
|
|
|
ScatterShape mShape;
|
|
|
QPen mPen;
|
|
|
QBrush mBrush;
|
|
|
QPixmap mPixmap;
|
|
|
QPainterPath mCustomPath;
|
|
|
|
|
|
// non-property members:
|
|
|
bool mPenDefined;
|
|
|
};
|
|
|
Q_DECLARE_TYPEINFO(QCPScatterStyle, Q_MOVABLE_TYPE);
|
|
|
|
|
|
|
|
|
class QCP_LIB_DECL QCPPainter : public QPainter
|
|
|
{
|
|
|
Q_GADGET
|
|
|
public:
|
|
|
/*!
|
|
|
Defines special modes the painter can operate in. They disable or enable certain subsets of features/fixes/workarounds,
|
|
|
depending on whether they are wanted on the respective output device.
|
|
|
*/
|
|
|
enum PainterMode { pmDefault = 0x00 ///< <tt>0x00</tt> Default mode for painting on screen devices
|
|
|
,pmVectorized = 0x01 ///< <tt>0x01</tt> Mode for vectorized painting (e.g. PDF export). For example, this prevents some antialiasing fixes.
|
|
|
,pmNoCaching = 0x02 ///< <tt>0x02</tt> Mode for all sorts of exports (e.g. PNG, PDF,...). For example, this prevents using cached pixmap labels
|
|
|
,pmNonCosmetic = 0x04 ///< <tt>0x04</tt> Turns pen widths 0 to 1, i.e. disables cosmetic pens. (A cosmetic pen is always drawn with width 1 pixel in the vector image/pdf viewer, independent of zoom.)
|
|
|
};
|
|
|
Q_FLAGS(PainterMode PainterModes)
|
|
|
Q_DECLARE_FLAGS(PainterModes, PainterMode)
|
|
|
|
|
|
QCPPainter();
|
|
|
QCPPainter(QPaintDevice *device);
|
|
|
~QCPPainter();
|
|
|
|
|
|
// getters:
|
|
|
bool antialiasing() const { return testRenderHint(QPainter::Antialiasing); }
|
|
|
PainterModes modes() const { return mModes; }
|
|
|
|
|
|
// setters:
|
|
|
void setAntialiasing(bool enabled);
|
|
|
void setMode(PainterMode mode, bool enabled=true);
|
|
|
void setModes(PainterModes modes);
|
|
|
|
|
|
// methods hiding non-virtual base class functions (QPainter bug workarounds):
|
|
|
bool begin(QPaintDevice *device);
|
|
|
void setPen(const QPen &pen);
|
|
|
void setPen(const QColor &color);
|
|
|
void setPen(Qt::PenStyle penStyle);
|
|
|
void drawLine(const QLineF &line);
|
|
|
void drawLine(const QPointF &p1, const QPointF &p2) {drawLine(QLineF(p1, p2));}
|
|
|
void save();
|
|
|
void restore();
|
|
|
|
|
|
// non-virtual methods:
|
|
|
void makeNonCosmetic();
|
|
|
|
|
|
protected:
|
|
|
// property members:
|
|
|
PainterModes mModes;
|
|
|
bool mIsAntialiasing;
|
|
|
|
|
|
// non-property members:
|
|
|
QStack<bool> mAntialiasingStack;
|
|
|
};
|
|
|
Q_DECLARE_OPERATORS_FOR_FLAGS(QCPPainter::PainterModes)
|
|
|
|
|
|
|
|
|
class QCP_LIB_DECL QCPLayer : public QObject
|
|
|
{
|
|
|
Q_OBJECT
|
|
|
/// \cond INCLUDE_QPROPERTIES
|
|
|
Q_PROPERTY(QCustomPlot* parentPlot READ parentPlot)
|
|
|
Q_PROPERTY(QString name READ name)
|
|
|
Q_PROPERTY(int index READ index)
|
|
|
Q_PROPERTY(QList<QCPLayerable*> children READ children)
|
|
|
Q_PROPERTY(bool visible READ visible WRITE setVisible)
|
|
|
/// \endcond
|
|
|
public:
|
|
|
QCPLayer(QCustomPlot* parentPlot, const QString &layerName);
|
|
|
~QCPLayer();
|
|
|
|
|
|
// getters:
|
|
|
QCustomPlot *parentPlot() const { return mParentPlot; }
|
|
|
QString name() const { return mName; }
|
|
|
int index() const { return mIndex; }
|
|
|
QList<QCPLayerable*> children() const { return mChildren; }
|
|
|
bool visible() const { return mVisible; }
|
|
|
|
|
|
// setters:
|
|
|
void setVisible(bool visible);
|
|
|
|
|
|
protected:
|
|
|
// property members:
|
|
|
QCustomPlot *mParentPlot;
|
|
|
QString mName;
|
|
|
int mIndex;
|
|
|
QList<QCPLayerable*> mChildren;
|
|
|
bool mVisible;
|
|
|
|
|
|
// non-virtual methods:
|
|
|
void addChild(QCPLayerable *layerable, bool prepend);
|
|
|
void removeChild(QCPLayerable *layerable);
|
|
|
|
|
|
private:
|
|
|
Q_DISABLE_COPY(QCPLayer)
|
|
|
|
|
|
friend class QCustomPlot;
|
|
|
friend class QCPLayerable;
|
|
|
};
|
|
|
|
|
|
class QCP_LIB_DECL QCPLayerable : public QObject
|
|
|
{
|
|
|
Q_OBJECT
|
|
|
/// \cond INCLUDE_QPROPERTIES
|
|
|
Q_PROPERTY(bool visible READ visible WRITE setVisible)
|
|
|
Q_PROPERTY(QCustomPlot* parentPlot READ parentPlot)
|
|
|
Q_PROPERTY(QCPLayerable* parentLayerable READ parentLayerable)
|
|
|
Q_PROPERTY(QCPLayer* layer READ layer WRITE setLayer NOTIFY layerChanged)
|
|
|
Q_PROPERTY(bool antialiased READ antialiased WRITE setAntialiased)
|
|
|
/// \endcond
|
|
|
public:
|
|
|
QCPLayerable(QCustomPlot *plot, QString targetLayer="", QCPLayerable *parentLayerable=0);
|
|
|
~QCPLayerable();
|
|
|
|
|
|
// getters:
|
|
|
bool visible() const { return mVisible; }
|
|
|
QCustomPlot *parentPlot() const { return mParentPlot; }
|
|
|
QCPLayerable *parentLayerable() const { return mParentLayerable.data(); }
|
|
|
QCPLayer *layer() const { return mLayer; }
|
|
|
bool antialiased() const { return mAntialiased; }
|
|
|
|
|
|
// setters:
|
|
|
void setVisible(bool on);
|
|
|
Q_SLOT bool setLayer(QCPLayer *layer);
|
|
|
bool setLayer(const QString &layerName);
|
|
|
void setAntialiased(bool enabled);
|
|
|
|
|
|
// introduced virtual methods:
|
|
|
virtual double selectTest(const QPointF &pos, bool onlySelectable, QVariant *details=0) const;
|
|
|
|
|
|
// non-property methods:
|
|
|
bool realVisibility() const;
|
|
|
|
|
|
signals:
|
|
|
void layerChanged(QCPLayer *newLayer);
|
|
|
|
|
|
protected:
|
|
|
// property members:
|
|
|
bool mVisible;
|
|
|
QCustomPlot *mParentPlot;
|
|
|
QPointer<QCPLayerable> mParentLayerable;
|
|
|
QCPLayer *mLayer;
|
|
|
bool mAntialiased;
|
|
|
|
|
|
// introduced virtual methods:
|
|
|
virtual void parentPlotInitialized(QCustomPlot *parentPlot);
|
|
|
virtual QCP::Interaction selectionCategory() const;
|
|
|
virtual QRect clipRect() const;
|
|
|
virtual void applyDefaultAntialiasingHint(QCPPainter *painter) const = 0;
|
|
|
virtual void draw(QCPPainter *painter) = 0;
|
|
|
// events:
|
|
|
virtual void selectEvent(QMouseEvent *event, bool additive, const QVariant &details, bool *selectionStateChanged);
|
|
|
virtual void deselectEvent(bool *selectionStateChanged);
|
|
|
|
|
|
// non-property methods:
|
|
|
void initializeParentPlot(QCustomPlot *parentPlot);
|
|
|
void setParentLayerable(QCPLayerable* parentLayerable);
|
|
|
bool moveToLayer(QCPLayer *layer, bool prepend);
|
|
|
void applyAntialiasingHint(QCPPainter *painter, bool localAntialiased, QCP::AntialiasedElement overrideElement) const;
|
|
|
|
|
|
private:
|
|
|
Q_DISABLE_COPY(QCPLayerable)
|
|
|
|
|
|
friend class QCustomPlot;
|
|
|
friend class QCPAxisRect;
|
|
|
};
|
|
|
|
|
|
|
|
|
class QCP_LIB_DECL QCPRange
|
|
|
{
|
|
|
public:
|
|
|
double lower, upper;
|
|
|
|
|
|
QCPRange();
|
|
|
QCPRange(double lower, double upper);
|
|
|
|
|
|
bool operator==(const QCPRange& other) { return lower == other.lower && upper == other.upper; }
|
|
|
bool operator!=(const QCPRange& other) { return !(*this == other); }
|
|
|
|
|
|
QCPRange &operator+=(const double& value) { lower+=value; upper+=value; return *this; }
|
|
|
QCPRange &operator-=(const double& value) { lower-=value; upper-=value; return *this; }
|
|
|
QCPRange &operator*=(const double& value) { lower*=value; upper*=value; return *this; }
|
|
|
QCPRange &operator/=(const double& value) { lower/=value; upper/=value; return *this; }
|
|
|
friend inline const QCPRange operator+(const QCPRange&, double);
|
|
|
friend inline const QCPRange operator+(double, const QCPRange&);
|
|
|
friend inline const QCPRange operator-(const QCPRange& range, double value);
|
|
|
friend inline const QCPRange operator*(const QCPRange& range, double value);
|
|
|
friend inline const QCPRange operator*(double value, const QCPRange& range);
|
|
|
friend inline const QCPRange operator/(const QCPRange& range, double value);
|
|
|
|
|
|
double size() const;
|
|
|
double center() const;
|
|
|
void normalize();
|
|
|
void expand(const QCPRange &otherRange);
|
|
|
QCPRange expanded(const QCPRange &otherRange) const;
|
|
|
QCPRange sanitizedForLogScale() const;
|
|
|
QCPRange sanitizedForLinScale() const;
|
|
|
bool contains(double value) const;
|
|
|
|
|
|
static bool validRange(double lower, double upper);
|
|
|
static bool validRange(const QCPRange &range);
|
|
|
static const double minRange; //1e-280;
|
|
|
static const double maxRange; //1e280;
|
|
|
|
|
|
};
|
|
|
Q_DECLARE_TYPEINFO(QCPRange, Q_MOVABLE_TYPE);
|
|
|
|
|
|
/* documentation of inline functions */
|
|
|
|
|
|
/*! \fn QCPRange &QCPRange::operator+=(const double& value)
|
|
|
|
|
|
Adds \a value to both boundaries of the range.
|
|
|
*/
|
|
|
|
|
|
/*! \fn QCPRange &QCPRange::operator-=(const double& value)
|
|
|
|
|
|
Subtracts \a value from both boundaries of the range.
|
|
|
*/
|
|
|
|
|
|
/*! \fn QCPRange &QCPRange::operator*=(const double& value)
|
|
|
|
|
|
Multiplies both boundaries of the range by \a value.
|
|
|
*/
|
|
|
|
|
|
/*! \fn QCPRange &QCPRange::operator/=(const double& value)
|
|
|
|
|
|
Divides both boundaries of the range by \a value.
|
|
|
*/
|
|
|
|
|
|
/* end documentation of inline functions */
|
|
|
|
|
|
/*!
|
|
|
Adds \a value to both boundaries of the range.
|
|
|
*/
|
|
|
inline const QCPRange operator+(const QCPRange& range, double value)
|
|
|
{
|
|
|
QCPRange result(range);
|
|
|
result += value;
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
/*!
|
|
|
Adds \a value to both boundaries of the range.
|
|
|
*/
|
|
|
inline const QCPRange operator+(double value, const QCPRange& range)
|
|
|
{
|
|
|
QCPRange result(range);
|
|
|
result += value;
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
/*!
|
|
|
Subtracts \a value from both boundaries of the range.
|
|
|
*/
|
|
|
inline const QCPRange operator-(const QCPRange& range, double value)
|
|
|
{
|
|
|
QCPRange result(range);
|
|
|
result -= value;
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
/*!
|
|
|
Multiplies both boundaries of the range by \a value.
|
|
|
*/
|
|
|
inline const QCPRange operator*(const QCPRange& range, double value)
|
|
|
{
|
|
|
QCPRange result(range);
|
|
|
result *= value;
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
/*!
|
|
|
Multiplies both boundaries of the range by \a value.
|
|
|
*/
|
|
|
inline const QCPRange operator*(double value, const QCPRange& range)
|
|
|
{
|
|
|
QCPRange result(range);
|
|
|
result *= value;
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
/*!
|
|
|
Divides both boundaries of the range by \a value.
|
|
|
*/
|
|
|
inline const QCPRange operator/(const QCPRange& range, double value)
|
|
|
{
|
|
|
QCPRange result(range);
|
|
|
result /= value;
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
|
|
|
class QCP_LIB_DECL QCPMarginGroup : public QObject
|
|
|
{
|
|
|
Q_OBJECT
|
|
|
public:
|
|
|
QCPMarginGroup(QCustomPlot *parentPlot);
|
|
|
~QCPMarginGroup();
|
|
|
|
|
|
// non-virtual methods:
|
|
|
QList<QCPLayoutElement*> elements(QCP::MarginSide side) const { return mChildren.value(side); }
|
|
|
bool isEmpty() const;
|
|
|
void clear();
|
|
|
|
|
|
protected:
|
|
|
// non-property members:
|
|
|
QCustomPlot *mParentPlot;
|
|
|
QHash<QCP::MarginSide, QList<QCPLayoutElement*> > mChildren;
|
|
|
|
|
|
// non-virtual methods:
|
|
|
int commonMargin(QCP::MarginSide side) const;
|
|
|
void addChild(QCP::MarginSide side, QCPLayoutElement *element);
|
|
|
void removeChild(QCP::MarginSide side, QCPLayoutElement *element);
|
|
|
|
|
|
private:
|
|
|
Q_DISABLE_COPY(QCPMarginGroup)
|
|
|
|
|
|
friend class QCPLayoutElement;
|
|
|
};
|
|
|
|
|
|
|
|
|
class QCP_LIB_DECL QCPLayoutElement : public QCPLayerable
|
|
|
{
|
|
|
Q_OBJECT
|
|
|
/// \cond INCLUDE_QPROPERTIES
|
|
|
Q_PROPERTY(QCPLayout* layout READ layout)
|
|
|
Q_PROPERTY(QRect rect READ rect)
|
|
|
Q_PROPERTY(QRect outerRect READ outerRect WRITE setOuterRect)
|
|
|
Q_PROPERTY(QMargins margins READ margins WRITE setMargins)
|
|
|
Q_PROPERTY(QMargins minimumMargins READ minimumMargins WRITE setMinimumMargins)
|
|
|
Q_PROPERTY(QSize minimumSize READ minimumSize WRITE setMinimumSize)
|
|
|
Q_PROPERTY(QSize maximumSize READ maximumSize WRITE setMaximumSize)
|
|
|
/// \endcond
|
|
|
public:
|
|
|
/*!
|
|
|
Defines the phases of the update process, that happens just before a replot. At each phase,
|
|
|
\ref update is called with the according UpdatePhase value.
|
|
|
*/
|
|
|
enum UpdatePhase { upPreparation ///< Phase used for any type of preparation that needs to be done before margin calculation and layout
|
|
|
,upMargins ///< Phase in which the margins are calculated and set
|
|
|
,upLayout ///< Final phase in which the layout system places the rects of the elements
|
|
|
};
|
|
|
Q_ENUMS(UpdatePhase)
|
|
|
|
|
|
explicit QCPLayoutElement(QCustomPlot *parentPlot=0);
|
|
|
virtual ~QCPLayoutElement();
|
|
|
|
|
|
// getters:
|
|
|
QCPLayout *layout() const { return mParentLayout; }
|
|
|
QRect rect() const { return mRect; }
|
|
|
QRect outerRect() const { return mOuterRect; }
|
|
|
QMargins margins() const { return mMargins; }
|
|
|
QMargins minimumMargins() const { return mMinimumMargins; }
|
|
|
QCP::MarginSides autoMargins() const { return mAutoMargins; }
|
|
|
QSize minimumSize() const { return mMinimumSize; }
|
|
|
QSize maximumSize() const { return mMaximumSize; }
|
|
|
QCPMarginGroup *marginGroup(QCP::MarginSide side) const { return mMarginGroups.value(side, (QCPMarginGroup*)0); }
|
|
|
QHash<QCP::MarginSide, QCPMarginGroup*> marginGroups() const { return mMarginGroups; }
|
|
|
|
|
|
// setters:
|
|
|
void setOuterRect(const QRect &rect);
|
|
|
void setMargins(const QMargins &margins);
|
|
|
void setMinimumMargins(const QMargins &margins);
|
|
|
void setAutoMargins(QCP::MarginSides sides);
|
|
|
void setMinimumSize(const QSize &size);
|
|
|
void setMinimumSize(int width, int height);
|
|
|
void setMaximumSize(const QSize &size);
|
|
|
void setMaximumSize(int width, int height);
|
|
|
void setMarginGroup(QCP::MarginSides sides, QCPMarginGroup *group);
|
|
|
|
|
|
// introduced virtual methods:
|
|
|
virtual void update(UpdatePhase phase);
|
|
|
virtual QSize minimumSizeHint() const;
|
|
|
virtual QSize maximumSizeHint() const;
|
|
|
virtual QList<QCPLayoutElement*> elements(bool recursive) const;
|
|
|
|
|
|
// reimplemented virtual methods:
|
|
|
virtual double selectTest(const QPointF &pos, bool onlySelectable, QVariant *details=0) const;
|
|
|
|
|
|
protected:
|
|
|
// property members:
|
|
|
QCPLayout *mParentLayout;
|
|
|
QSize mMinimumSize, mMaximumSize;
|
|
|
QRect mRect, mOuterRect;
|
|
|
QMargins mMargins, mMinimumMargins;
|
|
|
QCP::MarginSides mAutoMargins;
|
|
|
QHash<QCP::MarginSide, QCPMarginGroup*> mMarginGroups;
|
|
|
|
|
|
// introduced virtual methods:
|
|
|
virtual int calculateAutoMargin(QCP::MarginSide side);
|
|
|
// events:
|
|
|
virtual void mousePressEvent(QMouseEvent *event) {Q_UNUSED(event)}
|
|
|
virtual void mouseMoveEvent(QMouseEvent *event) {Q_UNUSED(event)}
|
|
|
virtual void mouseReleaseEvent(QMouseEvent *event) {Q_UNUSED(event)}
|
|
|
virtual void mouseDoubleClickEvent(QMouseEvent *event) {Q_UNUSED(event)}
|
|
|
virtual void wheelEvent(QWheelEvent *event) {Q_UNUSED(event)}
|
|
|
|
|
|
// reimplemented virtual methods:
|
|
|
virtual void applyDefaultAntialiasingHint(QCPPainter *painter) const { Q_UNUSED(painter) }
|
|
|
virtual void draw(QCPPainter *painter) { Q_UNUSED(painter) }
|
|
|
virtual void parentPlotInitialized(QCustomPlot *parentPlot);
|
|
|
|
|
|
private:
|
|
|
Q_DISABLE_COPY(QCPLayoutElement)
|
|
|
|
|
|
friend class QCustomPlot;
|
|
|
friend class QCPLayout;
|
|
|
friend class QCPMarginGroup;
|
|
|
};
|
|
|
|
|
|
|
|
|
class QCP_LIB_DECL QCPLayout : public QCPLayoutElement
|
|
|
{
|
|
|
Q_OBJECT
|
|
|
public:
|
|
|
explicit QCPLayout();
|
|
|
|
|
|
// reimplemented virtual methods:
|
|
|
virtual void update(UpdatePhase phase);
|
|
|
virtual QList<QCPLayoutElement*> elements(bool recursive) const;
|
|
|
|
|
|
// introduced virtual methods:
|
|
|
virtual int elementCount() const = 0;
|
|
|
virtual QCPLayoutElement* elementAt(int index) const = 0;
|
|
|
virtual QCPLayoutElement* takeAt(int index) = 0;
|
|
|
virtual bool take(QCPLayoutElement* element) = 0;
|
|
|
virtual void simplify();
|
|
|
|
|
|
// non-virtual methods:
|
|
|
bool removeAt(int index);
|
|
|
bool remove(QCPLayoutElement* element);
|
|
|
void clear();
|
|
|
|
|
|
protected:
|
|
|
// introduced virtual methods:
|
|
|
virtual void updateLayout();
|
|
|
|
|
|
// non-virtual methods:
|
|
|
void sizeConstraintsChanged() const;
|
|
|
void adoptElement(QCPLayoutElement *el);
|
|
|
void releaseElement(QCPLayoutElement *el);
|
|
|
QVector<int> getSectionSizes(QVector<int> maxSizes, QVector<int> minSizes, QVector<double> stretchFactors, int totalSize) const;
|
|
|
|
|
|
private:
|
|
|
Q_DISABLE_COPY(QCPLayout)
|
|
|
friend class QCPLayoutElement;
|
|
|
};
|
|
|
|
|
|
|
|
|
class QCP_LIB_DECL QCPLayoutGrid : public QCPLayout
|
|
|
{
|
|
|
Q_OBJECT
|
|
|
/// \cond INCLUDE_QPROPERTIES
|
|
|
Q_PROPERTY(int rowCount READ rowCount)
|
|
|
Q_PROPERTY(int columnCount READ columnCount)
|
|
|
Q_PROPERTY(QList<double> columnStretchFactors READ columnStretchFactors WRITE setColumnStretchFactors)
|
|
|
Q_PROPERTY(QList<double> rowStretchFactors READ rowStretchFactors WRITE setRowStretchFactors)
|
|
|
Q_PROPERTY(int columnSpacing READ columnSpacing WRITE setColumnSpacing)
|
|
|
Q_PROPERTY(int rowSpacing READ rowSpacing WRITE setRowSpacing)
|
|
|
/// \endcond
|
|
|
public:
|
|
|
explicit QCPLayoutGrid();
|
|
|
virtual ~QCPLayoutGrid();
|
|
|
|
|
|
// getters:
|
|
|
int rowCount() const;
|
|
|
int columnCount() const;
|
|
|
QList<double> columnStretchFactors() const { return mColumnStretchFactors; }
|
|
|
QList<double> rowStretchFactors() const { return mRowStretchFactors; }
|
|
|
int columnSpacing() const { return mColumnSpacing; }
|
|
|
int rowSpacing() const { return mRowSpacing; }
|
|
|
|
|
|
// setters:
|
|
|
void setColumnStretchFactor(int column, double factor);
|
|
|
void setColumnStretchFactors(const QList<double> &factors);
|
|
|
void setRowStretchFactor(int row, double factor);
|
|
|
void setRowStretchFactors(const QList<double> &factors);
|
|
|
void setColumnSpacing(int pixels);
|
|
|
void setRowSpacing(int pixels);
|
|
|
|
|
|
// reimplemented virtual methods:
|
|
|
virtual void updateLayout();
|
|
|
virtual int elementCount() const;
|
|
|
virtual QCPLayoutElement* elementAt(int index) const;
|
|
|
virtual QCPLayoutElement* takeAt(int index);
|
|
|
virtual bool take(QCPLayoutElement* element);
|
|
|
virtual QList<QCPLayoutElement*> elements(bool recursive) const;
|
|
|
virtual void simplify();
|
|
|
virtual QSize minimumSizeHint() const;
|
|
|
virtual QSize maximumSizeHint() const;
|
|
|
|
|
|
// non-virtual methods:
|
|
|
QCPLayoutElement *element(int row, int column) const;
|
|
|
bool addElement(int row, int column, QCPLayoutElement *element);
|
|
|
bool hasElement(int row, int column);
|
|
|
void expandTo(int newRowCount, int newColumnCount);
|
|
|
void insertRow(int newIndex);
|
|
|
void insertColumn(int newIndex);
|
|
|
|
|
|
protected:
|
|
|
// property members:
|
|
|
QList<QList<QCPLayoutElement*> > mElements;
|
|
|
QList<double> mColumnStretchFactors;
|
|
|
QList<double> mRowStretchFactors;
|
|
|
int mColumnSpacing, mRowSpacing;
|
|
|
|
|
|
// non-virtual methods:
|
|
|
void getMinimumRowColSizes(QVector<int> *minColWidths, QVector<int> *minRowHeights) const;
|
|
|
void getMaximumRowColSizes(QVector<int> *maxColWidths, QVector<int> *maxRowHeights) const;
|
|
|
|
|
|
private:
|
|
|
Q_DISABLE_COPY(QCPLayoutGrid)
|
|
|
};
|
|
|
|
|
|
|
|
|
class QCP_LIB_DECL QCPLayoutInset : public QCPLayout
|
|
|
{
|
|
|
Q_OBJECT
|
|
|
public:
|
|
|
/*!
|
|
|
Defines how the placement and sizing is handled for a certain element in a QCPLayoutInset.
|
|
|
*/
|
|
|
enum InsetPlacement { ipFree ///< The element may be positioned/sized arbitrarily, see \ref setInsetRect
|
|
|
,ipBorderAligned ///< The element is aligned to one of the layout sides, see \ref setInsetAlignment
|
|
|
};
|
|
|
|
|
|
explicit QCPLayoutInset();
|
|
|
virtual ~QCPLayoutInset();
|
|
|
|
|
|
// getters:
|
|
|
InsetPlacement insetPlacement(int index) const;
|
|
|
Qt::Alignment insetAlignment(int index) const;
|
|
|
QRectF insetRect(int index) const;
|
|
|
|
|
|
// setters:
|
|
|
void setInsetPlacement(int index, InsetPlacement placement);
|
|
|
void setInsetAlignment(int index, Qt::Alignment alignment);
|
|
|
void setInsetRect(int index, const QRectF &rect);
|
|
|
|
|
|
// reimplemented virtual methods:
|
|
|
virtual void updateLayout();
|
|
|
virtual int elementCount() const;
|
|
|
virtual QCPLayoutElement* elementAt(int index) const;
|
|
|
virtual QCPLayoutElement* takeAt(int index);
|
|
|
virtual bool take(QCPLayoutElement* element);
|
|
|
virtual void simplify() {}
|
|
|
virtual double selectTest(const QPointF &pos, bool onlySelectable, QVariant *details=0) const;
|
|
|
|
|
|
// non-virtual methods:
|
|
|
void addElement(QCPLayoutElement *element, Qt::Alignment alignment);
|
|
|
void addElement(QCPLayoutElement *element, const QRectF &rect);
|
|
|
|
|
|
protected:
|
|
|
// property members:
|
|
|
QList<QCPLayoutElement*> mElements;
|
|
|
QList<InsetPlacement> mInsetPlacement;
|
|
|
QList<Qt::Alignment> mInsetAlignment;
|
|
|
QList<QRectF> mInsetRect;
|
|
|
|
|
|
private:
|
|
|
Q_DISABLE_COPY(QCPLayoutInset)
|
|
|
};
|
|
|
|
|
|
|
|
|
class QCP_LIB_DECL QCPLineEnding
|
|
|
{
|
|
|
Q_GADGET
|
|
|
public:
|
|
|
/*!
|
|
|
Defines the type of ending decoration for line-like items, e.g. an arrow.
|
|
|
|
|
|
\image html QCPLineEnding.png
|
|
|
|
|
|
The width and length of these decorations can be controlled with the functions \ref setWidth
|
|
|
and \ref setLength. Some decorations like \ref esDisc, \ref esSquare, \ref esDiamond and \ref esBar only
|
|
|
support a width, the length property is ignored.
|
|
|
|
|
|
\see QCPItemLine::setHead, QCPItemLine::setTail, QCPItemCurve::setHead, QCPItemCurve::setTail, QCPAxis::setLowerEnding, QCPAxis::setUpperEnding
|
|
|
*/
|
|
|
Q_ENUMS(EndingStyle)
|
|
|
enum EndingStyle { esNone ///< No ending decoration
|
|
|
,esFlatArrow ///< A filled arrow head with a straight/flat back (a triangle)
|
|
|
,esSpikeArrow ///< A filled arrow head with an indented back
|
|
|
,esLineArrow ///< A non-filled arrow head with open back
|
|
|
,esDisc ///< A filled circle
|
|
|
,esSquare ///< A filled square
|
|
|
,esDiamond ///< A filled diamond (45° rotated square)
|
|
|
,esBar ///< A bar perpendicular to the line
|
|
|
,esHalfBar ///< A bar perpendicular to the line, pointing out to only one side (to which side can be changed with \ref setInverted)
|
|
|
,esSkewedBar ///< A bar that is skewed (skew controllable via \ref setLength)
|
|
|
};
|
|
|
|
|
|
QCPLineEnding();
|
|
|
QCPLineEnding(EndingStyle style, double width=8, double length=10, bool inverted=false);
|
|
|
|
|
|
// getters:
|
|
|
EndingStyle style() const { return mStyle; }
|
|
|
double width() const { return mWidth; }
|
|
|
double length() const { return mLength; }
|
|
|
bool inverted() const { return mInverted; }
|
|
|
|
|
|
// setters:
|
|
|
void setStyle(EndingStyle style);
|
|
|
void setWidth(double width);
|
|
|
void setLength(double length);
|
|
|
void setInverted(bool inverted);
|
|
|
|
|
|
// non-property methods:
|
|
|
double boundingDistance() const;
|
|
|
double realLength() const;
|
|
|
void draw(QCPPainter *painter, const QVector2D &pos, const QVector2D &dir) const;
|
|
|
void draw(QCPPainter *painter, const QVector2D &pos, double angle) const;
|
|
|
|
|
|
protected:
|
|
|
// property members:
|
|
|
EndingStyle mStyle;
|
|
|
double mWidth, mLength;
|
|
|
bool mInverted;
|
|
|
};
|
|
|
Q_DECLARE_TYPEINFO(QCPLineEnding, Q_MOVABLE_TYPE);
|
|
|
|
|
|
|
|
|
class QCP_LIB_DECL QCPGrid :public QCPLayerable
|
|
|
{
|
|
|
Q_OBJECT
|
|
|
/// \cond INCLUDE_QPROPERTIES
|
|
|
Q_PROPERTY(bool subGridVisible READ subGridVisible WRITE setSubGridVisible)
|
|
|
Q_PROPERTY(bool antialiasedSubGrid READ antialiasedSubGrid WRITE setAntialiasedSubGrid)
|
|
|
Q_PROPERTY(bool antialiasedZeroLine READ antialiasedZeroLine WRITE setAntialiasedZeroLine)
|
|
|
Q_PROPERTY(QPen pen READ pen WRITE setPen)
|
|
|
Q_PROPERTY(QPen subGridPen READ subGridPen WRITE setSubGridPen)
|
|
|
Q_PROPERTY(QPen zeroLinePen READ zeroLinePen WRITE setZeroLinePen)
|
|
|
/// \endcond
|
|
|
public:
|
|
|
QCPGrid(QCPAxis *parentAxis);
|
|
|
|
|
|
// getters:
|
|
|
bool subGridVisible() const { return mSubGridVisible; }
|
|
|
bool antialiasedSubGrid() const { return mAntialiasedSubGrid; }
|
|
|
bool antialiasedZeroLine() const { return mAntialiasedZeroLine; }
|
|
|
QPen pen() const { return mPen; }
|
|
|
QPen subGridPen() const { return mSubGridPen; }
|
|
|
QPen zeroLinePen() const { return mZeroLinePen; }
|
|
|
|
|
|
// setters:
|
|
|
void setSubGridVisible(bool visible);
|
|
|
void setAntialiasedSubGrid(bool enabled);
|
|
|
void setAntialiasedZeroLine(bool enabled);
|
|
|
void setPen(const QPen &pen);
|
|
|
void setSubGridPen(const QPen &pen);
|
|
|
void setZeroLinePen(const QPen &pen);
|
|
|
|
|
|
protected:
|
|
|
// property members:
|
|
|
bool mSubGridVisible;
|
|
|
bool mAntialiasedSubGrid, mAntialiasedZeroLine;
|
|
|
QPen mPen, mSubGridPen, mZeroLinePen;
|
|
|
// non-property members:
|
|
|
QCPAxis *mParentAxis;
|
|
|
|
|
|
// reimplemented virtual methods:
|
|
|
virtual void applyDefaultAntialiasingHint(QCPPainter *painter) const;
|
|
|
virtual void draw(QCPPainter *painter);
|
|
|
|
|
|
// non-virtual methods:
|
|
|
void drawGridLines(QCPPainter *painter) const;
|
|
|
void drawSubGridLines(QCPPainter *painter) const;
|
|
|
|
|
|
friend class QCPAxis;
|
|
|
};
|
|
|
|
|
|
|
|
|
class QCP_LIB_DECL QCPAxis : public QCPLayerable
|
|
|
{
|
|
|
Q_OBJECT
|
|
|
/// \cond INCLUDE_QPROPERTIES
|
|
|
Q_PROPERTY(AxisType axisType READ axisType)
|
|
|
Q_PROPERTY(QCPAxisRect* axisRect READ axisRect)
|
|
|
Q_PROPERTY(ScaleType scaleType READ scaleType WRITE setScaleType NOTIFY scaleTypeChanged)
|
|
|
Q_PROPERTY(double scaleLogBase READ scaleLogBase WRITE setScaleLogBase)
|
|
|
Q_PROPERTY(QCPRange range READ range WRITE setRange NOTIFY rangeChanged)
|
|
|
Q_PROPERTY(bool rangeReversed READ rangeReversed WRITE setRangeReversed)
|
|
|
Q_PROPERTY(bool autoTicks READ autoTicks WRITE setAutoTicks)
|
|
|
Q_PROPERTY(int autoTickCount READ autoTickCount WRITE setAutoTickCount)
|
|
|
Q_PROPERTY(bool autoTickLabels READ autoTickLabels WRITE setAutoTickLabels)
|
|
|
Q_PROPERTY(bool autoTickStep READ autoTickStep WRITE setAutoTickStep)
|
|
|
Q_PROPERTY(bool autoSubTicks READ autoSubTicks WRITE setAutoSubTicks)
|
|
|
Q_PROPERTY(bool ticks READ ticks WRITE setTicks)
|
|
|
Q_PROPERTY(bool tickLabels READ tickLabels WRITE setTickLabels)
|
|
|
Q_PROPERTY(int tickLabelPadding READ tickLabelPadding WRITE setTickLabelPadding)
|
|
|
Q_PROPERTY(LabelType tickLabelType READ tickLabelType WRITE setTickLabelType)
|
|
|
Q_PROPERTY(QFont tickLabelFont READ tickLabelFont WRITE setTickLabelFont)
|
|
|
Q_PROPERTY(QColor tickLabelColor READ tickLabelColor WRITE setTickLabelColor)
|
|
|
Q_PROPERTY(double tickLabelRotation READ tickLabelRotation WRITE setTickLabelRotation)
|
|
|
Q_PROPERTY(QString dateTimeFormat READ dateTimeFormat WRITE setDateTimeFormat)
|
|
|
Q_PROPERTY(Qt::TimeSpec dateTimeSpec READ dateTimeSpec WRITE setDateTimeSpec)
|
|
|
Q_PROPERTY(QString numberFormat READ numberFormat WRITE setNumberFormat)
|
|
|
Q_PROPERTY(int numberPrecision READ numberPrecision WRITE setNumberPrecision)
|
|
|
Q_PROPERTY(double tickStep READ tickStep WRITE setTickStep)
|
|
|
Q_PROPERTY(QVector<double> tickVector READ tickVector WRITE setTickVector)
|
|
|
Q_PROPERTY(QVector<QString> tickVectorLabels READ tickVectorLabels WRITE setTickVectorLabels)
|
|
|
Q_PROPERTY(int tickLengthIn READ tickLengthIn WRITE setTickLengthIn)
|
|
|
Q_PROPERTY(int tickLengthOut READ tickLengthOut WRITE setTickLengthOut)
|
|
|
Q_PROPERTY(int subTickCount READ subTickCount WRITE setSubTickCount)
|
|
|
Q_PROPERTY(int subTickLengthIn READ subTickLengthIn WRITE setSubTickLengthIn)
|
|
|
Q_PROPERTY(int subTickLengthOut READ subTickLengthOut WRITE setSubTickLengthOut)
|
|
|
Q_PROPERTY(QPen basePen READ basePen WRITE setBasePen)
|
|
|
Q_PROPERTY(QPen tickPen READ tickPen WRITE setTickPen)
|
|
|
Q_PROPERTY(QPen subTickPen READ subTickPen WRITE setSubTickPen)
|
|
|
Q_PROPERTY(QFont labelFont READ labelFont WRITE setLabelFont)
|
|
|
Q_PROPERTY(QColor labelColor READ labelColor WRITE setLabelColor)
|
|
|
Q_PROPERTY(QString label READ label WRITE setLabel)
|
|
|
Q_PROPERTY(int labelPadding READ labelPadding WRITE setLabelPadding)
|
|
|
Q_PROPERTY(int padding READ padding WRITE setPadding)
|
|
|
Q_PROPERTY(int offset READ offset WRITE setOffset)
|
|
|
Q_PROPERTY(SelectableParts selectedParts READ selectedParts WRITE setSelectedParts NOTIFY selectionChanged)
|
|
|
Q_PROPERTY(SelectableParts selectableParts READ selectableParts WRITE setSelectableParts NOTIFY selectableChanged)
|
|
|
Q_PROPERTY(QFont selectedTickLabelFont READ selectedTickLabelFont WRITE setSelectedTickLabelFont)
|
|
|
Q_PROPERTY(QFont selectedLabelFont READ selectedLabelFont WRITE setSelectedLabelFont)
|
|
|
Q_PROPERTY(QColor selectedTickLabelColor READ selectedTickLabelColor WRITE setSelectedTickLabelColor)
|
|
|
Q_PROPERTY(QColor selectedLabelColor READ selectedLabelColor WRITE setSelectedLabelColor)
|
|
|
Q_PROPERTY(QPen selectedBasePen READ selectedBasePen WRITE setSelectedBasePen)
|
|
|
Q_PROPERTY(QPen selectedTickPen READ selectedTickPen WRITE setSelectedTickPen)
|
|
|
Q_PROPERTY(QPen selectedSubTickPen READ selectedSubTickPen WRITE setSelectedSubTickPen)
|
|
|
Q_PROPERTY(QCPLineEnding lowerEnding READ lowerEnding WRITE setLowerEnding)
|
|
|
Q_PROPERTY(QCPLineEnding upperEnding READ upperEnding WRITE setUpperEnding)
|
|
|
Q_PROPERTY(QCPGrid* grid READ grid)
|
|
|
/// \endcond
|
|
|
public:
|
|
|
/*!
|
|
|
Defines at which side of the axis rect the axis will appear. This also affects how the tick
|
|
|
marks are drawn, on which side the labels are placed etc.
|
|
|
*/
|
|
|
enum AxisType { atLeft = 0x01 ///< <tt>0x01</tt> Axis is vertical and on the left side of the axis rect
|
|
|
,atRight = 0x02 ///< <tt>0x02</tt> Axis is vertical and on the right side of the axis rect
|
|
|
,atTop = 0x04 ///< <tt>0x04</tt> Axis is horizontal and on the top side of the axis rect
|
|
|
,atBottom = 0x08 ///< <tt>0x08</tt> Axis is horizontal and on the bottom side of the axis rect
|
|
|
};
|
|
|
Q_FLAGS(AxisType AxisTypes)
|
|
|
Q_DECLARE_FLAGS(AxisTypes, AxisType)
|
|
|
/*!
|
|
|
When automatic tick label generation is enabled (\ref setAutoTickLabels), defines how the
|
|
|
coordinate of the tick is interpreted, i.e. translated into a string.
|
|
|
|
|
|
\see setTickLabelType
|
|
|
*/
|
|
|
enum LabelType { ltNumber ///< Tick coordinate is regarded as normal number and will be displayed as such. (see \ref setNumberFormat)
|
|
|
,ltDateTime ///< Tick coordinate is regarded as a date/time (seconds since 1970-01-01T00:00:00 UTC) and will be displayed and formatted as such. (for details, see \ref setDateTimeFormat)
|
|
|
};
|
|
|
Q_ENUMS(LabelType)
|
|
|
/*!
|
|
|
Defines the scale of an axis.
|
|
|
\see setScaleType
|
|
|
*/
|
|
|
enum ScaleType { stLinear ///< Linear scaling
|
|
|
,stLogarithmic ///< Logarithmic scaling with correspondingly transformed plots and (major) tick marks at every base power (see \ref setScaleLogBase).
|
|
|
};
|
|
|
Q_ENUMS(ScaleType)
|
|
|
/*!
|
|
|
Defines the selectable parts of an axis.
|
|
|
\see setSelectableParts, setSelectedParts
|
|
|
*/
|
|
|
enum SelectablePart { spNone = 0 ///< None of the selectable parts
|
|
|
,spAxis = 0x001 ///< The axis backbone and tick marks
|
|
|
,spTickLabels = 0x002 ///< Tick labels (numbers) of this axis (as a whole, not individually)
|
|
|
,spAxisLabel = 0x004 ///< The axis label
|
|
|
};
|
|
|
Q_FLAGS(SelectablePart SelectableParts)
|
|
|
Q_DECLARE_FLAGS(SelectableParts, SelectablePart)
|
|
|
|
|
|
explicit QCPAxis(QCPAxisRect *parent, AxisType type);
|
|
|
virtual ~QCPAxis();
|
|
|
|
|
|
// getters:
|
|
|
AxisType axisType() const { return mAxisType; }
|
|
|
QCPAxisRect *axisRect() const { return mAxisRect; }
|
|
|
ScaleType scaleType() const { return mScaleType; }
|
|
|
double scaleLogBase() const { return mScaleLogBase; }
|
|
|
const QCPRange range() const { return mRange; }
|
|
|
bool rangeReversed() const { return mRangeReversed; }
|
|
|
bool autoTicks() const { return mAutoTicks; }
|
|
|
int autoTickCount() const { return mAutoTickCount; }
|
|
|
bool autoTickLabels() const { return mAutoTickLabels; }
|
|
|
bool autoTickStep() const { return mAutoTickStep; }
|
|
|
bool autoSubTicks() const { return mAutoSubTicks; }
|
|
|
bool ticks() const { return mTicks; }
|
|
|
bool tickLabels() const { return mTickLabels; }
|
|
|
int tickLabelPadding() const;
|
|
|
LabelType tickLabelType() const { return mTickLabelType; }
|
|
|
QFont tickLabelFont() const { return mTickLabelFont; }
|
|
|
QColor tickLabelColor() const { return mTickLabelColor; }
|
|
|
double tickLabelRotation() const;
|
|
|
QString dateTimeFormat() const { return mDateTimeFormat; }
|
|
|
Qt::TimeSpec dateTimeSpec() const { return mDateTimeSpec; }
|
|
|
QString numberFormat() const;
|
|
|
int numberPrecision() const { return mNumberPrecision; }
|
|
|
double tickStep() const { return mTickStep; }
|
|
|
QVector<double> tickVector() const { return mTickVector; }
|
|
|
QVector<QString> tickVectorLabels() const { return mTickVectorLabels; }
|
|
|
int tickLengthIn() const;
|
|
|
int tickLengthOut() const;
|
|
|
int subTickCount() const { return mSubTickCount; }
|
|
|
int subTickLengthIn() const;
|
|
|
int subTickLengthOut() const;
|
|
|
QPen basePen() const { return mBasePen; }
|
|
|
QPen tickPen() const { return mTickPen; }
|
|
|
QPen subTickPen() const { return mSubTickPen; }
|
|
|
QFont labelFont() const { return mLabelFont; }
|
|
|
QColor labelColor() const { return mLabelColor; }
|
|
|
QString label() const { return mLabel; }
|
|
|
int labelPadding() const;
|
|
|
int padding() const { return mPadding; }
|
|
|
int offset() const;
|
|
|
SelectableParts selectedParts() const { return mSelectedParts; }
|
|
|
SelectableParts selectableParts() const { return mSelectableParts; }
|
|
|
QFont selectedTickLabelFont() const { return mSelectedTickLabelFont; }
|
|
|
QFont selectedLabelFont() const { return mSelectedLabelFont; }
|
|
|
QColor selectedTickLabelColor() const { return mSelectedTickLabelColor; }
|
|
|
QColor selectedLabelColor() const { return mSelectedLabelColor; }
|
|
|
QPen selectedBasePen() const { return mSelectedBasePen; }
|
|
|
QPen selectedTickPen() const { return mSelectedTickPen; }
|
|
|
QPen selectedSubTickPen() const { return mSelectedSubTickPen; }
|
|
|
QCPLineEnding lowerEnding() const;
|
|
|
QCPLineEnding upperEnding() const;
|
|
|
QCPGrid *grid() const { return mGrid; }
|
|
|
|
|
|
// setters:
|
|
|
Q_SLOT void setScaleType(QCPAxis::ScaleType type);
|
|
|
void setScaleLogBase(double base);
|
|
|
Q_SLOT void setRange(const QCPRange &range);
|
|
|
void setRange(double lower, double upper);
|
|
|
void setRange(double position, double size, Qt::AlignmentFlag alignment);
|
|
|
void setRangeLower(double lower);
|
|
|
void setRangeUpper(double upper);
|
|
|
void setRangeReversed(bool reversed);
|
|
|
void setAutoTicks(bool on);
|
|
|
void setAutoTickCount(int approximateCount);
|
|
|
void setAutoTickLabels(bool on);
|
|
|
void setAutoTickStep(bool on);
|
|
|
void setAutoSubTicks(bool on);
|
|
|
void setTicks(bool show);
|
|
|
void setTickLabels(bool show);
|
|
|
void setTickLabelPadding(int padding);
|
|
|
void setTickLabelType(LabelType type);
|
|
|
void setTickLabelFont(const QFont &font);
|
|
|
void setTickLabelColor(const QColor &color);
|
|
|
void setTickLabelRotation(double degrees);
|
|
|
void setDateTimeFormat(const QString &format);
|
|
|
void setDateTimeSpec(const Qt::TimeSpec &timeSpec);
|
|
|
void setNumberFormat(const QString &formatCode);
|
|
|
void setNumberPrecision(int precision);
|
|
|
void setTickStep(double step);
|
|
|
void setTickVector(const QVector<double> &vec);
|
|
|
void setTickVectorLabels(const QVector<QString> &vec);
|
|
|
void setTickLength(int inside, int outside=0);
|
|
|
void setTickLengthIn(int inside);
|
|
|
void setTickLengthOut(int outside);
|
|
|
void setSubTickCount(int count);
|
|
|
void setSubTickLength(int inside, int outside=0);
|
|
|
void setSubTickLengthIn(int inside);
|
|
|
void setSubTickLengthOut(int outside);
|
|
|
void setBasePen(const QPen &pen);
|
|
|
void setTickPen(const QPen &pen);
|
|
|
void setSubTickPen(const QPen &pen);
|
|
|
void setLabelFont(const QFont &font);
|
|
|
void setLabelColor(const QColor &color);
|
|
|
void setLabel(const QString &str);
|
|
|
void setLabelPadding(int padding);
|
|
|
void setPadding(int padding);
|
|
|
void setOffset(int offset);
|
|
|
void setSelectedTickLabelFont(const QFont &font);
|
|
|
void setSelectedLabelFont(const QFont &font);
|
|
|
void setSelectedTickLabelColor(const QColor &color);
|
|
|
void setSelectedLabelColor(const QColor &color);
|
|
|
void setSelectedBasePen(const QPen &pen);
|
|
|
void setSelectedTickPen(const QPen &pen);
|
|
|
void setSelectedSubTickPen(const QPen &pen);
|
|
|
Q_SLOT void setSelectableParts(const QCPAxis::SelectableParts &selectableParts);
|
|
|
Q_SLOT void setSelectedParts(const QCPAxis::SelectableParts &selectedParts);
|
|
|
void setLowerEnding(const QCPLineEnding &ending);
|
|
|
void setUpperEnding(const QCPLineEnding &ending);
|
|
|
|
|
|
// reimplemented virtual methods:
|
|
|
virtual double selectTest(const QPointF &pos, bool onlySelectable, QVariant *details=0) const;
|
|
|
|
|
|
// non-property methods:
|
|
|
Qt::Orientation orientation() const { return mOrientation; }
|
|
|
void moveRange(double diff);
|
|
|
void scaleRange(double factor, double center);
|
|
|
void setScaleRatio(const QCPAxis *otherAxis, double ratio=1.0);
|
|
|
void rescale(bool onlyVisiblePlottables=false);
|
|
|
double pixelToCoord(double value) const;
|
|
|
double coordToPixel(double value) const;
|
|
|
SelectablePart getPartAt(const QPointF &pos) const;
|
|
|
QList<QCPAbstractPlottable*> plottables() const;
|
|
|
QList<QCPGraph*> graphs() const;
|
|
|
QList<QCPAbstractItem*> items() const;
|
|
|
|
|
|
static AxisType marginSideToAxisType(QCP::MarginSide side);
|
|
|
static Qt::Orientation orientation(AxisType type) { return type==atBottom||type==atTop ? Qt::Horizontal : Qt::Vertical; }
|
|
|
static AxisType opposite(AxisType type);
|
|
|
|
|
|
signals:
|
|
|
void ticksRequest();
|
|
|
void rangeChanged(const QCPRange &newRange);
|
|
|
void rangeChanged(const QCPRange &newRange, const QCPRange &oldRange);
|
|
|
void scaleTypeChanged(QCPAxis::ScaleType scaleType);
|
|
|
void selectionChanged(const QCPAxis::SelectableParts &parts);
|
|
|
void selectableChanged(const QCPAxis::SelectableParts &parts);
|
|
|
|
|
|
protected:
|
|
|
// property members:
|
|
|
// axis base:
|
|
|
AxisType mAxisType;
|
|
|
QCPAxisRect *mAxisRect;
|
|
|
//int mOffset; // in QCPAxisPainter
|
|
|
int mPadding;
|
|
|
Qt::Orientation mOrientation;
|
|
|
SelectableParts mSelectableParts, mSelectedParts;
|
|
|
QPen mBasePen, mSelectedBasePen;
|
|
|
//QCPLineEnding mLowerEnding, mUpperEnding; // in QCPAxisPainter
|
|
|
// axis label:
|
|
|
//int mLabelPadding; // in QCPAxisPainter
|
|
|
QString mLabel;
|
|
|
QFont mLabelFont, mSelectedLabelFont;
|
|
|
QColor mLabelColor, mSelectedLabelColor;
|
|
|
// tick labels:
|
|
|
//int mTickLabelPadding; // in QCPAxisPainter
|
|
|
bool mTickLabels, mAutoTickLabels;
|
|
|
//double mTickLabelRotation; // in QCPAxisPainter
|
|
|
LabelType mTickLabelType;
|
|
|
QFont mTickLabelFont, mSelectedTickLabelFont;
|
|
|
QColor mTickLabelColor, mSelectedTickLabelColor;
|
|
|
QString mDateTimeFormat;
|
|
|
Qt::TimeSpec mDateTimeSpec;
|
|
|
int mNumberPrecision;
|
|
|
char mNumberFormatChar;
|
|
|
bool mNumberBeautifulPowers;
|
|
|
//bool mNumberMultiplyCross; // QCPAxisPainter
|
|
|
// ticks and subticks:
|
|
|
bool mTicks;
|
|
|
double mTickStep;
|
|
|
int mSubTickCount, mAutoTickCount;
|
|
|
bool mAutoTicks, mAutoTickStep, mAutoSubTicks;
|
|
|
//int mTickLengthIn, mTickLengthOut, mSubTickLengthIn, mSubTickLengthOut; // QCPAxisPainter
|
|
|
QPen mTickPen, mSelectedTickPen;
|
|
|
QPen mSubTickPen, mSelectedSubTickPen;
|
|
|
// scale and range:
|
|
|
QCPRange mRange;
|
|
|
bool mRangeReversed;
|
|
|
ScaleType mScaleType;
|
|
|
double mScaleLogBase, mScaleLogBaseLogInv;
|
|
|
|
|
|
// non-property members:
|
|
|
QCPGrid *mGrid;
|
|
|
QCPAxisPainterPrivate *mAxisPainter;
|
|
|
int mLowestVisibleTick, mHighestVisibleTick;
|
|
|
QVector<double> mTickVector;
|
|
|
QVector<QString> mTickVectorLabels;
|
|
|
QVector<double> mSubTickVector;
|
|
|
bool mCachedMarginValid;
|
|
|
int mCachedMargin;
|
|
|
|
|
|
// introduced virtual methods:
|
|
|
virtual void setupTickVectors();
|
|
|
virtual void generateAutoTicks();
|
|
|
virtual int calculateAutoSubTickCount(double tickStep) const;
|
|
|
virtual int calculateMargin();
|
|
|
|
|
|
// reimplemented virtual methods:
|
|
|
virtual void applyDefaultAntialiasingHint(QCPPainter *painter) const;
|
|
|
virtual void draw(QCPPainter *painter);
|
|
|
virtual QCP::Interaction selectionCategory() const;
|
|
|
// events:
|
|
|
virtual void selectEvent(QMouseEvent *event, bool additive, const QVariant &details, bool *selectionStateChanged);
|
|
|
virtual void deselectEvent(bool *selectionStateChanged);
|
|
|
|
|
|
// non-virtual methods:
|
|
|
void visibleTickBounds(int &lowIndex, int &highIndex) const;
|
|
|
double baseLog(double value) const;
|
|
|
double basePow(double value) const;
|
|
|
QPen getBasePen() const;
|
|
|
QPen getTickPen() const;
|
|
|
QPen getSubTickPen() const;
|
|
|
QFont getTickLabelFont() const;
|
|
|
QFont getLabelFont() const;
|
|
|
QColor getTickLabelColor() const;
|
|
|
QColor getLabelColor() const;
|
|
|
|
|
|
private:
|
|
|
Q_DISABLE_COPY(QCPAxis)
|
|
|
|
|
|
friend class QCustomPlot;
|
|
|
friend class QCPGrid;
|
|
|
friend class QCPAxisRect;
|
|
|
};
|
|
|
Q_DECLARE_OPERATORS_FOR_FLAGS(QCPAxis::SelectableParts)
|
|
|
Q_DECLARE_OPERATORS_FOR_FLAGS(QCPAxis::AxisTypes)
|
|
|
Q_DECLARE_METATYPE(QCPAxis::SelectablePart)
|
|
|
|
|
|
|
|
|
class QCPAxisPainterPrivate
|
|
|
{
|
|
|
public:
|
|
|
explicit QCPAxisPainterPrivate(QCustomPlot *parentPlot);
|
|
|
virtual ~QCPAxisPainterPrivate();
|
|
|
|
|
|
virtual void draw(QCPPainter *painter);
|
|
|
virtual int size() const;
|
|
|
void clearCache();
|
|
|
|
|
|
QRect axisSelectionBox() const { return mAxisSelectionBox; }
|
|
|
QRect tickLabelsSelectionBox() const { return mTickLabelsSelectionBox; }
|
|
|
QRect labelSelectionBox() const { return mLabelSelectionBox; }
|
|
|
|
|
|
// public property members:
|
|
|
QCPAxis::AxisType type;
|
|
|
QPen basePen;
|
|
|
QCPLineEnding lowerEnding, upperEnding; // directly accessed by QCPAxis setters/getters
|
|
|
int labelPadding; // directly accessed by QCPAxis setters/getters
|
|
|
QFont labelFont;
|
|
|
QColor labelColor;
|
|
|
QString label;
|
|
|
int tickLabelPadding; // directly accessed by QCPAxis setters/getters
|
|
|
double tickLabelRotation; // directly accessed by QCPAxis setters/getters
|
|
|
bool substituteExponent;
|
|
|
bool numberMultiplyCross; // directly accessed by QCPAxis setters/getters
|
|
|
int tickLengthIn, tickLengthOut, subTickLengthIn, subTickLengthOut; // directly accessed by QCPAxis setters/getters
|
|
|
QPen tickPen, subTickPen;
|
|
|
QFont tickLabelFont;
|
|
|
QColor tickLabelColor;
|
|
|
QRect alignmentRect, viewportRect;
|
|
|
double offset; // directly accessed by QCPAxis setters/getters
|
|
|
bool abbreviateDecimalPowers;
|
|
|
bool reversedEndings;
|
|
|
|
|
|
QVector<double> subTickPositions;
|
|
|
QVector<double> tickPositions;
|
|
|
QVector<QString> tickLabels;
|
|
|
|
|
|
protected:
|
|
|
struct CachedLabel
|
|
|
{
|
|
|
QPointF offset;
|
|
|
QPixmap pixmap;
|
|
|
};
|
|
|
struct TickLabelData
|
|
|
{
|
|
|
QString basePart, expPart;
|
|
|
QRect baseBounds, expBounds, totalBounds, rotatedTotalBounds;
|
|
|
QFont baseFont, expFont;
|
|
|
};
|
|
|
QCustomPlot *mParentPlot;
|
|
|
QByteArray mLabelParameterHash; // to determine whether mLabelCache needs to be cleared due to changed parameters
|
|
|
QCache<QString, CachedLabel> mLabelCache;
|
|
|
QRect mAxisSelectionBox, mTickLabelsSelectionBox, mLabelSelectionBox;
|
|
|
|
|
|
virtual QByteArray generateLabelParameterHash() const;
|
|
|
|
|
|
virtual void placeTickLabel(QCPPainter *painter, double position, int distanceToAxis, const QString &text, QSize *tickLabelsSize);
|
|
|
virtual void drawTickLabel(QCPPainter *painter, double x, double y, const TickLabelData &labelData) const;
|
|
|
virtual TickLabelData getTickLabelData(const QFont &font, const QString &text) const;
|
|
|
virtual QPointF getTickLabelDrawOffset(const TickLabelData &labelData) const;
|
|
|
virtual void getMaxTickLabelSize(const QFont &font, const QString &text, QSize *tickLabelsSize) const;
|
|
|
};
|
|
|
|
|
|
|
|
|
class QCP_LIB_DECL QCPAbstractPlottable : public QCPLayerable
|
|
|
{
|
|
|
Q_OBJECT
|
|
|
/// \cond INCLUDE_QPROPERTIES
|
|
|
Q_PROPERTY(QString name READ name WRITE setName)
|
|
|
Q_PROPERTY(bool antialiasedFill READ antialiasedFill WRITE setAntialiasedFill)
|
|
|
Q_PROPERTY(bool antialiasedScatters READ antialiasedScatters WRITE setAntialiasedScatters)
|
|
|
Q_PROPERTY(bool antialiasedErrorBars READ antialiasedErrorBars WRITE setAntialiasedErrorBars)
|
|
|
Q_PROPERTY(QPen pen READ pen WRITE setPen)
|
|
|
Q_PROPERTY(QPen selectedPen READ selectedPen WRITE setSelectedPen)
|
|
|
Q_PROPERTY(QBrush brush READ brush WRITE setBrush)
|
|
|
Q_PROPERTY(QBrush selectedBrush READ selectedBrush WRITE setSelectedBrush)
|
|
|
Q_PROPERTY(QCPAxis* keyAxis READ keyAxis WRITE setKeyAxis)
|
|
|
Q_PROPERTY(QCPAxis* valueAxis READ valueAxis WRITE setValueAxis)
|
|
|
Q_PROPERTY(bool selectable READ selectable WRITE setSelectable NOTIFY selectableChanged)
|
|
|
Q_PROPERTY(bool selected READ selected WRITE setSelected NOTIFY selectionChanged)
|
|
|
/// \endcond
|
|
|
public:
|
|
|
QCPAbstractPlottable(QCPAxis *keyAxis, QCPAxis *valueAxis);
|
|
|
|
|
|
// getters:
|
|
|
QString name() const { return mName; }
|
|
|
bool antialiasedFill() const { return mAntialiasedFill; }
|
|
|
bool antialiasedScatters() const { return mAntialiasedScatters; }
|
|
|
bool antialiasedErrorBars() const { return mAntialiasedErrorBars; }
|
|
|
QPen pen() const { return mPen; }
|
|
|
QPen selectedPen() const { return mSelectedPen; }
|
|
|
QBrush brush() const { return mBrush; }
|
|
|
QBrush selectedBrush() const { return mSelectedBrush; }
|
|
|
QCPAxis *keyAxis() const { return mKeyAxis.data(); }
|
|
|
QCPAxis *valueAxis() const { return mValueAxis.data(); }
|
|
|
bool selectable() const { return mSelectable; }
|
|
|
bool selected() const { return mSelected; }
|
|
|
|
|
|
// setters:
|
|
|
void setName(const QString &name);
|
|
|
void setAntialiasedFill(bool enabled);
|
|
|
void setAntialiasedScatters(bool enabled);
|
|
|
void setAntialiasedErrorBars(bool enabled);
|
|
|
void setPen(const QPen &pen);
|
|
|
void setSelectedPen(const QPen &pen);
|
|
|
void setBrush(const QBrush &brush);
|
|
|
void setSelectedBrush(const QBrush &brush);
|
|
|
void setKeyAxis(QCPAxis *axis);
|
|
|
void setValueAxis(QCPAxis *axis);
|
|
|
Q_SLOT void setSelectable(bool selectable);
|
|
|
Q_SLOT void setSelected(bool selected);
|
|
|
|
|
|
// introduced virtual methods:
|
|
|
virtual void clearData() = 0;
|
|
|
virtual double selectTest(const QPointF &pos, bool onlySelectable, QVariant *details=0) const = 0;
|
|
|
virtual bool addToLegend();
|
|
|
virtual bool removeFromLegend() const;
|
|
|
|
|
|
// non-property methods:
|
|
|
void rescaleAxes(bool onlyEnlarge=false) const;
|
|
|
void rescaleKeyAxis(bool onlyEnlarge=false) const;
|
|
|
void rescaleValueAxis(bool onlyEnlarge=false) const;
|
|
|
|
|
|
signals:
|
|
|
void selectionChanged(bool selected);
|
|
|
void selectableChanged(bool selectable);
|
|
|
|
|
|
protected:
|
|
|
/*!
|
|
|
Represents negative and positive sign domain for passing to \ref getKeyRange and \ref getValueRange.
|
|
|
*/
|
|
|
enum SignDomain { sdNegative ///< The negative sign domain, i.e. numbers smaller than zero
|
|
|
,sdBoth ///< Both sign domains, including zero, i.e. all (rational) numbers
|
|
|
,sdPositive ///< The positive sign domain, i.e. numbers greater than zero
|
|
|
};
|
|
|
|
|
|
// property members:
|
|
|
QString mName;
|
|
|
bool mAntialiasedFill, mAntialiasedScatters, mAntialiasedErrorBars;
|
|
|
QPen mPen, mSelectedPen;
|
|
|
QBrush mBrush, mSelectedBrush;
|
|
|
QPointer<QCPAxis> mKeyAxis, mValueAxis;
|
|
|
bool mSelectable, mSelected;
|
|
|
|
|
|
// reimplemented virtual methods:
|
|
|
virtual QRect clipRect() const;
|
|
|
virtual void draw(QCPPainter *painter) = 0;
|
|
|
virtual QCP::Interaction selectionCategory() const;
|
|
|
void applyDefaultAntialiasingHint(QCPPainter *painter) const;
|
|
|
// events:
|
|
|
virtual void selectEvent(QMouseEvent *event, bool additive, const QVariant &details, bool *selectionStateChanged);
|
|
|
virtual void deselectEvent(bool *selectionStateChanged);
|
|
|
|
|
|
// introduced virtual methods:
|
|
|
virtual void drawLegendIcon(QCPPainter *painter, const QRectF &rect) const = 0;
|
|
|
virtual QCPRange getKeyRange(bool &foundRange, SignDomain inSignDomain=sdBoth) const = 0;
|
|
|
virtual QCPRange getValueRange(bool &foundRange, SignDomain inSignDomain=sdBoth) const = 0;
|
|
|
|
|
|
// non-virtual methods:
|
|
|
void coordsToPixels(double key, double value, double &x, double &y) const;
|
|
|
const QPointF coordsToPixels(double key, double value) const;
|
|
|
void pixelsToCoords(double x, double y, double &key, double &value) const;
|
|
|
void pixelsToCoords(const QPointF &pixelPos, double &key, double &value) const;
|
|
|
QPen mainPen() const;
|
|
|
QBrush mainBrush() const;
|
|
|
void applyFillAntialiasingHint(QCPPainter *painter) const;
|
|
|
void applyScattersAntialiasingHint(QCPPainter *painter) const;
|
|
|
void applyErrorBarsAntialiasingHint(QCPPainter *painter) const;
|
|
|
double distSqrToLine(const QPointF &start, const QPointF &end, const QPointF &point) const;
|
|
|
|
|
|
private:
|
|
|
Q_DISABLE_COPY(QCPAbstractPlottable)
|
|
|
|
|
|
friend class QCustomPlot;
|
|
|
friend class QCPAxis;
|
|
|
friend class QCPPlottableLegendItem;
|
|
|
};
|
|
|
|
|
|
|
|
|
class QCP_LIB_DECL QCPItemAnchor
|
|
|
{
|
|
|
public:
|
|
|
QCPItemAnchor(QCustomPlot *parentPlot, QCPAbstractItem *parentItem, const QString name, int anchorId=-1);
|
|
|
virtual ~QCPItemAnchor();
|
|
|
|
|
|
// getters:
|
|
|
QString name() const { return mName; }
|
|
|
virtual QPointF pixelPoint() const;
|
|
|
|
|
|
protected:
|
|
|
// property members:
|
|
|
QString mName;
|
|
|
|
|
|
// non-property members:
|
|
|
QCustomPlot *mParentPlot;
|
|
|
QCPAbstractItem *mParentItem;
|
|
|
int mAnchorId;
|
|
|
QSet<QCPItemPosition*> mChildren;
|
|
|
|
|
|
// introduced virtual methods:
|
|
|
virtual QCPItemPosition *toQCPItemPosition() { return 0; }
|
|
|
|
|
|
// non-virtual methods:
|
|
|
void addChild(QCPItemPosition* pos); // called from pos when this anchor is set as parent
|
|
|
void removeChild(QCPItemPosition *pos); // called from pos when its parent anchor is reset or pos deleted
|
|
|
|
|
|
private:
|
|
|
Q_DISABLE_COPY(QCPItemAnchor)
|
|
|
|
|
|
friend class QCPItemPosition;
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
class QCP_LIB_DECL QCPItemPosition : public QCPItemAnchor
|
|
|
{
|
|
|
public:
|
|
|
/*!
|
|
|
Defines the ways an item position can be specified. Thus it defines what the numbers passed to
|
|
|
\ref setCoords actually mean.
|
|
|
|
|
|
\see setType
|
|
|
*/
|
|
|
enum PositionType { ptAbsolute ///< Static positioning in pixels, starting from the top left corner of the viewport/widget.
|
|
|
,ptViewportRatio ///< Static positioning given by a fraction of the viewport size. For example, if you call setCoords(0, 0), the position will be at the top
|
|
|
///< left corner of the viewport/widget. setCoords(1, 1) will be at the bottom right corner, setCoords(0.5, 0) will be horizontally centered and
|
|
|
///< vertically at the top of the viewport/widget, etc.
|
|
|
,ptAxisRectRatio ///< Static positioning given by a fraction of the axis rect size (see \ref setAxisRect). For example, if you call setCoords(0, 0), the position will be at the top
|
|
|
///< left corner of the axis rect. setCoords(1, 1) will be at the bottom right corner, setCoords(0.5, 0) will be horizontally centered and
|
|
|
///< vertically at the top of the axis rect, etc. You can also go beyond the axis rect by providing negative coordinates or coordinates larger than 1.
|
|
|
,ptPlotCoords ///< Dynamic positioning at a plot coordinate defined by two axes (see \ref setAxes).
|
|
|
};
|
|
|
|
|
|
QCPItemPosition(QCustomPlot *parentPlot, QCPAbstractItem *parentItem, const QString name);
|
|
|
virtual ~QCPItemPosition();
|
|
|
|
|
|
// getters:
|
|
|
PositionType type() const { return mPositionType; }
|
|
|
QCPItemAnchor *parentAnchor() const { return mParentAnchor; }
|
|
|
double key() const { return mKey; }
|
|
|
double value() const { return mValue; }
|
|
|
QPointF coords() const { return QPointF(mKey, mValue); }
|
|
|
QCPAxis *keyAxis() const { return mKeyAxis.data(); }
|
|
|
QCPAxis *valueAxis() const { return mValueAxis.data(); }
|
|
|
QCPAxisRect *axisRect() const;
|
|
|
virtual QPointF pixelPoint() const;
|
|
|
|
|
|
// setters:
|
|
|
void setType(PositionType type);
|
|
|
bool setParentAnchor(QCPItemAnchor *parentAnchor, bool keepPixelPosition=false);
|
|
|
void setCoords(double key, double value);
|
|
|
void setCoords(const QPointF &coords);
|
|
|
void setAxes(QCPAxis* keyAxis, QCPAxis* valueAxis);
|
|
|
void setAxisRect(QCPAxisRect *axisRect);
|
|
|
void setPixelPoint(const QPointF &pixelPoint);
|
|
|
|
|
|
protected:
|
|
|
// property members:
|
|
|
PositionType mPositionType;
|
|
|
QPointer<QCPAxis> mKeyAxis, mValueAxis;
|
|
|
QPointer<QCPAxisRect> mAxisRect;
|
|
|
double mKey, mValue;
|
|
|
QCPItemAnchor *mParentAnchor;
|
|
|
|
|
|
// reimplemented virtual methods:
|
|
|
virtual QCPItemPosition *toQCPItemPosition() { return this; }
|
|
|
|
|
|
private:
|
|
|
Q_DISABLE_COPY(QCPItemPosition)
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
class QCP_LIB_DECL QCPAbstractItem : public QCPLayerable
|
|
|
{
|
|
|
Q_OBJECT
|
|
|
/// \cond INCLUDE_QPROPERTIES
|
|
|
Q_PROPERTY(bool clipToAxisRect READ clipToAxisRect WRITE setClipToAxisRect)
|
|
|
Q_PROPERTY(QCPAxisRect* clipAxisRect READ clipAxisRect WRITE setClipAxisRect)
|
|
|
Q_PROPERTY(bool selectable READ selectable WRITE setSelectable NOTIFY selectableChanged)
|
|
|
Q_PROPERTY(bool selected READ selected WRITE setSelected NOTIFY selectionChanged)
|
|
|
/// \endcond
|
|
|
public:
|
|
|
QCPAbstractItem(QCustomPlot *parentPlot);
|
|
|
virtual ~QCPAbstractItem();
|
|
|
|
|
|
// getters:
|
|
|
bool clipToAxisRect() const { return mClipToAxisRect; }
|
|
|
QCPAxisRect *clipAxisRect() const;
|
|
|
bool selectable() const { return mSelectable; }
|
|
|
bool selected() const { return mSelected; }
|
|
|
|
|
|
// setters:
|
|
|
void setClipToAxisRect(bool clip);
|
|
|
void setClipAxisRect(QCPAxisRect *rect);
|
|
|
Q_SLOT void setSelectable(bool selectable);
|
|
|
Q_SLOT void setSelected(bool selected);
|
|
|
|
|
|
// reimplemented virtual methods:
|
|
|
virtual double selectTest(const QPointF &pos, bool onlySelectable, QVariant *details=0) const = 0;
|
|
|
|
|
|
// non-virtual methods:
|
|
|
QList<QCPItemPosition*> positions() const { return mPositions; }
|
|
|
QList<QCPItemAnchor*> anchors() const { return mAnchors; }
|
|
|
QCPItemPosition *position(const QString &name) const;
|
|
|
QCPItemAnchor *anchor(const QString &name) const;
|
|
|
bool hasAnchor(const QString &name) const;
|
|
|
|
|
|
signals:
|
|
|
void selectionChanged(bool selected);
|
|
|
void selectableChanged(bool selectable);
|
|
|
|
|
|
protected:
|
|
|
// property members:
|
|
|
bool mClipToAxisRect;
|
|
|
QPointer<QCPAxisRect> mClipAxisRect;
|
|
|
QList<QCPItemPosition*> mPositions;
|
|
|
QList<QCPItemAnchor*> mAnchors;
|
|
|
bool mSelectable, mSelected;
|
|
|
|
|
|
// reimplemented virtual methods:
|
|
|
virtual QCP::Interaction selectionCategory() const;
|
|
|
virtual QRect clipRect() const;
|
|
|
virtual void applyDefaultAntialiasingHint(QCPPainter *painter) const;
|
|
|
virtual void draw(QCPPainter *painter) = 0;
|
|
|
// events:
|
|
|
virtual void selectEvent(QMouseEvent *event, bool additive, const QVariant &details, bool *selectionStateChanged);
|
|
|
virtual void deselectEvent(bool *selectionStateChanged);
|
|
|
|
|
|
// introduced virtual methods:
|
|
|
virtual QPointF anchorPixelPoint(int anchorId) const;
|
|
|
|
|
|
// non-virtual methods:
|
|
|
double distSqrToLine(const QPointF &start, const QPointF &end, const QPointF &point) const;
|
|
|
double rectSelectTest(const QRectF &rect, const QPointF &pos, bool filledRect) const;
|
|
|
QCPItemPosition *createPosition(const QString &name);
|
|
|
QCPItemAnchor *createAnchor(const QString &name, int anchorId);
|
|
|
|
|
|
private:
|
|
|
Q_DISABLE_COPY(QCPAbstractItem)
|
|
|
|
|
|
friend class QCustomPlot;
|
|
|
friend class QCPItemAnchor;
|
|
|
};
|
|
|
|
|
|
|
|
|
class QCP_LIB_DECL QCustomPlot : public QWidget
|
|
|
{
|
|
|
Q_OBJECT
|
|
|
/// \cond INCLUDE_QPROPERTIES
|
|
|
Q_PROPERTY(QRect viewport READ viewport WRITE setViewport)
|
|
|
Q_PROPERTY(QPixmap background READ background WRITE setBackground)
|
|
|
Q_PROPERTY(bool backgroundScaled READ backgroundScaled WRITE setBackgroundScaled)
|
|
|
Q_PROPERTY(Qt::AspectRatioMode backgroundScaledMode READ backgroundScaledMode WRITE setBackgroundScaledMode)
|
|
|
Q_PROPERTY(QCPLayoutGrid* plotLayout READ plotLayout)
|
|
|
Q_PROPERTY(bool autoAddPlottableToLegend READ autoAddPlottableToLegend WRITE setAutoAddPlottableToLegend)
|
|
|
Q_PROPERTY(int selectionTolerance READ selectionTolerance WRITE setSelectionTolerance)
|
|
|
Q_PROPERTY(bool noAntialiasingOnDrag READ noAntialiasingOnDrag WRITE setNoAntialiasingOnDrag)
|
|
|
Q_PROPERTY(Qt::KeyboardModifier multiSelectModifier READ multiSelectModifier WRITE setMultiSelectModifier)
|
|
|
/// \endcond
|
|
|
public:
|
|
|
/*!
|
|
|
Defines how a layer should be inserted relative to an other layer.
|
|
|
|
|
|
\see addLayer, moveLayer
|
|
|
*/
|
|
|
enum LayerInsertMode { limBelow ///< Layer is inserted below other layer
|
|
|
,limAbove ///< Layer is inserted above other layer
|
|
|
};
|
|
|
Q_ENUMS(LayerInsertMode)
|
|
|
|
|
|
/*!
|
|
|
Defines with what timing the QCustomPlot surface is refreshed after a replot.
|
|
|
|
|
|
\see replot
|
|
|
*/
|
|
|
enum RefreshPriority { rpImmediate ///< The QCustomPlot surface is immediately refreshed, by calling QWidget::repaint() after the replot
|
|
|
,rpQueued ///< Queues the refresh such that it is performed at a slightly delayed point in time after the replot, by calling QWidget::update() after the replot
|
|
|
,rpHint ///< Whether to use immediate repaint or queued update depends on whether the plotting hint \ref QCP::phForceRepaint is set, see \ref setPlottingHints.
|
|
|
};
|
|
|
|
|
|
explicit QCustomPlot(QWidget *parent = 0);
|
|
|
virtual ~QCustomPlot();
|
|
|
|
|
|
// getters:
|
|
|
QRect viewport() const { return mViewport; }
|
|
|
QPixmap background() const { return mBackgroundPixmap; }
|
|
|
bool backgroundScaled() const { return mBackgroundScaled; }
|
|
|
Qt::AspectRatioMode backgroundScaledMode() const { return mBackgroundScaledMode; }
|
|
|
QCPLayoutGrid *plotLayout() const { return mPlotLayout; }
|
|
|
QCP::AntialiasedElements antialiasedElements() const { return mAntialiasedElements; }
|
|
|
QCP::AntialiasedElements notAntialiasedElements() const { return mNotAntialiasedElements; }
|
|
|
bool autoAddPlottableToLegend() const { return mAutoAddPlottableToLegend; }
|
|
|
const QCP::Interactions interactions() const { return mInteractions; }
|
|
|
int selectionTolerance() const { return mSelectionTolerance; }
|
|
|
bool noAntialiasingOnDrag() const { return mNoAntialiasingOnDrag; }
|
|
|
QCP::PlottingHints plottingHints() const { return mPlottingHints; }
|
|
|
Qt::KeyboardModifier multiSelectModifier() const { return mMultiSelectModifier; }
|
|
|
|
|
|
// setters:
|
|
|
void setViewport(const QRect &rect);
|
|
|
void setBackground(const QPixmap &pm);
|
|
|
void setBackground(const QPixmap &pm, bool scaled, Qt::AspectRatioMode mode=Qt::KeepAspectRatioByExpanding);
|
|
|
void setBackground(const QBrush &brush);
|
|
|
void setBackgroundScaled(bool scaled);
|
|
|
void setBackgroundScaledMode(Qt::AspectRatioMode mode);
|
|
|
void setAntialiasedElements(const QCP::AntialiasedElements &antialiasedElements);
|
|
|
void setAntialiasedElement(QCP::AntialiasedElement antialiasedElement, bool enabled=true);
|
|
|
void setNotAntialiasedElements(const QCP::AntialiasedElements ¬AntialiasedElements);
|
|
|
void setNotAntialiasedElement(QCP::AntialiasedElement notAntialiasedElement, bool enabled=true);
|
|
|
void setAutoAddPlottableToLegend(bool on);
|
|
|
void setInteractions(const QCP::Interactions &interactions);
|
|
|
void setInteraction(const QCP::Interaction &interaction, bool enabled=true);
|
|
|
void setSelectionTolerance(int pixels);
|
|
|
void setNoAntialiasingOnDrag(bool enabled);
|
|
|
void setPlottingHints(const QCP::PlottingHints &hints);
|
|
|
void setPlottingHint(QCP::PlottingHint hint, bool enabled=true);
|
|
|
void setMultiSelectModifier(Qt::KeyboardModifier modifier);
|
|
|
|
|
|
// non-property methods:
|
|
|
// plottable interface:
|
|
|
QCPAbstractPlottable *plottable(int index);
|
|
|
QCPAbstractPlottable *plottable();
|
|
|
bool addPlottable(QCPAbstractPlottable *plottable);
|
|
|
bool removePlottable(QCPAbstractPlottable *plottable);
|
|
|
bool removePlottable(int index);
|
|
|
int clearPlottables();
|
|
|
int plottableCount() const;
|
|
|
QList<QCPAbstractPlottable*> selectedPlottables() const;
|
|
|
QCPAbstractPlottable *plottableAt(const QPointF &pos, bool onlySelectable=false) const;
|
|
|
bool hasPlottable(QCPAbstractPlottable *plottable) const;
|
|
|
|
|
|
// specialized interface for QCPGraph:
|
|
|
QCPGraph *graph(int index) const;
|
|
|
QCPGraph *graph() const;
|
|
|
QCPGraph *addGraph(QCPAxis *keyAxis=0, QCPAxis *valueAxis=0);
|
|
|
bool removeGraph(QCPGraph *graph);
|
|
|
bool removeGraph(int index);
|
|
|
int clearGraphs();
|
|
|
int graphCount() const;
|
|
|
QList<QCPGraph*> selectedGraphs() const;
|
|
|
|
|
|
// item interface:
|
|
|
QCPAbstractItem *item(int index) const;
|
|
|
QCPAbstractItem *item() const;
|
|
|
bool addItem(QCPAbstractItem* item);
|
|
|
bool removeItem(QCPAbstractItem *item);
|
|
|
bool removeItem(int index);
|
|
|
int clearItems();
|
|
|
int itemCount() const;
|
|
|
QList<QCPAbstractItem*> selectedItems() const;
|
|
|
QCPAbstractItem *itemAt(const QPointF &pos, bool onlySelectable=false) const;
|
|
|
bool hasItem(QCPAbstractItem *item) const;
|
|
|
|
|
|
// layer interface:
|
|
|
QCPLayer *layer(const QString &name) const;
|
|
|
QCPLayer *layer(int index) const;
|
|
|
QCPLayer *currentLayer() const;
|
|
|
bool setCurrentLayer(const QString &name);
|
|
|
bool setCurrentLayer(QCPLayer *layer);
|
|
|
int layerCount() const;
|
|
|
bool addLayer(const QString &name, QCPLayer *otherLayer=0, LayerInsertMode insertMode=limAbove);
|
|
|
bool removeLayer(QCPLayer *layer);
|
|
|
bool moveLayer(QCPLayer *layer, QCPLayer *otherLayer, LayerInsertMode insertMode=limAbove);
|
|
|
|
|
|
// axis rect/layout interface:
|
|
|
int axisRectCount() const;
|
|
|
QCPAxisRect* axisRect(int index=0) const;
|
|
|
QList<QCPAxisRect*> axisRects() const;
|
|
|
QCPLayoutElement* layoutElementAt(const QPointF &pos) const;
|
|
|
Q_SLOT void rescaleAxes(bool onlyVisiblePlottables=false);
|
|
|
|
|
|
QList<QCPAxis*> selectedAxes() const;
|
|
|
QList<QCPLegend*> selectedLegends() const;
|
|
|
Q_SLOT void deselectAll();
|
|
|
|
|
|
bool savePdf(const QString &fileName, bool noCosmeticPen=false, int width=0, int height=0, const QString &pdfCreator="", const QString &pdfTitle="");
|
|
|
bool savePng(const QString &fileName, int width=0, int height=0, double scale=1.0, int quality=-1);
|
|
|
bool saveJpg(const QString &fileName, int width=0, int height=0, double scale=1.0, int quality=-1);
|
|
|
bool saveBmp(const QString &fileName, int width=0, int height=0, double scale=1.0);
|
|
|
bool saveRastered(const QString &fileName, int width, int height, double scale, const char *format, int quality=-1);
|
|
|
QPixmap toPixmap(int width=0, int height=0, double scale=1.0);
|
|
|
void toPainter(QCPPainter *painter, int width=0, int height=0);
|
|
|
Q_SLOT void replot(QCustomPlot::RefreshPriority refreshPriority=QCustomPlot::rpHint);
|
|
|
|
|
|
QCPAxis *xAxis, *yAxis, *xAxis2, *yAxis2;
|
|
|
QCPLegend *legend;
|
|
|
|
|
|
signals:
|
|
|
void mouseDoubleClick(QMouseEvent *event);
|
|
|
void mousePress(QMouseEvent *event);
|
|
|
void mouseMove(QMouseEvent *event);
|
|
|
void mouseRelease(QMouseEvent *event);
|
|
|
void mouseWheel(QWheelEvent *event);
|
|
|
|
|
|
void plottableClick(QCPAbstractPlottable *plottable, QMouseEvent *event);
|
|
|
void plottableDoubleClick(QCPAbstractPlottable *plottable, QMouseEvent *event);
|
|
|
void itemClick(QCPAbstractItem *item, QMouseEvent *event);
|
|
|
void itemDoubleClick(QCPAbstractItem *item, QMouseEvent *event);
|
|
|
void axisClick(QCPAxis *axis, QCPAxis::SelectablePart part, QMouseEvent *event);
|
|
|
void axisDoubleClick(QCPAxis *axis, QCPAxis::SelectablePart part, QMouseEvent *event);
|
|
|
void legendClick(QCPLegend *legend, QCPAbstractLegendItem *item, QMouseEvent *event);
|
|
|
void legendDoubleClick(QCPLegend *legend, QCPAbstractLegendItem *item, QMouseEvent *event);
|
|
|
void titleClick(QMouseEvent *event, QCPPlotTitle *title);
|
|
|
void titleDoubleClick(QMouseEvent *event, QCPPlotTitle *title);
|
|
|
|
|
|
void selectionChangedByUser();
|
|
|
void beforeReplot();
|
|
|
void afterReplot();
|
|
|
|
|
|
protected:
|
|
|
// property members:
|
|
|
QRect mViewport;
|
|
|
QCPLayoutGrid *mPlotLayout;
|
|
|
bool mAutoAddPlottableToLegend;
|
|
|
QList<QCPAbstractPlottable*> mPlottables;
|
|
|
QList<QCPGraph*> mGraphs; // extra list of plottables also in mPlottables that are of type QCPGraph
|
|
|
QList<QCPAbstractItem*> mItems;
|
|
|
QList<QCPLayer*> mLayers;
|
|
|
QCP::AntialiasedElements mAntialiasedElements, mNotAntialiasedElements;
|
|
|
QCP::Interactions mInteractions;
|
|
|
int mSelectionTolerance;
|
|
|
bool mNoAntialiasingOnDrag;
|
|
|
QBrush mBackgroundBrush;
|
|
|
QPixmap mBackgroundPixmap;
|
|
|
QPixmap mScaledBackgroundPixmap;
|
|
|
bool mBackgroundScaled;
|
|
|
Qt::AspectRatioMode mBackgroundScaledMode;
|
|
|
QCPLayer *mCurrentLayer;
|
|
|
QCP::PlottingHints mPlottingHints;
|
|
|
Qt::KeyboardModifier mMultiSelectModifier;
|
|
|
|
|
|
// non-property members:
|
|
|
QPixmap mPaintBuffer;
|
|
|
QPoint mMousePressPos;
|
|
|
QPointer<QCPLayoutElement> mMouseEventElement;
|
|
|
bool mReplotting;
|
|
|
|
|
|
// reimplemented virtual methods:
|
|
|
virtual QSize minimumSizeHint() const;
|
|
|
virtual QSize sizeHint() const;
|
|
|
virtual void paintEvent(QPaintEvent *event);
|
|
|
virtual void resizeEvent(QResizeEvent *event);
|
|
|
virtual void mouseDoubleClickEvent(QMouseEvent *event);
|
|
|
virtual void mousePressEvent(QMouseEvent *event);
|
|
|
virtual void mouseMoveEvent(QMouseEvent *event);
|
|
|
virtual void mouseReleaseEvent(QMouseEvent *event);
|
|
|
virtual void wheelEvent(QWheelEvent *event);
|
|
|
|
|
|
// introduced virtual methods:
|
|
|
virtual void draw(QCPPainter *painter);
|
|
|
virtual void axisRemoved(QCPAxis *axis);
|
|
|
virtual void legendRemoved(QCPLegend *legend);
|
|
|
|
|
|
// non-virtual methods:
|
|
|
void updateLayerIndices() const;
|
|
|
QCPLayerable *layerableAt(const QPointF &pos, bool onlySelectable, QVariant *selectionDetails=0) const;
|
|
|
void drawBackground(QCPPainter *painter);
|
|
|
|
|
|
friend class QCPLegend;
|
|
|
friend class QCPAxis;
|
|
|
friend class QCPLayer;
|
|
|
friend class QCPAxisRect;
|
|
|
};
|
|
|
|
|
|
|
|
|
class QCP_LIB_DECL QCPColorGradient
|
|
|
{
|
|
|
Q_GADGET
|
|
|
public:
|
|
|
/*!
|
|
|
Defines the color spaces in which color interpolation between gradient stops can be performed.
|
|
|
|
|
|
\see setColorInterpolation
|
|
|
*/
|
|
|
enum ColorInterpolation { ciRGB ///< Color channels red, green and blue are linearly interpolated
|
|
|
,ciHSV ///< Color channels hue, saturation and value are linearly interpolated (The hue is interpolated over the shortest angle distance)
|
|
|
};
|
|
|
Q_ENUMS(ColorInterpolation)
|
|
|
|
|
|
/*!
|
|
|
Defines the available presets that can be loaded with \ref loadPreset. See the documentation
|
|
|
there for an image of the presets.
|
|
|
*/
|
|
|
enum GradientPreset { gpGrayscale ///< Continuous lightness from black to white (suited for non-biased data representation)
|
|
|
,gpHot ///< Continuous lightness from black over firey colors to white (suited for non-biased data representation)
|
|
|
,gpCold ///< Continuous lightness from black over icey colors to white (suited for non-biased data representation)
|
|
|
,gpNight ///< Continuous lightness from black over weak blueish colors to white (suited for non-biased data representation)
|
|
|
,gpCandy ///< Blue over pink to white
|
|
|
,gpGeography ///< Colors suitable to represent different elevations on geographical maps
|
|
|
,gpIon ///< Half hue spectrum from black over purple to blue and finally green (creates banding illusion but allows more precise magnitude estimates)
|
|
|
,gpThermal ///< Colors suitable for thermal imaging, ranging from dark blue over purple to orange, yellow and white
|
|
|
,gpPolar ///< Colors suitable to emphasize polarity around the center, with blue for negative, black in the middle and red for positive values
|
|
|
,gpSpectrum ///< An approximation of the visible light spectrum (creates banding illusion but allows more precise magnitude estimates)
|
|
|
,gpJet ///< Hue variation similar to a spectrum, often used in numerical visualization (creates banding illusion but allows more precise magnitude estimates)
|
|
|
,gpHues ///< Full hue cycle, with highest and lowest color red (suitable for periodic data, such as angles and phases, see \ref setPeriodic)
|
|
|
};
|
|
|
Q_ENUMS(GradientPreset)
|
|
|
|
|
|
QCPColorGradient(GradientPreset preset=gpCold);
|
|
|
bool operator==(const QCPColorGradient &other) const;
|
|
|
bool operator!=(const QCPColorGradient &other) const { return !(*this == other); }
|
|
|
|
|
|
// getters:
|
|
|
int levelCount() const { return mLevelCount; }
|
|
|
QMap<double, QColor> colorStops() const { return mColorStops; }
|
|
|
ColorInterpolation colorInterpolation() const { return mColorInterpolation; }
|
|
|
bool periodic() const { return mPeriodic; }
|
|
|
|
|
|
// setters:
|
|
|
void setLevelCount(int n);
|
|
|
void setColorStops(const QMap<double, QColor> &colorStops);
|
|
|
void setColorStopAt(double position, const QColor &color);
|
|
|
void setColorInterpolation(ColorInterpolation interpolation);
|
|
|
void setPeriodic(bool enabled);
|
|
|
|
|
|
// non-property methods:
|
|
|
void colorize(const double *data, const QCPRange &range, QRgb *scanLine, int n, int dataIndexFactor=1, bool logarithmic=false);
|
|
|
QRgb color(double position, const QCPRange &range, bool logarithmic=false);
|
|
|
void loadPreset(GradientPreset preset);
|
|
|
void clearColorStops();
|
|
|
QCPColorGradient inverted() const;
|
|
|
|
|
|
protected:
|
|
|
void updateColorBuffer();
|
|
|
|
|
|
// property members:
|
|
|
int mLevelCount;
|
|
|
QMap<double, QColor> mColorStops;
|
|
|
ColorInterpolation mColorInterpolation;
|
|
|
bool mPeriodic;
|
|
|
|
|
|
// non-property members:
|
|
|
QVector<QRgb> mColorBuffer;
|
|
|
bool mColorBufferInvalidated;
|
|
|
};
|
|
|
|
|
|
|
|
|
class QCP_LIB_DECL QCPAxisRect : public QCPLayoutElement
|
|
|
{
|
|
|
Q_OBJECT
|
|
|
/// \cond INCLUDE_QPROPERTIES
|
|
|
Q_PROPERTY(QPixmap background READ background WRITE setBackground)
|
|
|
Q_PROPERTY(bool backgroundScaled READ backgroundScaled WRITE setBackgroundScaled)
|
|
|
Q_PROPERTY(Qt::AspectRatioMode backgroundScaledMode READ backgroundScaledMode WRITE setBackgroundScaledMode)
|
|
|
Q_PROPERTY(Qt::Orientations rangeDrag READ rangeDrag WRITE setRangeDrag)
|
|
|
Q_PROPERTY(Qt::Orientations rangeZoom READ rangeZoom WRITE setRangeZoom)
|
|
|
/// \endcond
|
|
|
public:
|
|
|
explicit QCPAxisRect(QCustomPlot *parentPlot, bool setupDefaultAxes=true);
|
|
|
virtual ~QCPAxisRect();
|
|
|
|
|
|
// getters:
|
|
|
QPixmap background() const { return mBackgroundPixmap; }
|
|
|
bool backgroundScaled() const { return mBackgroundScaled; }
|
|
|
Qt::AspectRatioMode backgroundScaledMode() const { return mBackgroundScaledMode; }
|
|
|
Qt::Orientations rangeDrag() const { return mRangeDrag; }
|
|
|
Qt::Orientations rangeZoom() const { return mRangeZoom; }
|
|
|
QCPAxis *rangeDragAxis(Qt::Orientation orientation);
|
|
|
QCPAxis *rangeZoomAxis(Qt::Orientation orientation);
|
|
|
double rangeZoomFactor(Qt::Orientation orientation);
|
|
|
|
|
|
// setters:
|
|
|
void setBackground(const QPixmap &pm);
|
|
|
void setBackground(const QPixmap &pm, bool scaled, Qt::AspectRatioMode mode=Qt::KeepAspectRatioByExpanding);
|
|
|
void setBackground(const QBrush &brush);
|
|
|
void setBackgroundScaled(bool scaled);
|
|
|
void setBackgroundScaledMode(Qt::AspectRatioMode mode);
|
|
|
void setRangeDrag(Qt::Orientations orientations);
|
|
|
void setRangeZoom(Qt::Orientations orientations);
|
|
|
void setRangeDragAxes(QCPAxis *horizontal, QCPAxis *vertical);
|
|
|
void setRangeZoomAxes(QCPAxis *horizontal, QCPAxis *vertical);
|
|
|
void setRangeZoomFactor(double horizontalFactor, double verticalFactor);
|
|
|
void setRangeZoomFactor(double factor);
|
|
|
|
|
|
// non-property methods:
|
|
|
int axisCount(QCPAxis::AxisType type) const;
|
|
|
QCPAxis *axis(QCPAxis::AxisType type, int index=0) const;
|
|
|
QList<QCPAxis*> axes(QCPAxis::AxisTypes types) const;
|
|
|
QList<QCPAxis*> axes() const;
|
|
|
QCPAxis *addAxis(QCPAxis::AxisType type);
|
|
|
QList<QCPAxis*> addAxes(QCPAxis::AxisTypes types);
|
|
|
bool removeAxis(QCPAxis *axis);
|
|
|
QCPLayoutInset *insetLayout() const { return mInsetLayout; }
|
|
|
|
|
|
void setupFullAxesBox(bool connectRanges=false);
|
|
|
QList<QCPAbstractPlottable*> plottables() const;
|
|
|
QList<QCPGraph*> graphs() const;
|
|
|
QList<QCPAbstractItem*> items() const;
|
|
|
|
|
|
// read-only interface imitating a QRect:
|
|
|
int left() const { return mRect.left(); }
|
|
|
int right() const { return mRect.right(); }
|
|
|
int top() const { return mRect.top(); }
|
|
|
int bottom() const { return mRect.bottom(); }
|
|
|
int width() const { return mRect.width(); }
|
|
|
int height() const { return mRect.height(); }
|
|
|
QSize size() const { return mRect.size(); }
|
|
|
QPoint topLeft() const { return mRect.topLeft(); }
|
|
|
QPoint topRight() const { return mRect.topRight(); }
|
|
|
QPoint bottomLeft() const { return mRect.bottomLeft(); }
|
|
|
QPoint bottomRight() const { return mRect.bottomRight(); }
|
|
|
QPoint center() const { return mRect.center(); }
|
|
|
|
|
|
// reimplemented virtual methods:
|
|
|
virtual void update(UpdatePhase phase);
|
|
|
virtual QList<QCPLayoutElement*> elements(bool recursive) const;
|
|
|
|
|
|
protected:
|
|
|
// property members:
|
|
|
QBrush mBackgroundBrush;
|
|
|
QPixmap mBackgroundPixmap;
|
|
|
QPixmap mScaledBackgroundPixmap;
|
|
|
bool mBackgroundScaled;
|
|
|
Qt::AspectRatioMode mBackgroundScaledMode;
|
|
|
QCPLayoutInset *mInsetLayout;
|
|
|
Qt::Orientations mRangeDrag, mRangeZoom;
|
|
|
QPointer<QCPAxis> mRangeDragHorzAxis, mRangeDragVertAxis, mRangeZoomHorzAxis, mRangeZoomVertAxis;
|
|
|
double mRangeZoomFactorHorz, mRangeZoomFactorVert;
|
|
|
// non-property members:
|
|
|
QCPRange mDragStartHorzRange, mDragStartVertRange;
|
|
|
QCP::AntialiasedElements mAADragBackup, mNotAADragBackup;
|
|
|
QPoint mDragStart;
|
|
|
bool mDragging;
|
|
|
QHash<QCPAxis::AxisType, QList<QCPAxis*> > mAxes;
|
|
|
|
|
|
// reimplemented virtual methods:
|
|
|
virtual void applyDefaultAntialiasingHint(QCPPainter *painter) const;
|
|
|
virtual void draw(QCPPainter *painter);
|
|
|
virtual int calculateAutoMargin(QCP::MarginSide side);
|
|
|
// events:
|
|
|
virtual void mousePressEvent(QMouseEvent *event);
|
|
|
virtual void mouseMoveEvent(QMouseEvent *event);
|
|
|
virtual void mouseReleaseEvent(QMouseEvent *event);
|
|
|
virtual void wheelEvent(QWheelEvent *event);
|
|
|
|
|
|
// non-property methods:
|
|
|
void drawBackground(QCPPainter *painter);
|
|
|
void updateAxesOffset(QCPAxis::AxisType type);
|
|
|
|
|
|
private:
|
|
|
Q_DISABLE_COPY(QCPAxisRect)
|
|
|
|
|
|
friend class QCustomPlot;
|
|
|
};
|
|
|
|
|
|
|
|
|
class QCP_LIB_DECL QCPAbstractLegendItem : public QCPLayoutElement
|
|
|
{
|
|
|
Q_OBJECT
|
|
|
/// \cond INCLUDE_QPROPERTIES
|
|
|
Q_PROPERTY(QCPLegend* parentLegend READ parentLegend)
|
|
|
Q_PROPERTY(QFont font READ font WRITE setFont)
|
|
|
Q_PROPERTY(QColor textColor READ textColor WRITE setTextColor)
|
|
|
Q_PROPERTY(QFont selectedFont READ selectedFont WRITE setSelectedFont)
|
|
|
Q_PROPERTY(QColor selectedTextColor READ selectedTextColor WRITE setSelectedTextColor)
|
|
|
Q_PROPERTY(bool selectable READ selectable WRITE setSelectable NOTIFY selectionChanged)
|
|
|
Q_PROPERTY(bool selected READ selected WRITE setSelected NOTIFY selectableChanged)
|
|
|
/// \endcond
|
|
|
public:
|
|
|
explicit QCPAbstractLegendItem(QCPLegend *parent);
|
|
|
|
|
|
// getters:
|
|
|
QCPLegend *parentLegend() const { return mParentLegend; }
|
|
|
QFont font() const { return mFont; }
|
|
|
QColor textColor() const { return mTextColor; }
|
|
|
QFont selectedFont() const { return mSelectedFont; }
|
|
|
QColor selectedTextColor() const { return mSelectedTextColor; }
|
|
|
bool selectable() const { return mSelectable; }
|
|
|
bool selected() const { return mSelected; }
|
|
|
|
|
|
// setters:
|
|
|
void setFont(const QFont &font);
|
|
|
void setTextColor(const QColor &color);
|
|
|
void setSelectedFont(const QFont &font);
|
|
|
void setSelectedTextColor(const QColor &color);
|
|
|
Q_SLOT void setSelectable(bool selectable);
|
|
|
Q_SLOT void setSelected(bool selected);
|
|
|
|
|
|
// reimplemented virtual methods:
|
|
|
virtual double selectTest(const QPointF &pos, bool onlySelectable, QVariant *details=0) const;
|
|
|
|
|
|
signals:
|
|
|
void selectionChanged(bool selected);
|
|
|
void selectableChanged(bool selectable);
|
|
|
|
|
|
protected:
|
|
|
// property members:
|
|
|
QCPLegend *mParentLegend;
|
|
|
QFont mFont;
|
|
|
QColor mTextColor;
|
|
|
QFont mSelectedFont;
|
|
|
QColor mSelectedTextColor;
|
|
|
bool mSelectable, mSelected;
|
|
|
|
|
|
// reimplemented virtual methods:
|
|
|
virtual QCP::Interaction selectionCategory() const;
|
|
|
virtual void applyDefaultAntialiasingHint(QCPPainter *painter) const;
|
|
|
virtual QRect clipRect() const;
|
|
|
virtual void draw(QCPPainter *painter) = 0;
|
|
|
// events:
|
|
|
virtual void selectEvent(QMouseEvent *event, bool additive, const QVariant &details, bool *selectionStateChanged);
|
|
|
virtual void deselectEvent(bool *selectionStateChanged);
|
|
|
|
|
|
private:
|
|
|
Q_DISABLE_COPY(QCPAbstractLegendItem)
|
|
|
|
|
|
friend class QCPLegend;
|
|
|
};
|
|
|
|
|
|
|
|
|
class QCP_LIB_DECL QCPPlottableLegendItem : public QCPAbstractLegendItem
|
|
|
{
|
|
|
Q_OBJECT
|
|
|
public:
|
|
|
QCPPlottableLegendItem(QCPLegend *parent, QCPAbstractPlottable *plottable);
|
|
|
|
|
|
// getters:
|
|
|
QCPAbstractPlottable *plottable() { return mPlottable; }
|
|
|
|
|
|
protected:
|
|
|
// property members:
|
|
|
QCPAbstractPlottable *mPlottable;
|
|
|
|
|
|
// reimplemented virtual methods:
|
|
|
virtual void draw(QCPPainter *painter);
|
|
|
virtual QSize minimumSizeHint() const;
|
|
|
|
|
|
// non-virtual methods:
|
|
|
QPen getIconBorderPen() const;
|
|
|
QColor getTextColor() const;
|
|
|
QFont getFont() const;
|
|
|
};
|
|
|
|
|
|
|
|
|
class QCP_LIB_DECL QCPLegend : public QCPLayoutGrid
|
|
|
{
|
|
|
Q_OBJECT
|
|
|
/// \cond INCLUDE_QPROPERTIES
|
|
|
Q_PROPERTY(QPen borderPen READ borderPen WRITE setBorderPen)
|
|
|
Q_PROPERTY(QBrush brush READ brush WRITE setBrush)
|
|
|
Q_PROPERTY(QFont font READ font WRITE setFont)
|
|
|
Q_PROPERTY(QColor textColor READ textColor WRITE setTextColor)
|
|
|
Q_PROPERTY(QSize iconSize READ iconSize WRITE setIconSize)
|
|
|
Q_PROPERTY(int iconTextPadding READ iconTextPadding WRITE setIconTextPadding)
|
|
|
Q_PROPERTY(QPen iconBorderPen READ iconBorderPen WRITE setIconBorderPen)
|
|
|
Q_PROPERTY(SelectableParts selectableParts READ selectableParts WRITE setSelectableParts NOTIFY selectionChanged)
|
|
|
Q_PROPERTY(SelectableParts selectedParts READ selectedParts WRITE setSelectedParts NOTIFY selectableChanged)
|
|
|
Q_PROPERTY(QPen selectedBorderPen READ selectedBorderPen WRITE setSelectedBorderPen)
|
|
|
Q_PROPERTY(QPen selectedIconBorderPen READ selectedIconBorderPen WRITE setSelectedIconBorderPen)
|
|
|
Q_PROPERTY(QBrush selectedBrush READ selectedBrush WRITE setSelectedBrush)
|
|
|
Q_PROPERTY(QFont selectedFont READ selectedFont WRITE setSelectedFont)
|
|
|
Q_PROPERTY(QColor selectedTextColor READ selectedTextColor WRITE setSelectedTextColor)
|
|
|
/// \endcond
|
|
|
public:
|
|
|
/*!
|
|
|
Defines the selectable parts of a legend
|
|
|
|
|
|
\see setSelectedParts, setSelectableParts
|
|
|
*/
|
|
|
enum SelectablePart { spNone = 0x000 ///< <tt>0x000</tt> None
|
|
|
,spLegendBox = 0x001 ///< <tt>0x001</tt> The legend box (frame)
|
|
|
,spItems = 0x002 ///< <tt>0x002</tt> Legend items individually (see \ref selectedItems)
|
|
|
};
|
|
|
Q_FLAGS(SelectablePart SelectableParts)
|
|
|
Q_DECLARE_FLAGS(SelectableParts, SelectablePart)
|
|
|
|
|
|
explicit QCPLegend();
|
|
|
virtual ~QCPLegend();
|
|
|
|
|
|
// getters:
|
|
|
QPen borderPen() const { return mBorderPen; }
|
|
|
QBrush brush() const { return mBrush; }
|
|
|
QFont font() const { return mFont; }
|
|
|
QColor textColor() const { return mTextColor; }
|
|
|
QSize iconSize() const { return mIconSize; }
|
|
|
int iconTextPadding() const { return mIconTextPadding; }
|
|
|
QPen iconBorderPen() const { return mIconBorderPen; }
|
|
|
SelectableParts selectableParts() const { return mSelectableParts; }
|
|
|
SelectableParts selectedParts() const;
|
|
|
QPen selectedBorderPen() const { return mSelectedBorderPen; }
|
|
|
QPen selectedIconBorderPen() const { return mSelectedIconBorderPen; }
|
|
|
QBrush selectedBrush() const { return mSelectedBrush; }
|
|
|
QFont selectedFont() const { return mSelectedFont; }
|
|
|
QColor selectedTextColor() const { return mSelectedTextColor; }
|
|
|
|
|
|
// setters:
|
|
|
void setBorderPen(const QPen &pen);
|
|
|
void setBrush(const QBrush &brush);
|
|
|
void setFont(const QFont &font);
|
|
|
void setTextColor(const QColor &color);
|
|
|
void setIconSize(const QSize &size);
|
|
|
void setIconSize(int width, int height);
|
|
|
void setIconTextPadding(int padding);
|
|
|
void setIconBorderPen(const QPen &pen);
|
|
|
Q_SLOT void setSelectableParts(const SelectableParts &selectableParts);
|
|
|
Q_SLOT void setSelectedParts(const SelectableParts &selectedParts);
|
|
|
void setSelectedBorderPen(const QPen &pen);
|
|
|
void setSelectedIconBorderPen(const QPen &pen);
|
|
|
void setSelectedBrush(const QBrush &brush);
|
|
|
void setSelectedFont(const QFont &font);
|
|
|
void setSelectedTextColor(const QColor &color);
|
|
|
|
|
|
// reimplemented virtual methods:
|
|
|
virtual double selectTest(const QPointF &pos, bool onlySelectable, QVariant *details=0) const;
|
|
|
|
|
|
// non-virtual methods:
|
|
|
QCPAbstractLegendItem *item(int index) const;
|
|
|
QCPPlottableLegendItem *itemWithPlottable(const QCPAbstractPlottable *plottable) const;
|
|
|
int itemCount() const;
|
|
|
bool hasItem(QCPAbstractLegendItem *item) const;
|
|
|
bool hasItemWithPlottable(const QCPAbstractPlottable *plottable) const;
|
|
|
bool addItem(QCPAbstractLegendItem *item);
|
|
|
bool removeItem(int index);
|
|
|
bool removeItem(QCPAbstractLegendItem *item);
|
|
|
void clearItems();
|
|
|
QList<QCPAbstractLegendItem*> selectedItems() const;
|
|
|
|
|
|
signals:
|
|
|
void selectionChanged(QCPLegend::SelectableParts parts);
|
|
|
void selectableChanged(QCPLegend::SelectableParts parts);
|
|
|
|
|
|
protected:
|
|
|
// property members:
|
|
|
QPen mBorderPen, mIconBorderPen;
|
|
|
QBrush mBrush;
|
|
|
QFont mFont;
|
|
|
QColor mTextColor;
|
|
|
QSize mIconSize;
|
|
|
int mIconTextPadding;
|
|
|
SelectableParts mSelectedParts, mSelectableParts;
|
|
|
QPen mSelectedBorderPen, mSelectedIconBorderPen;
|
|
|
QBrush mSelectedBrush;
|
|
|
QFont mSelectedFont;
|
|
|
QColor mSelectedTextColor;
|
|
|
|
|
|
// reimplemented virtual methods:
|
|
|
virtual void parentPlotInitialized(QCustomPlot *parentPlot);
|
|
|
virtual QCP::Interaction selectionCategory() const;
|
|
|
virtual void applyDefaultAntialiasingHint(QCPPainter *painter) const;
|
|
|
virtual void draw(QCPPainter *painter);
|
|
|
// events:
|
|
|
virtual void selectEvent(QMouseEvent *event, bool additive, const QVariant &details, bool *selectionStateChanged);
|
|
|
virtual void deselectEvent(bool *selectionStateChanged);
|
|
|
|
|
|
// non-virtual methods:
|
|
|
QPen getBorderPen() const;
|
|
|
QBrush getBrush() const;
|
|
|
|
|
|
private:
|
|
|
Q_DISABLE_COPY(QCPLegend)
|
|
|
|
|
|
friend class QCustomPlot;
|
|
|
friend class QCPAbstractLegendItem;
|
|
|
};
|
|
|
Q_DECLARE_OPERATORS_FOR_FLAGS(QCPLegend::SelectableParts)
|
|
|
Q_DECLARE_METATYPE(QCPLegend::SelectablePart)
|
|
|
|
|
|
|
|
|
class QCP_LIB_DECL QCPPlotTitle : public QCPLayoutElement
|
|
|
{
|
|
|
Q_OBJECT
|
|
|
/// \cond INCLUDE_QPROPERTIES
|
|
|
Q_PROPERTY(QString text READ text WRITE setText)
|
|
|
Q_PROPERTY(QFont font READ font WRITE setFont)
|
|
|
Q_PROPERTY(QColor textColor READ textColor WRITE setTextColor)
|
|
|
Q_PROPERTY(QFont selectedFont READ selectedFont WRITE setSelectedFont)
|
|
|
Q_PROPERTY(QColor selectedTextColor READ selectedTextColor WRITE setSelectedTextColor)
|
|
|
Q_PROPERTY(bool selectable READ selectable WRITE setSelectable NOTIFY selectableChanged)
|
|
|
Q_PROPERTY(bool selected READ selected WRITE setSelected NOTIFY selectionChanged)
|
|
|
/// \endcond
|
|
|
public:
|
|
|
explicit QCPPlotTitle(QCustomPlot *parentPlot);
|
|
|
explicit QCPPlotTitle(QCustomPlot *parentPlot, const QString &text);
|
|
|
|
|
|
// getters:
|
|
|
QString text() const { return mText; }
|
|
|
QFont font() const { return mFont; }
|
|
|
QColor textColor() const { return mTextColor; }
|
|
|
QFont selectedFont() const { return mSelectedFont; }
|
|
|
QColor selectedTextColor() const { return mSelectedTextColor; }
|
|
|
bool selectable() const { return mSelectable; }
|
|
|
bool selected() const { return mSelected; }
|
|
|
|
|
|
// setters:
|
|
|
void setText(const QString &text);
|
|
|
void setFont(const QFont &font);
|
|
|
void setTextColor(const QColor &color);
|
|
|
void setSelectedFont(const QFont &font);
|
|
|
void setSelectedTextColor(const QColor &color);
|
|
|
Q_SLOT void setSelectable(bool selectable);
|
|
|
Q_SLOT void setSelected(bool selected);
|
|
|
|
|
|
// reimplemented virtual methods:
|
|
|
virtual double selectTest(const QPointF &pos, bool onlySelectable, QVariant *details=0) const;
|
|
|
|
|
|
signals:
|
|
|
void selectionChanged(bool selected);
|
|
|
void selectableChanged(bool selectable);
|
|
|
|
|
|
protected:
|
|
|
// property members:
|
|
|
QString mText;
|
|
|
QFont mFont;
|
|
|
QColor mTextColor;
|
|
|
QFont mSelectedFont;
|
|
|
QColor mSelectedTextColor;
|
|
|
QRect mTextBoundingRect;
|
|
|
bool mSelectable, mSelected;
|
|
|
|
|
|
// reimplemented virtual methods:
|
|
|
virtual void applyDefaultAntialiasingHint(QCPPainter *painter) const;
|
|
|
virtual void draw(QCPPainter *painter);
|
|
|
virtual QSize minimumSizeHint() const;
|
|
|
virtual QSize maximumSizeHint() const;
|
|
|
// events:
|
|
|
virtual void selectEvent(QMouseEvent *event, bool additive, const QVariant &details, bool *selectionStateChanged);
|
|
|
virtual void deselectEvent(bool *selectionStateChanged);
|
|
|
|
|
|
// non-virtual methods:
|
|
|
QFont mainFont() const;
|
|
|
QColor mainTextColor() const;
|
|
|
|
|
|
private:
|
|
|
Q_DISABLE_COPY(QCPPlotTitle)
|
|
|
};
|
|
|
|
|
|
|
|
|
class QCPColorScaleAxisRectPrivate : public QCPAxisRect
|
|
|
{
|
|
|
Q_OBJECT
|
|
|
public:
|
|
|
explicit QCPColorScaleAxisRectPrivate(QCPColorScale *parentColorScale);
|
|
|
protected:
|
|
|
QCPColorScale *mParentColorScale;
|
|
|
QImage mGradientImage;
|
|
|
bool mGradientImageInvalidated;
|
|
|
// re-using some methods of QCPAxisRect to make them available to friend class QCPColorScale
|
|
|
using QCPAxisRect::calculateAutoMargin;
|
|
|
using QCPAxisRect::mousePressEvent;
|
|
|
using QCPAxisRect::mouseMoveEvent;
|
|
|
using QCPAxisRect::mouseReleaseEvent;
|
|
|
using QCPAxisRect::wheelEvent;
|
|
|
using QCPAxisRect::update;
|
|
|
virtual void draw(QCPPainter *painter);
|
|
|
void updateGradientImage();
|
|
|
Q_SLOT void axisSelectionChanged(QCPAxis::SelectableParts selectedParts);
|
|
|
Q_SLOT void axisSelectableChanged(QCPAxis::SelectableParts selectableParts);
|
|
|
friend class QCPColorScale;
|
|
|
};
|
|
|
|
|
|
|
|
|
class QCP_LIB_DECL QCPColorScale : public QCPLayoutElement
|
|
|
{
|
|
|
Q_OBJECT
|
|
|
/// \cond INCLUDE_QPROPERTIES
|
|
|
Q_PROPERTY(QCPAxis::AxisType type READ type WRITE setType)
|
|
|
Q_PROPERTY(QCPRange dataRange READ dataRange WRITE setDataRange NOTIFY dataRangeChanged)
|
|
|
Q_PROPERTY(QCPAxis::ScaleType dataScaleType READ dataScaleType WRITE setDataScaleType NOTIFY dataScaleTypeChanged)
|
|
|
Q_PROPERTY(QCPColorGradient gradient READ gradient WRITE setGradient NOTIFY gradientChanged)
|
|
|
Q_PROPERTY(QString label READ label WRITE setLabel)
|
|
|
Q_PROPERTY(int barWidth READ barWidth WRITE setBarWidth)
|
|
|
Q_PROPERTY(bool rangeDrag READ rangeDrag WRITE setRangeDrag)
|
|
|
Q_PROPERTY(bool rangeZoom READ rangeZoom WRITE setRangeZoom)
|
|
|
/// \endcond
|
|
|
public:
|
|
|
explicit QCPColorScale(QCustomPlot *parentPlot);
|
|
|
virtual ~QCPColorScale();
|
|
|
|
|
|
// getters:
|
|
|
QCPAxis *axis() const { return mColorAxis.data(); }
|
|
|
QCPAxis::AxisType type() const { return mType; }
|
|
|
QCPRange dataRange() const { return mDataRange; }
|
|
|
QCPAxis::ScaleType dataScaleType() const { return mDataScaleType; }
|
|
|
QCPColorGradient gradient() const { return mGradient; }
|
|
|
QString label() const;
|
|
|
int barWidth () const { return mBarWidth; }
|
|
|
bool rangeDrag() const;
|
|
|
bool rangeZoom() const;
|
|
|
|
|
|
// setters:
|
|
|
void setType(QCPAxis::AxisType type);
|
|
|
Q_SLOT void setDataRange(const QCPRange &dataRange);
|
|
|
Q_SLOT void setDataScaleType(QCPAxis::ScaleType scaleType);
|
|
|
Q_SLOT void setGradient(const QCPColorGradient &gradient);
|
|
|
void setLabel(const QString &str);
|
|
|
void setBarWidth(int width);
|
|
|
void setRangeDrag(bool enabled);
|
|
|
void setRangeZoom(bool enabled);
|
|
|
|
|
|
// non-property methods:
|
|
|
QList<QCPColorMap*> colorMaps() const;
|
|
|
void rescaleDataRange(bool onlyVisibleMaps);
|
|
|
|
|
|
// reimplemented virtual methods:
|
|
|
virtual void update(UpdatePhase phase);
|
|
|
|
|
|
signals:
|
|
|
void dataRangeChanged(QCPRange newRange);
|
|
|
void dataScaleTypeChanged(QCPAxis::ScaleType scaleType);
|
|
|
void gradientChanged(QCPColorGradient newGradient);
|
|
|
|
|
|
protected:
|
|
|
// property members:
|
|
|
QCPAxis::AxisType mType;
|
|
|
QCPRange mDataRange;
|
|
|
QCPAxis::ScaleType mDataScaleType;
|
|
|
QCPColorGradient mGradient;
|
|
|
int mBarWidth;
|
|
|
|
|
|
// non-property members:
|
|
|
QPointer<QCPColorScaleAxisRectPrivate> mAxisRect;
|
|
|
QPointer<QCPAxis> mColorAxis;
|
|
|
|
|
|
// reimplemented virtual methods:
|
|
|
virtual void applyDefaultAntialiasingHint(QCPPainter *painter) const;
|
|
|
// events:
|
|
|
virtual void mousePressEvent(QMouseEvent *event);
|
|
|
virtual void mouseMoveEvent(QMouseEvent *event);
|
|
|
virtual void mouseReleaseEvent(QMouseEvent *event);
|
|
|
virtual void wheelEvent(QWheelEvent *event);
|
|
|
|
|
|
private:
|
|
|
Q_DISABLE_COPY(QCPColorScale)
|
|
|
|
|
|
friend class QCPColorScaleAxisRectPrivate;
|
|
|
};
|
|
|
|
|
|
|
|
|
/*! \file */
|
|
|
|
|
|
|
|
|
|
|
|
class QCP_LIB_DECL QCPData
|
|
|
{
|
|
|
public:
|
|
|
QCPData();
|
|
|
QCPData(double key, double value);
|
|
|
double key, value;
|
|
|
double keyErrorPlus, keyErrorMinus;
|
|
|
double valueErrorPlus, valueErrorMinus;
|
|
|
};
|
|
|
Q_DECLARE_TYPEINFO(QCPData, Q_MOVABLE_TYPE);
|
|
|
|
|
|
/*! \typedef QCPDataMap
|
|
|
Container for storing QCPData items in a sorted fashion. The key of the map
|
|
|
is the key member of the QCPData instance.
|
|
|
|
|
|
This is the container in which QCPGraph holds its data.
|
|
|
\see QCPData, QCPGraph::setData
|
|
|
*/
|
|
|
typedef QMap<double, QCPData> QCPDataMap;
|
|
|
typedef QMapIterator<double, QCPData> QCPDataMapIterator;
|
|
|
typedef QMutableMapIterator<double, QCPData> QCPDataMutableMapIterator;
|
|
|
|
|
|
|
|
|
class QCP_LIB_DECL QCPGraph : public QCPAbstractPlottable
|
|
|
{
|
|
|
Q_OBJECT
|
|
|
/// \cond INCLUDE_QPROPERTIES
|
|
|
Q_PROPERTY(LineStyle lineStyle READ lineStyle WRITE setLineStyle)
|
|
|
Q_PROPERTY(QCPScatterStyle scatterStyle READ scatterStyle WRITE setScatterStyle)
|
|
|
Q_PROPERTY(ErrorType errorType READ errorType WRITE setErrorType)
|
|
|
Q_PROPERTY(QPen errorPen READ errorPen WRITE setErrorPen)
|
|
|
Q_PROPERTY(double errorBarSize READ errorBarSize WRITE setErrorBarSize)
|
|
|
Q_PROPERTY(bool errorBarSkipSymbol READ errorBarSkipSymbol WRITE setErrorBarSkipSymbol)
|
|
|
Q_PROPERTY(QCPGraph* channelFillGraph READ channelFillGraph WRITE setChannelFillGraph)
|
|
|
Q_PROPERTY(bool adaptiveSampling READ adaptiveSampling WRITE setAdaptiveSampling)
|
|
|
/// \endcond
|
|
|
public:
|
|
|
/*!
|
|
|
Defines how the graph's line is represented visually in the plot. The line is drawn with the
|
|
|
current pen of the graph (\ref setPen).
|
|
|
\see setLineStyle
|
|
|
*/
|
|
|
enum LineStyle { lsNone ///< data points are not connected with any lines (e.g. data only represented
|
|
|
///< with symbols according to the scatter style, see \ref setScatterStyle)
|
|
|
,lsLine ///< data points are connected by a straight line
|
|
|
,lsStepLeft ///< line is drawn as steps where the step height is the value of the left data point
|
|
|
,lsStepRight ///< line is drawn as steps where the step height is the value of the right data point
|
|
|
,lsStepCenter ///< line is drawn as steps where the step is in between two data points
|
|
|
,lsImpulse ///< each data point is represented by a line parallel to the value axis, which reaches from the data point to the zero-value-line
|
|
|
};
|
|
|
Q_ENUMS(LineStyle)
|
|
|
/*!
|
|
|
Defines what kind of error bars are drawn for each data point
|
|
|
*/
|
|
|
enum ErrorType { etNone ///< No error bars are shown
|
|
|
,etKey ///< Error bars for the key dimension of the data point are shown
|
|
|
,etValue ///< Error bars for the value dimension of the data point are shown
|
|
|
,etBoth ///< Error bars for both key and value dimensions of the data point are shown
|
|
|
};
|
|
|
Q_ENUMS(ErrorType)
|
|
|
|
|
|
explicit QCPGraph(QCPAxis *keyAxis, QCPAxis *valueAxis);
|
|
|
virtual ~QCPGraph();
|
|
|
|
|
|
// getters:
|
|
|
QCPDataMap *data() const { return mData; }
|
|
|
LineStyle lineStyle() const { return mLineStyle; }
|
|
|
QCPScatterStyle scatterStyle() const { return mScatterStyle; }
|
|
|
ErrorType errorType() const { return mErrorType; }
|
|
|
QPen errorPen() const { return mErrorPen; }
|
|
|
double errorBarSize() const { return mErrorBarSize; }
|
|
|
bool errorBarSkipSymbol() const { return mErrorBarSkipSymbol; }
|
|
|
QCPGraph *channelFillGraph() const { return mChannelFillGraph.data(); }
|
|
|
bool adaptiveSampling() const { return mAdaptiveSampling; }
|
|
|
|
|
|
// setters:
|
|
|
void setData(QCPDataMap *data, bool copy=false);
|
|
|
void setData(const QVector<double> &key, const QVector<double> &value);
|
|
|
void setDataKeyError(const QVector<double> &key, const QVector<double> &value, const QVector<double> &keyError);
|
|
|
void setDataKeyError(const QVector<double> &key, const QVector<double> &value, const QVector<double> &keyErrorMinus, const QVector<double> &keyErrorPlus);
|
|
|
void setDataValueError(const QVector<double> &key, const QVector<double> &value, const QVector<double> &valueError);
|
|
|
void setDataValueError(const QVector<double> &key, const QVector<double> &value, const QVector<double> &valueErrorMinus, const QVector<double> &valueErrorPlus);
|
|
|
void setDataBothError(const QVector<double> &key, const QVector<double> &value, const QVector<double> &keyError, const QVector<double> &valueError);
|
|
|
void setDataBothError(const QVector<double> &key, const QVector<double> &value, const QVector<double> &keyErrorMinus, const QVector<double> &keyErrorPlus, const QVector<double> &valueErrorMinus, const QVector<double> &valueErrorPlus);
|
|
|
void setLineStyle(LineStyle ls);
|
|
|
void setScatterStyle(const QCPScatterStyle &style);
|
|
|
void setErrorType(ErrorType errorType);
|
|
|
void setErrorPen(const QPen &pen);
|
|
|
void setErrorBarSize(double size);
|
|
|
void setErrorBarSkipSymbol(bool enabled);
|
|
|
void setChannelFillGraph(QCPGraph *targetGraph);
|
|
|
void setAdaptiveSampling(bool enabled);
|
|
|
|
|
|
// non-property methods:
|
|
|
void addData(const QCPDataMap &dataMap);
|
|
|
void addData(const QCPData &data);
|
|
|
void addData(double key, double value);
|
|
|
void addData(const QVector<double> &keys, const QVector<double> &values);
|
|
|
void removeDataBefore(double key);
|
|
|
void removeDataAfter(double key);
|
|
|
void removeData(double fromKey, double toKey);
|
|
|
void removeData(double key);
|
|
|
|
|
|
// reimplemented virtual methods:
|
|
|
virtual void clearData();
|
|
|
virtual double selectTest(const QPointF &pos, bool onlySelectable, QVariant *details=0) const;
|
|
|
using QCPAbstractPlottable::rescaleAxes;
|
|
|
using QCPAbstractPlottable::rescaleKeyAxis;
|
|
|
using QCPAbstractPlottable::rescaleValueAxis;
|
|
|
void rescaleAxes(bool onlyEnlarge, bool includeErrorBars) const; // overloads base class interface
|
|
|
void rescaleKeyAxis(bool onlyEnlarge, bool includeErrorBars) const; // overloads base class interface
|
|
|
void rescaleValueAxis(bool onlyEnlarge, bool includeErrorBars) const; // overloads base class interface
|
|
|
|
|
|
protected:
|
|
|
// property members:
|
|
|
QCPDataMap *mData;
|
|
|
QPen mErrorPen;
|
|
|
LineStyle mLineStyle;
|
|
|
QCPScatterStyle mScatterStyle;
|
|
|
ErrorType mErrorType;
|
|
|
double mErrorBarSize;
|
|
|
bool mErrorBarSkipSymbol;
|
|
|
QPointer<QCPGraph> mChannelFillGraph;
|
|
|
bool mAdaptiveSampling;
|
|
|
|
|
|
// reimplemented virtual methods:
|
|
|
virtual void draw(QCPPainter *painter);
|
|
|
virtual void drawLegendIcon(QCPPainter *painter, const QRectF &rect) const;
|
|
|
virtual QCPRange getKeyRange(bool &foundRange, SignDomain inSignDomain=sdBoth) const;
|
|
|
virtual QCPRange getValueRange(bool &foundRange, SignDomain inSignDomain=sdBoth) const;
|
|
|
virtual QCPRange getKeyRange(bool &foundRange, SignDomain inSignDomain, bool includeErrors) const; // overloads base class interface
|
|
|
virtual QCPRange getValueRange(bool &foundRange, SignDomain inSignDomain, bool includeErrors) const; // overloads base class interface
|
|
|
|
|
|
// introduced virtual methods:
|
|
|
virtual void drawFill(QCPPainter *painter, QVector<QPointF> *lineData) const;
|
|
|
virtual void drawScatterPlot(QCPPainter *painter, QVector<QCPData> *scatterData) const;
|
|
|
virtual void drawLinePlot(QCPPainter *painter, QVector<QPointF> *lineData) const;
|
|
|
virtual void drawImpulsePlot(QCPPainter *painter, QVector<QPointF> *lineData) const;
|
|
|
|
|
|
// non-virtual methods:
|
|
|
void getPreparedData(QVector<QCPData> *lineData, QVector<QCPData> *scatterData) const;
|
|
|
void getPlotData(QVector<QPointF> *lineData, QVector<QCPData> *scatterData) const;
|
|
|
void getScatterPlotData(QVector<QCPData> *scatterData) const;
|
|
|
void getLinePlotData(QVector<QPointF> *linePixelData, QVector<QCPData> *scatterData) const;
|
|
|
void getStepLeftPlotData(QVector<QPointF> *linePixelData, QVector<QCPData> *scatterData) const;
|
|
|
void getStepRightPlotData(QVector<QPointF> *linePixelData, QVector<QCPData> *scatterData) const;
|
|
|
void getStepCenterPlotData(QVector<QPointF> *linePixelData, QVector<QCPData> *scatterData) const;
|
|
|
void getImpulsePlotData(QVector<QPointF> *linePixelData, QVector<QCPData> *scatterData) const;
|
|
|
void drawError(QCPPainter *painter, double x, double y, const QCPData &data) const;
|
|
|
void getVisibleDataBounds(QCPDataMap::const_iterator &lower, QCPDataMap::const_iterator &upper) const;
|
|
|
int countDataInBounds(const QCPDataMap::const_iterator &lower, const QCPDataMap::const_iterator &upper, int maxCount) const;
|
|
|
void addFillBasePoints(QVector<QPointF> *lineData) const;
|
|
|
void removeFillBasePoints(QVector<QPointF> *lineData) const;
|
|
|
QPointF lowerFillBasePoint(double lowerKey) const;
|
|
|
QPointF upperFillBasePoint(double upperKey) const;
|
|
|
const QPolygonF getChannelFillPolygon(const QVector<QPointF> *lineData) const;
|
|
|
int findIndexBelowX(const QVector<QPointF> *data, double x) const;
|
|
|
int findIndexAboveX(const QVector<QPointF> *data, double x) const;
|
|
|
int findIndexBelowY(const QVector<QPointF> *data, double y) const;
|
|
|
int findIndexAboveY(const QVector<QPointF> *data, double y) const;
|
|
|
double pointDistance(const QPointF &pixelPoint) const;
|
|
|
|
|
|
friend class QCustomPlot;
|
|
|
friend class QCPLegend;
|
|
|
};
|
|
|
|
|
|
|
|
|
/*! \file */
|
|
|
|
|
|
|
|
|
|
|
|
class QCP_LIB_DECL QCPCurveData
|
|
|
{
|
|
|
public:
|
|
|
QCPCurveData();
|
|
|
QCPCurveData(double t, double key, double value);
|
|
|
double t, key, value;
|
|
|
};
|
|
|
Q_DECLARE_TYPEINFO(QCPCurveData, Q_MOVABLE_TYPE);
|
|
|
|
|
|
/*! \typedef QCPCurveDataMap
|
|
|
Container for storing QCPCurveData items in a sorted fashion. The key of the map
|
|
|
is the t member of the QCPCurveData instance.
|
|
|
|
|
|
This is the container in which QCPCurve holds its data.
|
|
|
\see QCPCurveData, QCPCurve::setData
|
|
|
*/
|
|
|
|
|
|
typedef QMap<double, QCPCurveData> QCPCurveDataMap;
|
|
|
typedef QMapIterator<double, QCPCurveData> QCPCurveDataMapIterator;
|
|
|
typedef QMutableMapIterator<double, QCPCurveData> QCPCurveDataMutableMapIterator;
|
|
|
|
|
|
|
|
|
class QCP_LIB_DECL QCPCurve : public QCPAbstractPlottable
|
|
|
{
|
|
|
Q_OBJECT
|
|
|
/// \cond INCLUDE_QPROPERTIES
|
|
|
Q_PROPERTY(QCPScatterStyle scatterStyle READ scatterStyle WRITE setScatterStyle)
|
|
|
Q_PROPERTY(LineStyle lineStyle READ lineStyle WRITE setLineStyle)
|
|
|
/// \endcond
|
|
|
public:
|
|
|
/*!
|
|
|
Defines how the curve's line is represented visually in the plot. The line is drawn with the
|
|
|
current pen of the curve (\ref setPen).
|
|
|
\see setLineStyle
|
|
|
*/
|
|
|
enum LineStyle { lsNone ///< No line is drawn between data points (e.g. only scatters)
|
|
|
,lsLine ///< Data points are connected with a straight line
|
|
|
};
|
|
|
explicit QCPCurve(QCPAxis *keyAxis, QCPAxis *valueAxis);
|
|
|
virtual ~QCPCurve();
|
|
|
|
|
|
// getters:
|
|
|
QCPCurveDataMap *data() const { return mData; }
|
|
|
QCPScatterStyle scatterStyle() const { return mScatterStyle; }
|
|
|
LineStyle lineStyle() const { return mLineStyle; }
|
|
|
|
|
|
// setters:
|
|
|
void setData(QCPCurveDataMap *data, bool copy=false);
|
|
|
void setData(const QVector<double> &t, const QVector<double> &key, const QVector<double> &value);
|
|
|
void setData(const QVector<double> &key, const QVector<double> &value);
|
|
|
void setScatterStyle(const QCPScatterStyle &style);
|
|
|
void setLineStyle(LineStyle style);
|
|
|
|
|
|
// non-property methods:
|
|
|
void addData(const QCPCurveDataMap &dataMap);
|
|
|
void addData(const QCPCurveData &data);
|
|
|
void addData(double t, double key, double value);
|
|
|
void addData(double key, double value);
|
|
|
void addData(const QVector<double> &ts, const QVector<double> &keys, const QVector<double> &values);
|
|
|
void removeDataBefore(double t);
|
|
|
void removeDataAfter(double t);
|
|
|
void removeData(double fromt, double tot);
|
|
|
void removeData(double t);
|
|
|
|
|
|
// reimplemented virtual methods:
|
|
|
virtual void clearData();
|
|
|
virtual double selectTest(const QPointF &pos, bool onlySelectable, QVariant *details=0) const;
|
|
|
|
|
|
protected:
|
|
|
// property members:
|
|
|
QCPCurveDataMap *mData;
|
|
|
QCPScatterStyle mScatterStyle;
|
|
|
LineStyle mLineStyle;
|
|
|
|
|
|
// reimplemented virtual methods:
|
|
|
virtual void draw(QCPPainter *painter);
|
|
|
virtual void drawLegendIcon(QCPPainter *painter, const QRectF &rect) const;
|
|
|
virtual QCPRange getKeyRange(bool &foundRange, SignDomain inSignDomain=sdBoth) const;
|
|
|
virtual QCPRange getValueRange(bool &foundRange, SignDomain inSignDomain=sdBoth) const;
|
|
|
|
|
|
// introduced virtual methods:
|
|
|
virtual void drawScatterPlot(QCPPainter *painter, const QVector<QPointF> *pointData) const;
|
|
|
|
|
|
// non-virtual methods:
|
|
|
void getCurveData(QVector<QPointF> *lineData) const;
|
|
|
double pointDistance(const QPointF &pixelPoint) const;
|
|
|
QPointF outsideCoordsToPixels(double key, double value, int region, QRect axisRect) const;
|
|
|
|
|
|
friend class QCustomPlot;
|
|
|
friend class QCPLegend;
|
|
|
};
|
|
|
|
|
|
|
|
|
/*! \file */
|
|
|
|
|
|
|
|
|
|
|
|
class QCP_LIB_DECL QCPBarData
|
|
|
{
|
|
|
public:
|
|
|
QCPBarData();
|
|
|
QCPBarData(double key, double value);
|
|
|
double key, value;
|
|
|
};
|
|
|
Q_DECLARE_TYPEINFO(QCPBarData, Q_MOVABLE_TYPE);
|
|
|
|
|
|
/*! \typedef QCPBarDataMap
|
|
|
Container for storing QCPBarData items in a sorted fashion. The key of the map
|
|
|
is the key member of the QCPBarData instance.
|
|
|
|
|
|
This is the container in which QCPBars holds its data.
|
|
|
\see QCPBarData, QCPBars::setData
|
|
|
*/
|
|
|
typedef QMap<double, QCPBarData> QCPBarDataMap;
|
|
|
typedef QMapIterator<double, QCPBarData> QCPBarDataMapIterator;
|
|
|
typedef QMutableMapIterator<double, QCPBarData> QCPBarDataMutableMapIterator;
|
|
|
|
|
|
|
|
|
class QCP_LIB_DECL QCPBars : public QCPAbstractPlottable
|
|
|
{
|
|
|
Q_OBJECT
|
|
|
/// \cond INCLUDE_QPROPERTIES
|
|
|
Q_PROPERTY(double width READ width WRITE setWidth)
|
|
|
Q_PROPERTY(QCPBars* barBelow READ barBelow)
|
|
|
Q_PROPERTY(QCPBars* barAbove READ barAbove)
|
|
|
/// \endcond
|
|
|
public:
|
|
|
explicit QCPBars(QCPAxis *keyAxis, QCPAxis *valueAxis);
|
|
|
virtual ~QCPBars();
|
|
|
|
|
|
// getters:
|
|
|
double width() const { return mWidth; }
|
|
|
QCPBars *barBelow() const { return mBarBelow.data(); }
|
|
|
QCPBars *barAbove() const { return mBarAbove.data(); }
|
|
|
QCPBarDataMap *data() const { return mData; }
|
|
|
|
|
|
// setters:
|
|
|
void setWidth(double width);
|
|
|
void setData(QCPBarDataMap *data, bool copy=false);
|
|
|
void setData(const QVector<double> &key, const QVector<double> &value);
|
|
|
|
|
|
// non-property methods:
|
|
|
void moveBelow(QCPBars *bars);
|
|
|
void moveAbove(QCPBars *bars);
|
|
|
void addData(const QCPBarDataMap &dataMap);
|
|
|
void addData(const QCPBarData &data);
|
|
|
void addData(double key, double value);
|
|
|
void addData(const QVector<double> &keys, const QVector<double> &values);
|
|
|
void removeDataBefore(double key);
|
|
|
void removeDataAfter(double key);
|
|
|
void removeData(double fromKey, double toKey);
|
|
|
void removeData(double key);
|
|
|
|
|
|
// reimplemented virtual methods:
|
|
|
virtual void clearData();
|
|
|
virtual double selectTest(const QPointF &pos, bool onlySelectable, QVariant *details=0) const;
|
|
|
|
|
|
protected:
|
|
|
// property members:
|
|
|
QCPBarDataMap *mData;
|
|
|
double mWidth;
|
|
|
QPointer<QCPBars> mBarBelow, mBarAbove;
|
|
|
|
|
|
// reimplemented virtual methods:
|
|
|
virtual void draw(QCPPainter *painter);
|
|
|
virtual void drawLegendIcon(QCPPainter *painter, const QRectF &rect) const;
|
|
|
virtual QCPRange getKeyRange(bool &foundRange, SignDomain inSignDomain=sdBoth) const;
|
|
|
virtual QCPRange getValueRange(bool &foundRange, SignDomain inSignDomain=sdBoth) const;
|
|
|
|
|
|
// non-virtual methods:
|
|
|
QPolygonF getBarPolygon(double key, double value) const;
|
|
|
double getBaseValue(double key, bool positive) const;
|
|
|
static void connectBars(QCPBars* lower, QCPBars* upper);
|
|
|
|
|
|
friend class QCustomPlot;
|
|
|
friend class QCPLegend;
|
|
|
};
|
|
|
|
|
|
|
|
|
/*! \file */
|
|
|
|
|
|
|
|
|
|
|
|
class QCP_LIB_DECL QCPStatisticalBox : public QCPAbstractPlottable
|
|
|
{
|
|
|
Q_OBJECT
|
|
|
/// \cond INCLUDE_QPROPERTIES
|
|
|
Q_PROPERTY(double key READ key WRITE setKey)
|
|
|
Q_PROPERTY(double minimum READ minimum WRITE setMinimum)
|
|
|
Q_PROPERTY(double lowerQuartile READ lowerQuartile WRITE setLowerQuartile)
|
|
|
Q_PROPERTY(double median READ median WRITE setMedian)
|
|
|
Q_PROPERTY(double upperQuartile READ upperQuartile WRITE setUpperQuartile)
|
|
|
Q_PROPERTY(double maximum READ maximum WRITE setMaximum)
|
|
|
Q_PROPERTY(QVector<double> outliers READ outliers WRITE setOutliers)
|
|
|
Q_PROPERTY(double width READ width WRITE setWidth)
|
|
|
Q_PROPERTY(double whiskerWidth READ whiskerWidth WRITE setWhiskerWidth)
|
|
|
Q_PROPERTY(QPen whiskerPen READ whiskerPen WRITE setWhiskerPen)
|
|
|
Q_PROPERTY(QPen whiskerBarPen READ whiskerBarPen WRITE setWhiskerBarPen)
|
|
|
Q_PROPERTY(QPen medianPen READ medianPen WRITE setMedianPen)
|
|
|
Q_PROPERTY(QCPScatterStyle outlierStyle READ outlierStyle WRITE setOutlierStyle)
|
|
|
/// \endcond
|
|
|
public:
|
|
|
explicit QCPStatisticalBox(QCPAxis *keyAxis, QCPAxis *valueAxis);
|
|
|
|
|
|
// getters:
|
|
|
double key() const { return mKey; }
|
|
|
double minimum() const { return mMinimum; }
|
|
|
double lowerQuartile() const { return mLowerQuartile; }
|
|
|
double median() const { return mMedian; }
|
|
|
double upperQuartile() const { return mUpperQuartile; }
|
|
|
double maximum() const { return mMaximum; }
|
|
|
QVector<double> outliers() const { return mOutliers; }
|
|
|
double width() const { return mWidth; }
|
|
|
double whiskerWidth() const { return mWhiskerWidth; }
|
|
|
QPen whiskerPen() const { return mWhiskerPen; }
|
|
|
QPen whiskerBarPen() const { return mWhiskerBarPen; }
|
|
|
QPen medianPen() const { return mMedianPen; }
|
|
|
QCPScatterStyle outlierStyle() const { return mOutlierStyle; }
|
|
|
|
|
|
// setters:
|
|
|
void setKey(double key);
|
|
|
void setMinimum(double value);
|
|
|
void setLowerQuartile(double value);
|
|
|
void setMedian(double value);
|
|
|
void setUpperQuartile(double value);
|
|
|
void setMaximum(double value);
|
|
|
void setOutliers(const QVector<double> &values);
|
|
|
void setData(double key, double minimum, double lowerQuartile, double median, double upperQuartile, double maximum);
|
|
|
void setWidth(double width);
|
|
|
void setWhiskerWidth(double width);
|
|
|
void setWhiskerPen(const QPen &pen);
|
|
|
void setWhiskerBarPen(const QPen &pen);
|
|
|
void setMedianPen(const QPen &pen);
|
|
|
void setOutlierStyle(const QCPScatterStyle &style);
|
|
|
|
|
|
// non-property methods:
|
|
|
virtual void clearData();
|
|
|
virtual double selectTest(const QPointF &pos, bool onlySelectable, QVariant *details=0) const;
|
|
|
|
|
|
protected:
|
|
|
// property members:
|
|
|
QVector<double> mOutliers;
|
|
|
double mKey, mMinimum, mLowerQuartile, mMedian, mUpperQuartile, mMaximum;
|
|
|
double mWidth;
|
|
|
double mWhiskerWidth;
|
|
|
QPen mWhiskerPen, mWhiskerBarPen, mMedianPen;
|
|
|
QCPScatterStyle mOutlierStyle;
|
|
|
|
|
|
// reimplemented virtual methods:
|
|
|
virtual void draw(QCPPainter *painter);
|
|
|
virtual void drawLegendIcon(QCPPainter *painter, const QRectF &rect) const;
|
|
|
virtual QCPRange getKeyRange(bool &foundRange, SignDomain inSignDomain=sdBoth) const;
|
|
|
virtual QCPRange getValueRange(bool &foundRange, SignDomain inSignDomain=sdBoth) const;
|
|
|
|
|
|
// introduced virtual methods:
|
|
|
virtual void drawQuartileBox(QCPPainter *painter, QRectF *quartileBox=0) const;
|
|
|
virtual void drawMedian(QCPPainter *painter) const;
|
|
|
virtual void drawWhiskers(QCPPainter *painter) const;
|
|
|
virtual void drawOutliers(QCPPainter *painter) const;
|
|
|
|
|
|
friend class QCustomPlot;
|
|
|
friend class QCPLegend;
|
|
|
};
|
|
|
|
|
|
|
|
|
class QCP_LIB_DECL QCPColorMapData
|
|
|
{
|
|
|
public:
|
|
|
QCPColorMapData(int keySize, int valueSize, const QCPRange &keyRange, const QCPRange &valueRange);
|
|
|
~QCPColorMapData();
|
|
|
QCPColorMapData(const QCPColorMapData &other);
|
|
|
QCPColorMapData &operator=(const QCPColorMapData &other);
|
|
|
|
|
|
// getters:
|
|
|
int keySize() const { return mKeySize; }
|
|
|
int valueSize() const { return mValueSize; }
|
|
|
QCPRange keyRange() const { return mKeyRange; }
|
|
|
QCPRange valueRange() const { return mValueRange; }
|
|
|
QCPRange dataBounds() const { return mDataBounds; }
|
|
|
double data(double key, double value);
|
|
|
double cell(int keyIndex, int valueIndex);
|
|
|
|
|
|
// setters:
|
|
|
void setSize(int keySize, int valueSize);
|
|
|
void setKeySize(int keySize);
|
|
|
void setValueSize(int valueSize);
|
|
|
void setRange(const QCPRange &keyRange, const QCPRange &valueRange);
|
|
|
void setKeyRange(const QCPRange &keyRange);
|
|
|
void setValueRange(const QCPRange &valueRange);
|
|
|
void setData(double key, double value, double z);
|
|
|
void setCell(int keyIndex, int valueIndex, double z);
|
|
|
|
|
|
// non-property methods:
|
|
|
void recalculateDataBounds();
|
|
|
void clear();
|
|
|
void fill(double z);
|
|
|
bool isEmpty() const { return mIsEmpty; }
|
|
|
void coordToCell(double key, double value, int *keyIndex, int *valueIndex) const;
|
|
|
void cellToCoord(int keyIndex, int valueIndex, double *key, double *value) const;
|
|
|
|
|
|
protected:
|
|
|
// property members:
|
|
|
int mKeySize, mValueSize;
|
|
|
QCPRange mKeyRange, mValueRange;
|
|
|
bool mIsEmpty;
|
|
|
// non-property members:
|
|
|
double *mData;
|
|
|
QCPRange mDataBounds;
|
|
|
bool mDataModified;
|
|
|
|
|
|
friend class QCPColorMap;
|
|
|
};
|
|
|
|
|
|
|
|
|
class QCP_LIB_DECL QCPColorMap : public QCPAbstractPlottable
|
|
|
{
|
|
|
Q_OBJECT
|
|
|
/// \cond INCLUDE_QPROPERTIES
|
|
|
Q_PROPERTY(QCPRange dataRange READ dataRange WRITE setDataRange NOTIFY dataRangeChanged)
|
|
|
Q_PROPERTY(QCPAxis::ScaleType dataScaleType READ dataScaleType WRITE setDataScaleType NOTIFY dataScaleTypeChanged)
|
|
|
Q_PROPERTY(QCPColorGradient gradient READ gradient WRITE setGradient NOTIFY gradientChanged)
|
|
|
Q_PROPERTY(bool interpolate READ interpolate WRITE setInterpolate)
|
|
|
Q_PROPERTY(bool tightBoundary READ tightBoundary WRITE setTightBoundary)
|
|
|
Q_PROPERTY(QCPColorScale* colorScale READ colorScale WRITE setColorScale)
|
|
|
/// \endcond
|
|
|
public:
|
|
|
explicit QCPColorMap(QCPAxis *keyAxis, QCPAxis *valueAxis);
|
|
|
virtual ~QCPColorMap();
|
|
|
|
|
|
// getters:
|
|
|
QCPColorMapData *data() const { return mMapData; }
|
|
|
QCPRange dataRange() const { return mDataRange; }
|
|
|
QCPAxis::ScaleType dataScaleType() const { return mDataScaleType; }
|
|
|
bool interpolate() const { return mInterpolate; }
|
|
|
bool tightBoundary() const { return mTightBoundary; }
|
|
|
QCPColorGradient gradient() const { return mGradient; }
|
|
|
QCPColorScale *colorScale() const { return mColorScale.data(); }
|
|
|
|
|
|
// setters:
|
|
|
void setData(QCPColorMapData *data, bool copy=false);
|
|
|
Q_SLOT void setDataRange(const QCPRange &dataRange);
|
|
|
Q_SLOT void setDataScaleType(QCPAxis::ScaleType scaleType);
|
|
|
Q_SLOT void setGradient(const QCPColorGradient &gradient);
|
|
|
void setInterpolate(bool enabled);
|
|
|
void setTightBoundary(bool enabled);
|
|
|
void setColorScale(QCPColorScale *colorScale);
|
|
|
|
|
|
// non-property methods:
|
|
|
void rescaleDataRange(bool recalculateDataBounds=false);
|
|
|
Q_SLOT void updateLegendIcon(Qt::TransformationMode transformMode=Qt::SmoothTransformation, const QSize &thumbSize=QSize(32, 18));
|
|
|
|
|
|
// reimplemented virtual methods:
|
|
|
virtual void clearData();
|
|
|
virtual double selectTest(const QPointF &pos, bool onlySelectable, QVariant *details=0) const;
|
|
|
|
|
|
signals:
|
|
|
void dataRangeChanged(QCPRange newRange);
|
|
|
void dataScaleTypeChanged(QCPAxis::ScaleType scaleType);
|
|
|
void gradientChanged(QCPColorGradient newGradient);
|
|
|
|
|
|
protected:
|
|
|
// property members:
|
|
|
QCPRange mDataRange;
|
|
|
QCPAxis::ScaleType mDataScaleType;
|
|
|
QCPColorMapData *mMapData;
|
|
|
QCPColorGradient mGradient;
|
|
|
bool mInterpolate;
|
|
|
bool mTightBoundary;
|
|
|
QPointer<QCPColorScale> mColorScale;
|
|
|
// non-property members:
|
|
|
QImage mMapImage;
|
|
|
QPixmap mLegendIcon;
|
|
|
bool mMapImageInvalidated;
|
|
|
|
|
|
// introduced virtual methods:
|
|
|
virtual void updateMapImage();
|
|
|
|
|
|
// reimplemented virtual methods:
|
|
|
virtual void draw(QCPPainter *painter);
|
|
|
virtual void drawLegendIcon(QCPPainter *painter, const QRectF &rect) const;
|
|
|
virtual QCPRange getKeyRange(bool &foundRange, SignDomain inSignDomain=sdBoth) const;
|
|
|
virtual QCPRange getValueRange(bool &foundRange, SignDomain inSignDomain=sdBoth) const;
|
|
|
|
|
|
friend class QCustomPlot;
|
|
|
friend class QCPLegend;
|
|
|
};
|
|
|
|
|
|
|
|
|
class QCP_LIB_DECL QCPItemStraightLine : public QCPAbstractItem
|
|
|
{
|
|
|
Q_OBJECT
|
|
|
/// \cond INCLUDE_QPROPERTIES
|
|
|
Q_PROPERTY(QPen pen READ pen WRITE setPen)
|
|
|
Q_PROPERTY(QPen selectedPen READ selectedPen WRITE setSelectedPen)
|
|
|
/// \endcond
|
|
|
public:
|
|
|
QCPItemStraightLine(QCustomPlot *parentPlot);
|
|
|
virtual ~QCPItemStraightLine();
|
|
|
|
|
|
// getters:
|
|
|
QPen pen() const { return mPen; }
|
|
|
QPen selectedPen() const { return mSelectedPen; }
|
|
|
|
|
|
// setters;
|
|
|
void setPen(const QPen &pen);
|
|
|
void setSelectedPen(const QPen &pen);
|
|
|
|
|
|
// reimplemented virtual methods:
|
|
|
virtual double selectTest(const QPointF &pos, bool onlySelectable, QVariant *details=0) const;
|
|
|
|
|
|
QCPItemPosition * const point1;
|
|
|
QCPItemPosition * const point2;
|
|
|
|
|
|
protected:
|
|
|
// property members:
|
|
|
QPen mPen, mSelectedPen;
|
|
|
|
|
|
// reimplemented virtual methods:
|
|
|
virtual void draw(QCPPainter *painter);
|
|
|
|
|
|
// non-virtual methods:
|
|
|
double distToStraightLine(const QVector2D &point1, const QVector2D &vec, const QVector2D &point) const;
|
|
|
QLineF getRectClippedStraightLine(const QVector2D &point1, const QVector2D &vec, const QRect &rect) const;
|
|
|
QPen mainPen() const;
|
|
|
};
|
|
|
|
|
|
|
|
|
class QCP_LIB_DECL QCPItemLine : public QCPAbstractItem
|
|
|
{
|
|
|
Q_OBJECT
|
|
|
/// \cond INCLUDE_QPROPERTIES
|
|
|
Q_PROPERTY(QPen pen READ pen WRITE setPen)
|
|
|
Q_PROPERTY(QPen selectedPen READ selectedPen WRITE setSelectedPen)
|
|
|
Q_PROPERTY(QCPLineEnding head READ head WRITE setHead)
|
|
|
Q_PROPERTY(QCPLineEnding tail READ tail WRITE setTail)
|
|
|
/// \endcond
|
|
|
public:
|
|
|
QCPItemLine(QCustomPlot *parentPlot);
|
|
|
virtual ~QCPItemLine();
|
|
|
|
|
|
// getters:
|
|
|
QPen pen() const { return mPen; }
|
|
|
QPen selectedPen() const { return mSelectedPen; }
|
|
|
QCPLineEnding head() const { return mHead; }
|
|
|
QCPLineEnding tail() const { return mTail; }
|
|
|
|
|
|
// setters;
|
|
|
void setPen(const QPen &pen);
|
|
|
void setSelectedPen(const QPen &pen);
|
|
|
void setHead(const QCPLineEnding &head);
|
|
|
void setTail(const QCPLineEnding &tail);
|
|
|
|
|
|
// reimplemented virtual methods:
|
|
|
virtual double selectTest(const QPointF &pos, bool onlySelectable, QVariant *details=0) const;
|
|
|
|
|
|
QCPItemPosition * const start;
|
|
|
QCPItemPosition * const end;
|
|
|
|
|
|
protected:
|
|
|
// property members:
|
|
|
QPen mPen, mSelectedPen;
|
|
|
QCPLineEnding mHead, mTail;
|
|
|
|
|
|
// reimplemented virtual methods:
|
|
|
virtual void draw(QCPPainter *painter);
|
|
|
|
|
|
// non-virtual methods:
|
|
|
QLineF getRectClippedLine(const QVector2D &start, const QVector2D &end, const QRect &rect) const;
|
|
|
QPen mainPen() const;
|
|
|
};
|
|
|
|
|
|
|
|
|
class QCP_LIB_DECL QCPItemCurve : public QCPAbstractItem
|
|
|
{
|
|
|
Q_OBJECT
|
|
|
/// \cond INCLUDE_QPROPERTIES
|
|
|
Q_PROPERTY(QPen pen READ pen WRITE setPen)
|
|
|
Q_PROPERTY(QPen selectedPen READ selectedPen WRITE setSelectedPen)
|
|
|
Q_PROPERTY(QCPLineEnding head READ head WRITE setHead)
|
|
|
Q_PROPERTY(QCPLineEnding tail READ tail WRITE setTail)
|
|
|
/// \endcond
|
|
|
public:
|
|
|
QCPItemCurve(QCustomPlot *parentPlot);
|
|
|
virtual ~QCPItemCurve();
|
|
|
|
|
|
// getters:
|
|
|
QPen pen() const { return mPen; }
|
|
|
QPen selectedPen() const { return mSelectedPen; }
|
|
|
QCPLineEnding head() const { return mHead; }
|
|
|
QCPLineEnding tail() const { return mTail; }
|
|
|
|
|
|
// setters;
|
|
|
void setPen(const QPen &pen);
|
|
|
void setSelectedPen(const QPen &pen);
|
|
|
void setHead(const QCPLineEnding &head);
|
|
|
void setTail(const QCPLineEnding &tail);
|
|
|
|
|
|
// reimplemented virtual methods:
|
|
|
virtual double selectTest(const QPointF &pos, bool onlySelectable, QVariant *details=0) const;
|
|
|
|
|
|
QCPItemPosition * const start;
|
|
|
QCPItemPosition * const startDir;
|
|
|
QCPItemPosition * const endDir;
|
|
|
QCPItemPosition * const end;
|
|
|
|
|
|
protected:
|
|
|
// property members:
|
|
|
QPen mPen, mSelectedPen;
|
|
|
QCPLineEnding mHead, mTail;
|
|
|
|
|
|
// reimplemented virtual methods:
|
|
|
virtual void draw(QCPPainter *painter);
|
|
|
|
|
|
// non-virtual methods:
|
|
|
QPen mainPen() const;
|
|
|
};
|
|
|
|
|
|
|
|
|
class QCP_LIB_DECL QCPItemRect : public QCPAbstractItem
|
|
|
{
|
|
|
Q_OBJECT
|
|
|
/// \cond INCLUDE_QPROPERTIES
|
|
|
Q_PROPERTY(QPen pen READ pen WRITE setPen)
|
|
|
Q_PROPERTY(QPen selectedPen READ selectedPen WRITE setSelectedPen)
|
|
|
Q_PROPERTY(QBrush brush READ brush WRITE setBrush)
|
|
|
Q_PROPERTY(QBrush selectedBrush READ selectedBrush WRITE setSelectedBrush)
|
|
|
/// \endcond
|
|
|
public:
|
|
|
QCPItemRect(QCustomPlot *parentPlot);
|
|
|
virtual ~QCPItemRect();
|
|
|
|
|
|
// getters:
|
|
|
QPen pen() const { return mPen; }
|
|
|
QPen selectedPen() const { return mSelectedPen; }
|
|
|
QBrush brush() const { return mBrush; }
|
|
|
QBrush selectedBrush() const { return mSelectedBrush; }
|
|
|
|
|
|
// setters;
|
|
|
void setPen(const QPen &pen);
|
|
|
void setSelectedPen(const QPen &pen);
|
|
|
void setBrush(const QBrush &brush);
|
|
|
void setSelectedBrush(const QBrush &brush);
|
|
|
|
|
|
// reimplemented virtual methods:
|
|
|
virtual double selectTest(const QPointF &pos, bool onlySelectable, QVariant *details=0) const;
|
|
|
|
|
|
QCPItemPosition * const topLeft;
|
|
|
QCPItemPosition * const bottomRight;
|
|
|
QCPItemAnchor * const top;
|
|
|
QCPItemAnchor * const topRight;
|
|
|
QCPItemAnchor * const right;
|
|
|
QCPItemAnchor * const bottom;
|
|
|
QCPItemAnchor * const bottomLeft;
|
|
|
QCPItemAnchor * const left;
|
|
|
|
|
|
protected:
|
|
|
enum AnchorIndex {aiTop, aiTopRight, aiRight, aiBottom, aiBottomLeft, aiLeft};
|
|
|
|
|
|
// property members:
|
|
|
QPen mPen, mSelectedPen;
|
|
|
QBrush mBrush, mSelectedBrush;
|
|
|
|
|
|
// reimplemented virtual methods:
|
|
|
virtual void draw(QCPPainter *painter);
|
|
|
virtual QPointF anchorPixelPoint(int anchorId) const;
|
|
|
|
|
|
// non-virtual methods:
|
|
|
QPen mainPen() const;
|
|
|
QBrush mainBrush() const;
|
|
|
};
|
|
|
|
|
|
|
|
|
class QCP_LIB_DECL QCPItemText : public QCPAbstractItem
|
|
|
{
|
|
|
Q_OBJECT
|
|
|
/// \cond INCLUDE_QPROPERTIES
|
|
|
Q_PROPERTY(QColor color READ color WRITE setColor)
|
|
|
Q_PROPERTY(QColor selectedColor READ selectedColor WRITE setSelectedColor)
|
|
|
Q_PROPERTY(QPen pen READ pen WRITE setPen)
|
|
|
Q_PROPERTY(QPen selectedPen READ selectedPen WRITE setSelectedPen)
|
|
|
Q_PROPERTY(QBrush brush READ brush WRITE setBrush)
|
|
|
Q_PROPERTY(QBrush selectedBrush READ selectedBrush WRITE setSelectedBrush)
|
|
|
Q_PROPERTY(QFont font READ font WRITE setFont)
|
|
|
Q_PROPERTY(QFont selectedFont READ selectedFont WRITE setSelectedFont)
|
|
|
Q_PROPERTY(QString text READ text WRITE setText)
|
|
|
Q_PROPERTY(Qt::Alignment positionAlignment READ positionAlignment WRITE setPositionAlignment)
|
|
|
Q_PROPERTY(Qt::Alignment textAlignment READ textAlignment WRITE setTextAlignment)
|
|
|
Q_PROPERTY(double rotation READ rotation WRITE setRotation)
|
|
|
Q_PROPERTY(QMargins padding READ padding WRITE setPadding)
|
|
|
/// \endcond
|
|
|
public:
|
|
|
QCPItemText(QCustomPlot *parentPlot);
|
|
|
virtual ~QCPItemText();
|
|
|
|
|
|
// getters:
|
|
|
QColor color() const { return mColor; }
|
|
|
QColor selectedColor() const { return mSelectedColor; }
|
|
|
QPen pen() const { return mPen; }
|
|
|
QPen selectedPen() const { return mSelectedPen; }
|
|
|
QBrush brush() const { return mBrush; }
|
|
|
QBrush selectedBrush() const { return mSelectedBrush; }
|
|
|
QFont font() const { return mFont; }
|
|
|
QFont selectedFont() const { return mSelectedFont; }
|
|
|
QString text() const { return mText; }
|
|
|
Qt::Alignment positionAlignment() const { return mPositionAlignment; }
|
|
|
Qt::Alignment textAlignment() const { return mTextAlignment; }
|
|
|
double rotation() const { return mRotation; }
|
|
|
QMargins padding() const { return mPadding; }
|
|
|
|
|
|
// setters;
|
|
|
void setColor(const QColor &color);
|
|
|
void setSelectedColor(const QColor &color);
|
|
|
void setPen(const QPen &pen);
|
|
|
void setSelectedPen(const QPen &pen);
|
|
|
void setBrush(const QBrush &brush);
|
|
|
void setSelectedBrush(const QBrush &brush);
|
|
|
void setFont(const QFont &font);
|
|
|
void setSelectedFont(const QFont &font);
|
|
|
void setText(const QString &text);
|
|
|
void setPositionAlignment(Qt::Alignment alignment);
|
|
|
void setTextAlignment(Qt::Alignment alignment);
|
|
|
void setRotation(double degrees);
|
|
|
void setPadding(const QMargins &padding);
|
|
|
|
|
|
// reimplemented virtual methods:
|
|
|
virtual double selectTest(const QPointF &pos, bool onlySelectable, QVariant *details=0) const;
|
|
|
|
|
|
QCPItemPosition * const position;
|
|
|
QCPItemAnchor * const topLeft;
|
|
|
QCPItemAnchor * const top;
|
|
|
QCPItemAnchor * const topRight;
|
|
|
QCPItemAnchor * const right;
|
|
|
QCPItemAnchor * const bottomRight;
|
|
|
QCPItemAnchor * const bottom;
|
|
|
QCPItemAnchor * const bottomLeft;
|
|
|
QCPItemAnchor * const left;
|
|
|
|
|
|
protected:
|
|
|
enum AnchorIndex {aiTopLeft, aiTop, aiTopRight, aiRight, aiBottomRight, aiBottom, aiBottomLeft, aiLeft};
|
|
|
|
|
|
// property members:
|
|
|
QColor mColor, mSelectedColor;
|
|
|
QPen mPen, mSelectedPen;
|
|
|
QBrush mBrush, mSelectedBrush;
|
|
|
QFont mFont, mSelectedFont;
|
|
|
QString mText;
|
|
|
Qt::Alignment mPositionAlignment;
|
|
|
Qt::Alignment mTextAlignment;
|
|
|
double mRotation;
|
|
|
QMargins mPadding;
|
|
|
|
|
|
// reimplemented virtual methods:
|
|
|
virtual void draw(QCPPainter *painter);
|
|
|
virtual QPointF anchorPixelPoint(int anchorId) const;
|
|
|
|
|
|
// non-virtual methods:
|
|
|
QPointF getTextDrawPoint(const QPointF &pos, const QRectF &rect, Qt::Alignment positionAlignment) const;
|
|
|
QFont mainFont() const;
|
|
|
QColor mainColor() const;
|
|
|
QPen mainPen() const;
|
|
|
QBrush mainBrush() const;
|
|
|
};
|
|
|
|
|
|
|
|
|
class QCP_LIB_DECL QCPItemEllipse : public QCPAbstractItem
|
|
|
{
|
|
|
Q_OBJECT
|
|
|
/// \cond INCLUDE_QPROPERTIES
|
|
|
Q_PROPERTY(QPen pen READ pen WRITE setPen)
|
|
|
Q_PROPERTY(QPen selectedPen READ selectedPen WRITE setSelectedPen)
|
|
|
Q_PROPERTY(QBrush brush READ brush WRITE setBrush)
|
|
|
Q_PROPERTY(QBrush selectedBrush READ selectedBrush WRITE setSelectedBrush)
|
|
|
/// \endcond
|
|
|
public:
|
|
|
QCPItemEllipse(QCustomPlot *parentPlot);
|
|
|
virtual ~QCPItemEllipse();
|
|
|
|
|
|
// getters:
|
|
|
QPen pen() const { return mPen; }
|
|
|
QPen selectedPen() const { return mSelectedPen; }
|
|
|
QBrush brush() const { return mBrush; }
|
|
|
QBrush selectedBrush() const { return mSelectedBrush; }
|
|
|
|
|
|
// setters;
|
|
|
void setPen(const QPen &pen);
|
|
|
void setSelectedPen(const QPen &pen);
|
|
|
void setBrush(const QBrush &brush);
|
|
|
void setSelectedBrush(const QBrush &brush);
|
|
|
|
|
|
// reimplemented virtual methods:
|
|
|
virtual double selectTest(const QPointF &pos, bool onlySelectable, QVariant *details=0) const;
|
|
|
|
|
|
QCPItemPosition * const topLeft;
|
|
|
QCPItemPosition * const bottomRight;
|
|
|
QCPItemAnchor * const topLeftRim;
|
|
|
QCPItemAnchor * const top;
|
|
|
QCPItemAnchor * const topRightRim;
|
|
|
QCPItemAnchor * const right;
|
|
|
QCPItemAnchor * const bottomRightRim;
|
|
|
QCPItemAnchor * const bottom;
|
|
|
QCPItemAnchor * const bottomLeftRim;
|
|
|
QCPItemAnchor * const left;
|
|
|
QCPItemAnchor * const center;
|
|
|
|
|
|
protected:
|
|
|
enum AnchorIndex {aiTopLeftRim, aiTop, aiTopRightRim, aiRight, aiBottomRightRim, aiBottom, aiBottomLeftRim, aiLeft, aiCenter};
|
|
|
|
|
|
// property members:
|
|
|
QPen mPen, mSelectedPen;
|
|
|
QBrush mBrush, mSelectedBrush;
|
|
|
|
|
|
// reimplemented virtual methods:
|
|
|
virtual void draw(QCPPainter *painter);
|
|
|
virtual QPointF anchorPixelPoint(int anchorId) const;
|
|
|
|
|
|
// non-virtual methods:
|
|
|
QPen mainPen() const;
|
|
|
QBrush mainBrush() const;
|
|
|
};
|
|
|
|
|
|
|
|
|
class QCP_LIB_DECL QCPItemPixmap : public QCPAbstractItem
|
|
|
{
|
|
|
Q_OBJECT
|
|
|
/// \cond INCLUDE_QPROPERTIES
|
|
|
Q_PROPERTY(QPixmap pixmap READ pixmap WRITE setPixmap)
|
|
|
Q_PROPERTY(bool scaled READ scaled WRITE setScaled)
|
|
|
Q_PROPERTY(Qt::AspectRatioMode aspectRatioMode READ aspectRatioMode)
|
|
|
Q_PROPERTY(QPen pen READ pen WRITE setPen)
|
|
|
Q_PROPERTY(QPen selectedPen READ selectedPen WRITE setSelectedPen)
|
|
|
/// \endcond
|
|
|
public:
|
|
|
QCPItemPixmap(QCustomPlot *parentPlot);
|
|
|
virtual ~QCPItemPixmap();
|
|
|
|
|
|
// getters:
|
|
|
QPixmap pixmap() const { return mPixmap; }
|
|
|
bool scaled() const { return mScaled; }
|
|
|
Qt::AspectRatioMode aspectRatioMode() const { return mAspectRatioMode; }
|
|
|
QPen pen() const { return mPen; }
|
|
|
QPen selectedPen() const { return mSelectedPen; }
|
|
|
|
|
|
// setters;
|
|
|
void setPixmap(const QPixmap &pixmap);
|
|
|
void setScaled(bool scaled, Qt::AspectRatioMode aspectRatioMode=Qt::KeepAspectRatio);
|
|
|
void setPen(const QPen &pen);
|
|
|
void setSelectedPen(const QPen &pen);
|
|
|
|
|
|
// reimplemented virtual methods:
|
|
|
virtual double selectTest(const QPointF &pos, bool onlySelectable, QVariant *details=0) const;
|
|
|
|
|
|
QCPItemPosition * const topLeft;
|
|
|
QCPItemPosition * const bottomRight;
|
|
|
QCPItemAnchor * const top;
|
|
|
QCPItemAnchor * const topRight;
|
|
|
QCPItemAnchor * const right;
|
|
|
QCPItemAnchor * const bottom;
|
|
|
QCPItemAnchor * const bottomLeft;
|
|
|
QCPItemAnchor * const left;
|
|
|
|
|
|
protected:
|
|
|
enum AnchorIndex {aiTop, aiTopRight, aiRight, aiBottom, aiBottomLeft, aiLeft};
|
|
|
|
|
|
// property members:
|
|
|
QPixmap mPixmap;
|
|
|
QPixmap mScaledPixmap;
|
|
|
bool mScaled;
|
|
|
Qt::AspectRatioMode mAspectRatioMode;
|
|
|
QPen mPen, mSelectedPen;
|
|
|
|
|
|
// reimplemented virtual methods:
|
|
|
virtual void draw(QCPPainter *painter);
|
|
|
virtual QPointF anchorPixelPoint(int anchorId) const;
|
|
|
|
|
|
// non-virtual methods:
|
|
|
void updateScaledPixmap(QRect finalRect=QRect(), bool flipHorz=false, bool flipVert=false);
|
|
|
QRect getFinalRect(bool *flippedHorz=0, bool *flippedVert=0) const;
|
|
|
QPen mainPen() const;
|
|
|
};
|
|
|
|
|
|
|
|
|
class QCP_LIB_DECL QCPItemTracer : public QCPAbstractItem
|
|
|
{
|
|
|
Q_OBJECT
|
|
|
/// \cond INCLUDE_QPROPERTIES
|
|
|
Q_PROPERTY(QPen pen READ pen WRITE setPen)
|
|
|
Q_PROPERTY(QPen selectedPen READ selectedPen WRITE setSelectedPen)
|
|
|
Q_PROPERTY(QBrush brush READ brush WRITE setBrush)
|
|
|
Q_PROPERTY(QBrush selectedBrush READ selectedBrush WRITE setSelectedBrush)
|
|
|
Q_PROPERTY(double size READ size WRITE setSize)
|
|
|
Q_PROPERTY(TracerStyle style READ style WRITE setStyle)
|
|
|
Q_PROPERTY(QCPGraph* graph READ graph WRITE setGraph)
|
|
|
Q_PROPERTY(double graphKey READ graphKey WRITE setGraphKey)
|
|
|
Q_PROPERTY(bool interpolating READ interpolating WRITE setInterpolating)
|
|
|
/// \endcond
|
|
|
public:
|
|
|
/*!
|
|
|
The different visual appearances a tracer item can have. Some styles size may be controlled with \ref setSize.
|
|
|
|
|
|
\see setStyle
|
|
|
*/
|
|
|
enum TracerStyle { tsNone ///< The tracer is not visible
|
|
|
,tsPlus ///< A plus shaped crosshair with limited size
|
|
|
,tsCrosshair ///< A plus shaped crosshair which spans the complete axis rect
|
|
|
,tsCircle ///< A circle
|
|
|
,tsSquare ///< A square
|
|
|
};
|
|
|
Q_ENUMS(TracerStyle)
|
|
|
|
|
|
QCPItemTracer(QCustomPlot *parentPlot);
|
|
|
virtual ~QCPItemTracer();
|
|
|
|
|
|
// getters:
|
|
|
QPen pen() const { return mPen; }
|
|
|
QPen selectedPen() const { return mSelectedPen; }
|
|
|
QBrush brush() const { return mBrush; }
|
|
|
QBrush selectedBrush() const { return mSelectedBrush; }
|
|
|
double size() const { return mSize; }
|
|
|
TracerStyle style() const { return mStyle; }
|
|
|
QCPGraph *graph() const { return mGraph; }
|
|
|
double graphKey() const { return mGraphKey; }
|
|
|
bool interpolating() const { return mInterpolating; }
|
|
|
|
|
|
// setters;
|
|
|
void setPen(const QPen &pen);
|
|
|
void setSelectedPen(const QPen &pen);
|
|
|
void setBrush(const QBrush &brush);
|
|
|
void setSelectedBrush(const QBrush &brush);
|
|
|
void setSize(double size);
|
|
|
void setStyle(TracerStyle style);
|
|
|
void setGraph(QCPGraph *graph);
|
|
|
void setGraphKey(double key);
|
|
|
void setInterpolating(bool enabled);
|
|
|
|
|
|
// reimplemented virtual methods:
|
|
|
virtual double selectTest(const QPointF &pos, bool onlySelectable, QVariant *details=0) const;
|
|
|
|
|
|
// non-virtual methods:
|
|
|
void updatePosition();
|
|
|
|
|
|
QCPItemPosition * const position;
|
|
|
|
|
|
protected:
|
|
|
// property members:
|
|
|
QPen mPen, mSelectedPen;
|
|
|
QBrush mBrush, mSelectedBrush;
|
|
|
double mSize;
|
|
|
TracerStyle mStyle;
|
|
|
QCPGraph *mGraph;
|
|
|
double mGraphKey;
|
|
|
bool mInterpolating;
|
|
|
|
|
|
// reimplemented virtual methods:
|
|
|
virtual void draw(QCPPainter *painter);
|
|
|
|
|
|
// non-virtual methods:
|
|
|
QPen mainPen() const;
|
|
|
QBrush mainBrush() const;
|
|
|
};
|
|
|
|
|
|
|
|
|
class QCP_LIB_DECL QCPItemBracket : public QCPAbstractItem
|
|
|
{
|
|
|
Q_OBJECT
|
|
|
/// \cond INCLUDE_QPROPERTIES
|
|
|
Q_PROPERTY(QPen pen READ pen WRITE setPen)
|
|
|
Q_PROPERTY(QPen selectedPen READ selectedPen WRITE setSelectedPen)
|
|
|
Q_PROPERTY(double length READ length WRITE setLength)
|
|
|
Q_PROPERTY(BracketStyle style READ style WRITE setStyle)
|
|
|
/// \endcond
|
|
|
public:
|
|
|
enum BracketStyle { bsSquare ///< A brace with angled edges
|
|
|
,bsRound ///< A brace with round edges
|
|
|
,bsCurly ///< A curly brace
|
|
|
,bsCalligraphic ///< A curly brace with varying stroke width giving a calligraphic impression
|
|
|
};
|
|
|
|
|
|
QCPItemBracket(QCustomPlot *parentPlot);
|
|
|
virtual ~QCPItemBracket();
|
|
|
|
|
|
// getters:
|
|
|
QPen pen() const { return mPen; }
|
|
|
QPen selectedPen() const { return mSelectedPen; }
|
|
|
double length() const { return mLength; }
|
|
|
BracketStyle style() const { return mStyle; }
|
|
|
|
|
|
// setters;
|
|
|
void setPen(const QPen &pen);
|
|
|
void setSelectedPen(const QPen &pen);
|
|
|
void setLength(double length);
|
|
|
void setStyle(BracketStyle style);
|
|
|
|
|
|
// reimplemented virtual methods:
|
|
|
virtual double selectTest(const QPointF &pos, bool onlySelectable, QVariant *details=0) const;
|
|
|
|
|
|
QCPItemPosition * const left;
|
|
|
QCPItemPosition * const right;
|
|
|
QCPItemAnchor * const center;
|
|
|
|
|
|
protected:
|
|
|
// property members:
|
|
|
enum AnchorIndex {aiCenter};
|
|
|
QPen mPen, mSelectedPen;
|
|
|
double mLength;
|
|
|
BracketStyle mStyle;
|
|
|
|
|
|
// reimplemented virtual methods:
|
|
|
virtual void draw(QCPPainter *painter);
|
|
|
virtual QPointF anchorPixelPoint(int anchorId) const;
|
|
|
|
|
|
// non-virtual methods:
|
|
|
QPen mainPen() const;
|
|
|
};
|
|
|
|
|
|
#endif // QCUSTOMPLOT_H
|
|
|
|
|
|
|
