--- /dev/null
+/***************************************************************************
+** **
+** QCustomPlot, an easy to use, modern plotting widget for Qt **
+** Copyright (C) 2011-2015 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: 22.12.15 **
+** Version: 1.3.2 **
+****************************************************************************/
+
+#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/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:
+/* LFV
+ #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
+*/
+#include <cp_QCustomPlot_Export.h>
+#define QCP_LIB_DECL cp_QCustomPlot_EXPORT
+
+/*!
+ 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, mUndersampledMapImage;
+ 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;
+ bool mScaledPixmapInvalidated;
+ 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
+
git://git.creatis.insa-lyon.fr / cpPlugins.git / blobdiff