qcustomplot.h
3767 lines
| 145.7 KiB
| text/x-c
|
CLexer
r16 | /*************************************************************************** | |||
** ** | ||||
** 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: 27.12.14 ** | ||||
** Version: 1.3.0 ** | ||||
****************************************************************************/ | ||||
#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; | ||||
class QCPBars; | ||||
/*! \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=QString(), 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) const { return lower == other.lower && upper == other.upper; } | ||||
bool operator!=(const QCPRange& other) const { 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(LabelSide tickLabelSide READ tickLabelSide WRITE setTickLabelSide) | ||||
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 on which side of the axis the tick labels (numbers) shall appear. | ||||
\see setTickLabelSide | ||||
*/ | ||||
enum LabelSide { lsInside ///< Tick labels will be displayed inside the axis rect and clipped to the inner axis rect | ||||
,lsOutside ///< Tick labels will be displayed outside the axis rect | ||||
}; | ||||
Q_ENUMS(LabelSide) | ||||
/*! | ||||
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; | ||||
LabelSide tickLabelSide() 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 setTickLabelSide(LabelSide side); | ||||
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; | ||||
QLatin1Char 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 | ||||
QCPAxis::LabelSide tickLabelSide; // 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 axisRect, 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*> mChildrenX, mChildrenY; | ||||
// introduced virtual methods: | ||||
virtual QCPItemPosition *toQCPItemPosition() { return 0; } | ||||
// non-virtual methods: | ||||
void addChildX(QCPItemPosition* pos); // called from pos when this anchor is set as parent | ||||
void removeChildX(QCPItemPosition *pos); // called from pos when its parent anchor is reset or pos deleted | ||||
void addChildY(QCPItemPosition* pos); // called from pos when this anchor is set as parent | ||||
void removeChildY(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 typeX(); } | ||||
PositionType typeX() const { return mPositionTypeX; } | ||||
PositionType typeY() const { return mPositionTypeY; } | ||||
QCPItemAnchor *parentAnchor() const { return parentAnchorX(); } | ||||
QCPItemAnchor *parentAnchorX() const { return mParentAnchorX; } | ||||
QCPItemAnchor *parentAnchorY() const { return mParentAnchorY; } | ||||
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); | ||||
void setTypeX(PositionType type); | ||||
void setTypeY(PositionType type); | ||||
bool setParentAnchor(QCPItemAnchor *parentAnchor, bool keepPixelPosition=false); | ||||
bool setParentAnchorX(QCPItemAnchor *parentAnchor, bool keepPixelPosition=false); | ||||
bool setParentAnchorY(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 mPositionTypeX, mPositionTypeY; | ||||
QPointer<QCPAxis> mKeyAxis, mValueAxis; | ||||
QPointer<QCPAxisRect> mAxisRect; | ||||
double mKey, mValue; | ||||
QCPItemAnchor *mParentAnchorX, *mParentAnchorY; | ||||
// 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=QString(), const QString &pdfTitle=QString()); | ||||
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, QCPAxis *axis=0); | ||||
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 \ref 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 \ref 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; | ||||
int getRegion(double x, double y, double rectLeft, double rectTop, double rectRight, double rectBottom) const; | ||||
QPointF getOptimizedPoint(int prevRegion, double prevKey, double prevValue, double key, double value, double rectLeft, double rectTop, double rectRight, double rectBottom) const; | ||||
QVector<QPointF> getOptimizedCornerPoints(int prevRegion, int currentRegion, double prevKey, double prevValue, double key, double value, double rectLeft, double rectTop, double rectRight, double rectBottom) const; | ||||
bool mayTraverse(int prevRegion, int currentRegion) const; | ||||
bool getTraverse(double prevKey, double prevValue, double key, double value, double rectLeft, double rectTop, double rectRight, double rectBottom, QPointF &crossA, QPointF &crossB) const; | ||||
void getTraverseCornerPoints(int prevRegion, int currentRegion, double rectLeft, double rectTop, double rectRight, double rectBottom, QVector<QPointF> &beforeTraverse, QVector<QPointF> &afterTraverse) const; | ||||
double pointDistance(const QPointF &pixelPoint) const; | ||||
friend class QCustomPlot; | ||||
friend class QCPLegend; | ||||
}; | ||||
/*! \file */ | ||||
class QCP_LIB_DECL QCPBarsGroup : public QObject | ||||
{ | ||||
Q_OBJECT | ||||
/// \cond INCLUDE_QPROPERTIES | ||||
Q_PROPERTY(SpacingType spacingType READ spacingType WRITE setSpacingType) | ||||
Q_PROPERTY(double spacing READ spacing WRITE setSpacing) | ||||
/// \endcond | ||||
public: | ||||
/*! | ||||
Defines the ways the spacing between bars in the group can be specified. Thus it defines what | ||||
the number passed to \ref setSpacing actually means. | ||||
\see setSpacingType, setSpacing | ||||
*/ | ||||
enum SpacingType { stAbsolute ///< Bar spacing is in absolute pixels | ||||
,stAxisRectRatio ///< Bar spacing is given by a fraction of the axis rect size | ||||
,stPlotCoords ///< Bar spacing is in key coordinates and thus scales with the key axis range | ||||
}; | ||||
QCPBarsGroup(QCustomPlot *parentPlot); | ||||
~QCPBarsGroup(); | ||||
// getters: | ||||
SpacingType spacingType() const { return mSpacingType; } | ||||
double spacing() const { return mSpacing; } | ||||
// setters: | ||||
void setSpacingType(SpacingType spacingType); | ||||
void setSpacing(double spacing); | ||||
// non-virtual methods: | ||||
QList<QCPBars*> bars() const { return mBars; } | ||||
QCPBars* bars(int index) const; | ||||
int size() const { return mBars.size(); } | ||||
bool isEmpty() const { return mBars.isEmpty(); } | ||||
void clear(); | ||||
bool contains(QCPBars *bars) const { return mBars.contains(bars); } | ||||
void append(QCPBars *bars); | ||||
void insert(int i, QCPBars *bars); | ||||
void remove(QCPBars *bars); | ||||
protected: | ||||
// non-property members: | ||||
QCustomPlot *mParentPlot; | ||||
SpacingType mSpacingType; | ||||
double mSpacing; | ||||
QList<QCPBars*> mBars; | ||||
// non-virtual methods: | ||||
void registerBars(QCPBars *bars); | ||||
void unregisterBars(QCPBars *bars); | ||||
// virtual methods: | ||||
double keyPixelOffset(const QCPBars *bars, double keyCoord); | ||||
double getPixelSpacing(const QCPBars *bars, double keyCoord); | ||||
private: | ||||
Q_DISABLE_COPY(QCPBarsGroup) | ||||
friend class QCPBars; | ||||
}; | ||||
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 \ref 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(WidthType widthType READ widthType WRITE setWidthType) | ||||
Q_PROPERTY(QCPBarsGroup* barsGroup READ barsGroup WRITE setBarsGroup) | ||||
Q_PROPERTY(double baseValue READ baseValue WRITE setBaseValue) | ||||
Q_PROPERTY(QCPBars* barBelow READ barBelow) | ||||
Q_PROPERTY(QCPBars* barAbove READ barAbove) | ||||
/// \endcond | ||||
public: | ||||
/*! | ||||
Defines the ways the width of the bar can be specified. Thus it defines what the number passed | ||||
to \ref setWidth actually means. | ||||
\see setWidthType, setWidth | ||||
*/ | ||||
enum WidthType { wtAbsolute ///< Bar width is in absolute pixels | ||||
,wtAxisRectRatio ///< Bar width is given by a fraction of the axis rect size | ||||
,wtPlotCoords ///< Bar width is in key coordinates and thus scales with the key axis range | ||||
}; | ||||
Q_ENUMS(WidthType) | ||||
explicit QCPBars(QCPAxis *keyAxis, QCPAxis *valueAxis); | ||||
virtual ~QCPBars(); | ||||
// getters: | ||||
double width() const { return mWidth; } | ||||
WidthType widthType() const { return mWidthType; } | ||||
QCPBarsGroup *barsGroup() const { return mBarsGroup; } | ||||
double baseValue() const { return mBaseValue; } | ||||
QCPBars *barBelow() const { return mBarBelow.data(); } | ||||
QCPBars *barAbove() const { return mBarAbove.data(); } | ||||
QCPBarDataMap *data() const { return mData; } | ||||
// setters: | ||||
void setWidth(double width); | ||||
void setWidthType(WidthType widthType); | ||||
void setBarsGroup(QCPBarsGroup *barsGroup); | ||||
void setBaseValue(double baseValue); | ||||
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; | ||||
WidthType mWidthType; | ||||
QCPBarsGroup *mBarsGroup; | ||||
double mBaseValue; | ||||
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: | ||||
void getVisibleDataBounds(QCPBarDataMap::const_iterator &lower, QCPBarDataMap::const_iterator &upperEnd) const; | ||||
QPolygonF getBarPolygon(double key, double value) const; | ||||
void getPixelWidth(double key, double &lower, double &upper) const; | ||||
double getStackedBaseValue(double key, bool positive) const; | ||||
static void connectBars(QCPBars* lower, QCPBars* upper); | ||||
friend class QCustomPlot; | ||||
friend class QCPLegend; | ||||
friend class QCPBarsGroup; | ||||
}; | ||||
/*! \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; | ||||
}; | ||||
/*! \file */ | ||||
class QCP_LIB_DECL QCPFinancialData | ||||
{ | ||||
public: | ||||
QCPFinancialData(); | ||||
QCPFinancialData(double key, double open, double high, double low, double close); | ||||
double key, open, high, low, close; | ||||
}; | ||||
Q_DECLARE_TYPEINFO(QCPFinancialData, Q_MOVABLE_TYPE); | ||||
/*! \typedef QCPFinancialDataMap | ||||
Container for storing \ref QCPFinancialData items in a sorted fashion. The key of the map | ||||
is the key member of the QCPFinancialData instance. | ||||
This is the container in which QCPFinancial holds its data. | ||||
\see QCPFinancial, QCPFinancial::setData | ||||
*/ | ||||
typedef QMap<double, QCPFinancialData> QCPFinancialDataMap; | ||||
typedef QMapIterator<double, QCPFinancialData> QCPFinancialDataMapIterator; | ||||
typedef QMutableMapIterator<double, QCPFinancialData> QCPFinancialDataMutableMapIterator; | ||||
class QCP_LIB_DECL QCPFinancial : public QCPAbstractPlottable | ||||
{ | ||||
Q_OBJECT | ||||
/// \cond INCLUDE_QPROPERTIES | ||||
Q_PROPERTY(ChartStyle chartStyle READ chartStyle WRITE setChartStyle) | ||||
Q_PROPERTY(double width READ width WRITE setWidth) | ||||
Q_PROPERTY(bool twoColored READ twoColored WRITE setTwoColored) | ||||
Q_PROPERTY(QBrush brushPositive READ brushPositive WRITE setBrushPositive) | ||||
Q_PROPERTY(QBrush brushNegative READ brushNegative WRITE setBrushNegative) | ||||
Q_PROPERTY(QPen penPositive READ penPositive WRITE setPenPositive) | ||||
Q_PROPERTY(QPen penNegative READ penNegative WRITE setPenNegative) | ||||
/// \endcond | ||||
public: | ||||
/*! | ||||
Defines the possible representations of OHLC data in the plot. | ||||
\see setChartStyle | ||||
*/ | ||||
enum ChartStyle { csOhlc ///< Open-High-Low-Close bar representation | ||||
,csCandlestick ///< Candlestick representation | ||||
}; | ||||
Q_ENUMS(ChartStyle) | ||||
explicit QCPFinancial(QCPAxis *keyAxis, QCPAxis *valueAxis); | ||||
virtual ~QCPFinancial(); | ||||
// getters: | ||||
QCPFinancialDataMap *data() const { return mData; } | ||||
ChartStyle chartStyle() const { return mChartStyle; } | ||||
double width() const { return mWidth; } | ||||
bool twoColored() const { return mTwoColored; } | ||||
QBrush brushPositive() const { return mBrushPositive; } | ||||
QBrush brushNegative() const { return mBrushNegative; } | ||||
QPen penPositive() const { return mPenPositive; } | ||||
QPen penNegative() const { return mPenNegative; } | ||||
// setters: | ||||
void setData(QCPFinancialDataMap *data, bool copy=false); | ||||
void setData(const QVector<double> &key, const QVector<double> &open, const QVector<double> &high, const QVector<double> &low, const QVector<double> &close); | ||||
void setChartStyle(ChartStyle style); | ||||
void setWidth(double width); | ||||
void setTwoColored(bool twoColored); | ||||
void setBrushPositive(const QBrush &brush); | ||||
void setBrushNegative(const QBrush &brush); | ||||
void setPenPositive(const QPen &pen); | ||||
void setPenNegative(const QPen &pen); | ||||
// non-property methods: | ||||
void addData(const QCPFinancialDataMap &dataMap); | ||||
void addData(const QCPFinancialData &data); | ||||
void addData(double key, double open, double high, double low, double close); | ||||
void addData(const QVector<double> &key, const QVector<double> &open, const QVector<double> &high, const QVector<double> &low, const QVector<double> &close); | ||||
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; | ||||
// static methods: | ||||
static QCPFinancialDataMap timeSeriesToOhlc(const QVector<double> &time, const QVector<double> &value, double timeBinSize, double timeBinOffset = 0); | ||||
protected: | ||||
// property members: | ||||
QCPFinancialDataMap *mData; | ||||
ChartStyle mChartStyle; | ||||
double mWidth; | ||||
bool mTwoColored; | ||||
QBrush mBrushPositive, mBrushNegative; | ||||
QPen mPenPositive, mPenNegative; | ||||
// 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: | ||||
void drawOhlcPlot(QCPPainter *painter, const QCPFinancialDataMap::const_iterator &begin, const QCPFinancialDataMap::const_iterator &end); | ||||
void drawCandlestickPlot(QCPPainter *painter, const QCPFinancialDataMap::const_iterator &begin, const QCPFinancialDataMap::const_iterator &end); | ||||
double ohlcSelectTest(const QPointF &pos, const QCPFinancialDataMap::const_iterator &begin, const QCPFinancialDataMap::const_iterator &end) const; | ||||
double candlestickSelectTest(const QPointF &pos, const QCPFinancialDataMap::const_iterator &begin, const QCPFinancialDataMap::const_iterator &end) const; | ||||
void getVisibleDataBounds(QCPFinancialDataMap::const_iterator &lower, QCPFinancialDataMap::const_iterator &upper) 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(Qt::TransformationMode transformationMode READ transformationMode) | ||||
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; } | ||||
Qt::TransformationMode transformationMode() const { return mTransformationMode; } | ||||
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, Qt::TransformationMode transformationMode=Qt::SmoothTransformation); | ||||
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; | ||||
Qt::TransformationMode mTransformationMode; | ||||
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 | ||||