2022-06-02 01:41:24 +00:00
/***************************************************************************
2021-12-10 12:23:28 +00:00
* * * *
* * 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:
# if defined(QCUSTOMPLOT_COMPILE_LIBRARY)
# define QCP_LIB_DECL Q_DECL_EXPORT
# elif defined(QCUSTOMPLOT_USE_LIBRARY)
# define QCP_LIB_DECL Q_DECL_IMPORT
# else
# define QCP_LIB_DECL
# endif
/*!
The QCP Namespace contains general enums and QFlags used throughout the QCustomPlot library
*/
2022-06-02 01:41:24 +00:00
namespace QCP {
2021-12-10 12:23:28 +00:00
/*!
Defines the sides of a rectangular entity to which margins can be applied .
2022-06-02 01:41:24 +00:00
2021-12-10 12:23:28 +00:00
\ see QCPLayoutElement : : setAutoMargins , QCPAxisRect : : setAutoMargins
*/
enum MarginSide { msLeft = 0x01 ///< <tt>0x01</tt> left margin
2022-06-02 01:41:24 +00:00
, 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
2021-12-10 12:23:28 +00:00
} ;
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 .
2022-06-02 01:41:24 +00:00
2021-12-10 12:23:28 +00:00
\ c AntialiasedElements is a flag of or - combined elements of this enum type .
2022-06-02 01:41:24 +00:00
2021-12-10 12:23:28 +00:00
\ see QCustomPlot : : setAntialiasedElements , QCustomPlot : : setNotAntialiasedElements
*/
enum AntialiasedElement { aeAxes = 0x0001 ///< <tt>0x0001</tt> Axis base line and tick marks
2022-06-02 01:41:24 +00:00
, 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
2021-12-10 12:23:28 +00:00
} ;
Q_DECLARE_FLAGS ( AntialiasedElements , AntialiasedElement )
/*!
Defines plotting hints that control various aspects of the quality and speed of plotting .
2022-06-02 01:41:24 +00:00
2021-12-10 12:23:28 +00:00
\ see QCustomPlot : : setPlottingHints
*/
enum PlottingHint { phNone = 0x000 ///< <tt>0x000</tt> No hints are set
2022-06-02 01:41:24 +00:00
, 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.
2021-12-10 12:23:28 +00:00
} ;
Q_DECLARE_FLAGS ( PlottingHints , PlottingHint )
/*!
Defines the mouse interactions possible with QCustomPlot .
2022-06-02 01:41:24 +00:00
2021-12-10 12:23:28 +00:00
\ c Interactions is a flag of or - combined elements of this enum type .
2022-06-02 01:41:24 +00:00
2021-12-10 12:23:28 +00:00
\ see QCustomPlot : : setInteractions
*/
enum Interaction { iRangeDrag = 0x001 ///< <tt>0x001</tt> Axis ranges are draggable (see \ref QCPAxisRect::setRangeDrag, \ref QCPAxisRect::setRangeDragAxes)
2022-06-02 01:41:24 +00:00
, 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,...)
2021-12-10 12:23:28 +00:00
} ;
Q_DECLARE_FLAGS ( Interactions , Interaction )
/*! \internal
2022-06-02 01:41:24 +00:00
2021-12-10 12:23:28 +00:00
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 )
{
2022-06-02 01:41:24 +00:00
return qIsNaN ( value ) | | qIsInf ( value ) ;
2021-12-10 12:23:28 +00:00
}
/*! \internal
\ overload
2022-06-02 01:41:24 +00:00
2021-12-10 12:23:28 +00:00
Checks two arguments instead of one .
*/
inline bool isInvalidData ( double value1 , double value2 )
{
2022-06-02 01:41:24 +00:00
return isInvalidData ( value1 ) | | isInvalidData ( value2 ) ;
2021-12-10 12:23:28 +00:00
}
/*! \internal
2022-06-02 01:41:24 +00:00
2021-12-10 12:23:28 +00:00
Sets the specified \ a side of \ a margins to \ a value
2022-06-02 01:41:24 +00:00
2021-12-10 12:23:28 +00:00
\ see getMarginValue
*/
inline void setMarginValue ( QMargins & margins , QCP : : MarginSide side , int value )
{
2022-06-02 01:41:24 +00:00
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 ;
}
2021-12-10 12:23:28 +00:00
}
/*! \internal
2022-06-02 01:41:24 +00:00
2021-12-10 12:23:28 +00:00
Returns the value of the specified \ a side of \ a margins . If \ a side is \ ref QCP : : msNone or
\ ref QCP : : msAll , returns 0.
2022-06-02 01:41:24 +00:00
2021-12-10 12:23:28 +00:00
\ see setMarginValue
*/
inline int getMarginValue ( const QMargins & margins , QCP : : MarginSide side )
{
2022-06-02 01:41:24 +00:00
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 ;
2021-12-10 12:23:28 +00:00
}
} // 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
{
2022-06-02 01:41:24 +00:00
Q_GADGET
2021-12-10 12:23:28 +00:00
public :
2022-06-02 01:41:24 +00:00
/*!
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)
} ;
2021-12-10 12:23:28 +00:00
2022-06-02 01:41:24 +00:00
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 ;
2021-12-10 12:23:28 +00:00
protected :
2022-06-02 01:41:24 +00:00
// property members:
double mSize ;
ScatterShape mShape ;
QPen mPen ;
QBrush mBrush ;
QPixmap mPixmap ;
QPainterPath mCustomPath ;
// non-property members:
bool mPenDefined ;
2021-12-10 12:23:28 +00:00
} ;
Q_DECLARE_TYPEINFO ( QCPScatterStyle , Q_MOVABLE_TYPE ) ;
class QCP_LIB_DECL QCPPainter : public QPainter
{
2022-06-02 01:41:24 +00:00
Q_GADGET
2021-12-10 12:23:28 +00:00
public :
2022-06-02 01:41:24 +00:00
/*!
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 ( ) ;
2021-12-10 12:23:28 +00:00
protected :
2022-06-02 01:41:24 +00:00
// property members:
PainterModes mModes ;
bool mIsAntialiasing ;
// non-property members:
QStack < bool > mAntialiasingStack ;
2021-12-10 12:23:28 +00:00
} ;
Q_DECLARE_OPERATORS_FOR_FLAGS ( QCPPainter : : PainterModes )
class QCP_LIB_DECL QCPLayer : public QObject
{
2022-06-02 01:41:24 +00:00
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
2021-12-10 12:23:28 +00:00
public :
2022-06-02 01:41:24 +00:00
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 ) ;
2021-12-10 12:23:28 +00:00
protected :
2022-06-02 01:41:24 +00:00
// 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 ) ;
2021-12-10 12:23:28 +00:00
private :
2022-06-02 01:41:24 +00:00
Q_DISABLE_COPY ( QCPLayer )
friend class QCustomPlot ;
friend class QCPLayerable ;
2021-12-10 12:23:28 +00:00
} ;
class QCP_LIB_DECL QCPLayerable : public QObject
{
2022-06-02 01:41:24 +00:00
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
2021-12-10 12:23:28 +00:00
public :
2022-06-02 01:41:24 +00:00
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 ;
2021-12-10 12:23:28 +00:00
signals :
2022-06-02 01:41:24 +00:00
void layerChanged ( QCPLayer * newLayer ) ;
2021-12-10 12:23:28 +00:00
protected :
2022-06-02 01:41:24 +00:00
// 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 ;
2021-12-10 12:23:28 +00:00
private :
2022-06-02 01:41:24 +00:00
Q_DISABLE_COPY ( QCPLayerable )
friend class QCustomPlot ;
friend class QCPAxisRect ;
2021-12-10 12:23:28 +00:00
} ;
class QCP_LIB_DECL QCPRange
{
public :
2022-06-02 01:41:24 +00:00
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;
2021-12-10 12:23:28 +00:00
} ;
Q_DECLARE_TYPEINFO ( QCPRange , Q_MOVABLE_TYPE ) ;
/* documentation of inline functions */
/*! \fn QCPRange &QCPRange::operator+=(const double& value)
2022-06-02 01:41:24 +00:00
2021-12-10 12:23:28 +00:00
Adds \ a value to both boundaries of the range .
*/
/*! \fn QCPRange &QCPRange::operator-=(const double& value)
2022-06-02 01:41:24 +00:00
2021-12-10 12:23:28 +00:00
Subtracts \ a value from both boundaries of the range .
*/
/*! \fn QCPRange &QCPRange::operator*=(const double& value)
2022-06-02 01:41:24 +00:00
2021-12-10 12:23:28 +00:00
Multiplies both boundaries of the range by \ a value .
*/
/*! \fn QCPRange &QCPRange::operator/=(const double& value)
2022-06-02 01:41:24 +00:00
2021-12-10 12:23:28 +00:00
Divides both boundaries of the range by \ a value .
*/
/* end documentation of inline functions */
/*!
Adds \ a value to both boundaries of the range .
*/
2022-06-02 01:41:24 +00:00
inline const QCPRange operator + ( const QCPRange & range , double value )
2021-12-10 12:23:28 +00:00
{
2022-06-02 01:41:24 +00:00
QCPRange result ( range ) ;
result + = value ;
return result ;
2021-12-10 12:23:28 +00:00
}
/*!
Adds \ a value to both boundaries of the range .
*/
2022-06-02 01:41:24 +00:00
inline const QCPRange operator + ( double value , const QCPRange & range )
2021-12-10 12:23:28 +00:00
{
2022-06-02 01:41:24 +00:00
QCPRange result ( range ) ;
result + = value ;
return result ;
2021-12-10 12:23:28 +00:00
}
/*!
Subtracts \ a value from both boundaries of the range .
*/
2022-06-02 01:41:24 +00:00
inline const QCPRange operator - ( const QCPRange & range , double value )
2021-12-10 12:23:28 +00:00
{
2022-06-02 01:41:24 +00:00
QCPRange result ( range ) ;
result - = value ;
return result ;
2021-12-10 12:23:28 +00:00
}
/*!
Multiplies both boundaries of the range by \ a value .
*/
2022-06-02 01:41:24 +00:00
inline const QCPRange operator * ( const QCPRange & range , double value )
2021-12-10 12:23:28 +00:00
{
2022-06-02 01:41:24 +00:00
QCPRange result ( range ) ;
result * = value ;
return result ;
2021-12-10 12:23:28 +00:00
}
/*!
Multiplies both boundaries of the range by \ a value .
*/
2022-06-02 01:41:24 +00:00
inline const QCPRange operator * ( double value , const QCPRange & range )
2021-12-10 12:23:28 +00:00
{
2022-06-02 01:41:24 +00:00
QCPRange result ( range ) ;
result * = value ;
return result ;
2021-12-10 12:23:28 +00:00
}
/*!
Divides both boundaries of the range by \ a value .
*/
2022-06-02 01:41:24 +00:00
inline const QCPRange operator / ( const QCPRange & range , double value )
2021-12-10 12:23:28 +00:00
{
2022-06-02 01:41:24 +00:00
QCPRange result ( range ) ;
result / = value ;
return result ;
2021-12-10 12:23:28 +00:00
}
class QCP_LIB_DECL QCPMarginGroup : public QObject
{
2022-06-02 01:41:24 +00:00
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 ( ) ;
2021-12-10 12:23:28 +00:00
protected :
2022-06-02 01:41:24 +00:00
// 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 ) ;
2021-12-10 12:23:28 +00:00
private :
2022-06-02 01:41:24 +00:00
Q_DISABLE_COPY ( QCPMarginGroup )
friend class QCPLayoutElement ;
2021-12-10 12:23:28 +00:00
} ;
class QCP_LIB_DECL QCPLayoutElement : public QCPLayerable
{
2022-06-02 01:41:24 +00:00
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
2021-12-10 12:23:28 +00:00
public :
2022-06-02 01:41:24 +00:00
/*!
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 ;
2021-12-10 12:23:28 +00:00
protected :
2022-06-02 01:41:24 +00:00
// 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 ) ;
2021-12-10 12:23:28 +00:00
private :
2022-06-02 01:41:24 +00:00
Q_DISABLE_COPY ( QCPLayoutElement )
friend class QCustomPlot ;
friend class QCPLayout ;
friend class QCPMarginGroup ;
2021-12-10 12:23:28 +00:00
} ;
class QCP_LIB_DECL QCPLayout : public QCPLayoutElement
{
2022-06-02 01:41:24 +00:00
Q_OBJECT
2021-12-10 12:23:28 +00:00
public :
2022-06-02 01:41:24 +00:00
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 ( ) ;
2021-12-10 12:23:28 +00:00
protected :
2022-06-02 01:41:24 +00:00
// 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 ;
2021-12-10 12:23:28 +00:00
private :
2022-06-02 01:41:24 +00:00
Q_DISABLE_COPY ( QCPLayout )
friend class QCPLayoutElement ;
2021-12-10 12:23:28 +00:00
} ;
class QCP_LIB_DECL QCPLayoutGrid : public QCPLayout
{
2022-06-02 01:41:24 +00:00
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
2021-12-10 12:23:28 +00:00
public :
2022-06-02 01:41:24 +00:00
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 ) ;
2021-12-10 12:23:28 +00:00
protected :
2022-06-02 01:41:24 +00:00
// 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 ;
2021-12-10 12:23:28 +00:00
private :
2022-06-02 01:41:24 +00:00
Q_DISABLE_COPY ( QCPLayoutGrid )
2021-12-10 12:23:28 +00:00
} ;
class QCP_LIB_DECL QCPLayoutInset : public QCPLayout
{
2022-06-02 01:41:24 +00:00
Q_OBJECT
2021-12-10 12:23:28 +00:00
public :
2022-06-02 01:41:24 +00:00
/*!
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 ) ;
2021-12-10 12:23:28 +00:00
protected :
2022-06-02 01:41:24 +00:00
// property members:
QList < QCPLayoutElement * > mElements ;
QList < InsetPlacement > mInsetPlacement ;
QList < Qt : : Alignment > mInsetAlignment ;
QList < QRectF > mInsetRect ;
2021-12-10 12:23:28 +00:00
private :
2022-06-02 01:41:24 +00:00
Q_DISABLE_COPY ( QCPLayoutInset )
2021-12-10 12:23:28 +00:00
} ;
class QCP_LIB_DECL QCPLineEnding
{
2022-06-02 01:41:24 +00:00
Q_GADGET
2021-12-10 12:23:28 +00:00
public :
2022-06-02 01:41:24 +00:00
/*!
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 ;
2021-12-10 12:23:28 +00:00
protected :
2022-06-02 01:41:24 +00:00
// property members:
EndingStyle mStyle ;
double mWidth , mLength ;
bool mInverted ;
2021-12-10 12:23:28 +00:00
} ;
Q_DECLARE_TYPEINFO ( QCPLineEnding , Q_MOVABLE_TYPE ) ;
2022-06-02 01:41:24 +00:00
class QCP_LIB_DECL QCPGrid : public QCPLayerable
2021-12-10 12:23:28 +00:00
{
2022-06-02 01:41:24 +00:00
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
2021-12-10 12:23:28 +00:00
public :
2022-06-02 01:41:24 +00:00
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 ) ;
2021-12-10 12:23:28 +00:00
protected :
2022-06-02 01:41:24 +00:00
// 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 ;
2021-12-10 12:23:28 +00:00
} ;
class QCP_LIB_DECL QCPAxis : public QCPLayerable
{
2022-06-02 01:41:24 +00:00
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
2021-12-10 12:23:28 +00:00
public :
2022-06-02 01:41:24 +00:00
/*!
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 ) ;
2021-12-10 12:23:28 +00:00
signals :
2022-06-02 01:41:24 +00:00
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 ) ;
2021-12-10 12:23:28 +00:00
protected :
2022-06-02 01:41:24 +00:00
// 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 ;
2021-12-10 12:23:28 +00:00
private :
2022-06-02 01:41:24 +00:00
Q_DISABLE_COPY ( QCPAxis )
friend class QCustomPlot ;
friend class QCPGrid ;
friend class QCPAxisRect ;
2021-12-10 12:23:28 +00:00
} ;
Q_DECLARE_OPERATORS_FOR_FLAGS ( QCPAxis : : SelectableParts )
Q_DECLARE_OPERATORS_FOR_FLAGS ( QCPAxis : : AxisTypes )
Q_DECLARE_METATYPE ( QCPAxis : : SelectablePart )
class QCPAxisPainterPrivate
{
public :
2022-06-02 01:41:24 +00:00
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 ;
2021-12-10 12:23:28 +00:00
protected :
2022-06-02 01:41:24 +00:00
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 ;
2021-12-10 12:23:28 +00:00
} ;
class QCP_LIB_DECL QCPAbstractPlottable : public QCPLayerable
{
2022-06-02 01:41:24 +00:00
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
2021-12-10 12:23:28 +00:00
public :
2022-06-02 01:41:24 +00:00
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 ;
2021-12-10 12:23:28 +00:00
signals :
2022-06-02 01:41:24 +00:00
void selectionChanged ( bool selected ) ;
void selectableChanged ( bool selectable ) ;
2021-12-10 12:23:28 +00:00
protected :
2022-06-02 01:41:24 +00:00
/*!
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 ;
2021-12-10 12:23:28 +00:00
private :
2022-06-02 01:41:24 +00:00
Q_DISABLE_COPY ( QCPAbstractPlottable )
friend class QCustomPlot ;
friend class QCPAxis ;
friend class QCPPlottableLegendItem ;
2021-12-10 12:23:28 +00:00
} ;
class QCP_LIB_DECL QCPItemAnchor
{
public :
2022-06-02 01:41:24 +00:00
QCPItemAnchor ( QCustomPlot * parentPlot , QCPAbstractItem * parentItem , const QString name , int anchorId = - 1 ) ;
virtual ~ QCPItemAnchor ( ) ;
// getters:
QString name ( ) const {
return mName ;
}
virtual QPointF pixelPoint ( ) const ;
2021-12-10 12:23:28 +00:00
protected :
2022-06-02 01:41:24 +00:00
// 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
2021-12-10 12:23:28 +00:00
private :
2022-06-02 01:41:24 +00:00
Q_DISABLE_COPY ( QCPItemAnchor )
friend class QCPItemPosition ;
2021-12-10 12:23:28 +00:00
} ;
class QCP_LIB_DECL QCPItemPosition : public QCPItemAnchor
{
public :
2022-06-02 01:41:24 +00:00
/*!
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 ) ;
2021-12-10 12:23:28 +00:00
protected :
2022-06-02 01:41:24 +00:00
// 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 ;
}
2021-12-10 12:23:28 +00:00
private :
2022-06-02 01:41:24 +00:00
Q_DISABLE_COPY ( QCPItemPosition )
2021-12-10 12:23:28 +00:00
} ;
class QCP_LIB_DECL QCPAbstractItem : public QCPLayerable
{
2022-06-02 01:41:24 +00:00
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
2021-12-10 12:23:28 +00:00
public :
2022-06-02 01:41:24 +00:00
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 ;
2021-12-10 12:23:28 +00:00
signals :
2022-06-02 01:41:24 +00:00
void selectionChanged ( bool selected ) ;
void selectableChanged ( bool selectable ) ;
2021-12-10 12:23:28 +00:00
protected :
2022-06-02 01:41:24 +00:00
// 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 ) ;
2021-12-10 12:23:28 +00:00
private :
2022-06-02 01:41:24 +00:00
Q_DISABLE_COPY ( QCPAbstractItem )
friend class QCustomPlot ;
friend class QCPItemAnchor ;
2021-12-10 12:23:28 +00:00
} ;
class QCP_LIB_DECL QCustomPlot : public QWidget
{
2022-06-02 01:41:24 +00:00
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
2021-12-10 12:23:28 +00:00
public :
2022-06-02 01:41:24 +00:00
/*!
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 & notAntialiasedElements ) ;
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 ;
2021-12-10 12:23:28 +00:00
signals :
2022-06-02 01:41:24 +00:00
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 ( ) ;
2021-12-10 12:23:28 +00:00
protected :
2022-06-02 01:41:24 +00:00
// 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 ;
2021-12-10 12:23:28 +00:00
} ;
class QCP_LIB_DECL QCPColorGradient
{
2022-06-02 01:41:24 +00:00
Q_GADGET
2021-12-10 12:23:28 +00:00
public :
2022-06-02 01:41:24 +00:00
/*!
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 ;
2021-12-10 12:23:28 +00:00
protected :
2022-06-02 01:41:24 +00:00
void updateColorBuffer ( ) ;
// property members:
int mLevelCount ;
QMap < double , QColor > mColorStops ;
ColorInterpolation mColorInterpolation ;
bool mPeriodic ;
// non-property members:
QVector < QRgb > mColorBuffer ;
bool mColorBufferInvalidated ;
2021-12-10 12:23:28 +00:00
} ;
class QCP_LIB_DECL QCPAxisRect : public QCPLayoutElement
{
2022-06-02 01:41:24 +00:00
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
2021-12-10 12:23:28 +00:00
public :
2022-06-02 01:41:24 +00:00
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 ;
2021-12-10 12:23:28 +00:00
protected :
2022-06-02 01:41:24 +00:00
// 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 ) ;
2021-12-10 12:23:28 +00:00
private :
2022-06-02 01:41:24 +00:00
Q_DISABLE_COPY ( QCPAxisRect )
friend class QCustomPlot ;
2021-12-10 12:23:28 +00:00
} ;
class QCP_LIB_DECL QCPAbstractLegendItem : public QCPLayoutElement
{
2022-06-02 01:41:24 +00:00
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
2021-12-10 12:23:28 +00:00
public :
2022-06-02 01:41:24 +00:00
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 ;
2021-12-10 12:23:28 +00:00
signals :
2022-06-02 01:41:24 +00:00
void selectionChanged ( bool selected ) ;
void selectableChanged ( bool selectable ) ;
2021-12-10 12:23:28 +00:00
protected :
2022-06-02 01:41:24 +00:00
// 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 ) ;
2021-12-10 12:23:28 +00:00
private :
2022-06-02 01:41:24 +00:00
Q_DISABLE_COPY ( QCPAbstractLegendItem )
friend class QCPLegend ;
2021-12-10 12:23:28 +00:00
} ;
class QCP_LIB_DECL QCPPlottableLegendItem : public QCPAbstractLegendItem
{
2022-06-02 01:41:24 +00:00
Q_OBJECT
public : QCPPlottableLegendItem ( QCPLegend * parent , QCPAbstractPlottable * plottable ) ;
// getters:
QCPAbstractPlottable * plottable ( ) {
return mPlottable ;
}
2021-12-10 12:23:28 +00:00
protected :
2022-06-02 01:41:24 +00:00
// 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 ;
2021-12-10 12:23:28 +00:00
} ;
class QCP_LIB_DECL QCPLegend : public QCPLayoutGrid
{
2022-06-02 01:41:24 +00:00
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
2021-12-10 12:23:28 +00:00
public :
2022-06-02 01:41:24 +00:00
/*!
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 ;
2021-12-10 12:23:28 +00:00
signals :
2022-06-02 01:41:24 +00:00
void selectionChanged ( QCPLegend : : SelectableParts parts ) ;
void selectableChanged ( QCPLegend : : SelectableParts parts ) ;
2021-12-10 12:23:28 +00:00
protected :
2022-06-02 01:41:24 +00:00
// 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 ;
2021-12-10 12:23:28 +00:00
private :
2022-06-02 01:41:24 +00:00
Q_DISABLE_COPY ( QCPLegend )
friend class QCustomPlot ;
friend class QCPAbstractLegendItem ;
2021-12-10 12:23:28 +00:00
} ;
Q_DECLARE_OPERATORS_FOR_FLAGS ( QCPLegend : : SelectableParts )
Q_DECLARE_METATYPE ( QCPLegend : : SelectablePart )
class QCP_LIB_DECL QCPPlotTitle : public QCPLayoutElement
{
2022-06-02 01:41:24 +00:00
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
2021-12-10 12:23:28 +00:00
public :
2022-06-02 01:41:24 +00:00
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 ;
2021-12-10 12:23:28 +00:00
signals :
2022-06-02 01:41:24 +00:00
void selectionChanged ( bool selected ) ;
void selectableChanged ( bool selectable ) ;
2021-12-10 12:23:28 +00:00
protected :
2022-06-02 01:41:24 +00:00
// 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 ;
2021-12-10 12:23:28 +00:00
private :
2022-06-02 01:41:24 +00:00
Q_DISABLE_COPY ( QCPPlotTitle )
2021-12-10 12:23:28 +00:00
} ;
class QCPColorScaleAxisRectPrivate : public QCPAxisRect
{
2022-06-02 01:41:24 +00:00
Q_OBJECT
2021-12-10 12:23:28 +00:00
public :
2022-06-02 01:41:24 +00:00
explicit QCPColorScaleAxisRectPrivate ( QCPColorScale * parentColorScale ) ;
2021-12-10 12:23:28 +00:00
protected :
2022-06-02 01:41:24 +00:00
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 ;
2021-12-10 12:23:28 +00:00
} ;
class QCP_LIB_DECL QCPColorScale : public QCPLayoutElement
{
2022-06-02 01:41:24 +00:00
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
2021-12-10 12:23:28 +00:00
public :
2022-06-02 01:41:24 +00:00
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 ) ;
2021-12-10 12:23:28 +00:00
signals :
2022-06-02 01:41:24 +00:00
void dataRangeChanged ( QCPRange newRange ) ;
void dataScaleTypeChanged ( QCPAxis : : ScaleType scaleType ) ;
void gradientChanged ( QCPColorGradient newGradient ) ;
2021-12-10 12:23:28 +00:00
protected :
2022-06-02 01:41:24 +00:00
// 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 ) ;
2021-12-10 12:23:28 +00:00
private :
2022-06-02 01:41:24 +00:00
Q_DISABLE_COPY ( QCPColorScale )
friend class QCPColorScaleAxisRectPrivate ;
2021-12-10 12:23:28 +00:00
} ;
/*! \file */
class QCP_LIB_DECL QCPData
{
public :
2022-06-02 01:41:24 +00:00
QCPData ( ) ;
QCPData ( double key , double value ) ;
double key , value ;
double keyErrorPlus , keyErrorMinus ;
double valueErrorPlus , valueErrorMinus ;
2021-12-10 12:23:28 +00:00
} ;
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 .
2022-06-02 01:41:24 +00:00
2021-12-10 12:23:28 +00:00
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
{
2022-06-02 01:41:24 +00:00
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
2021-12-10 12:23:28 +00:00
public :
2022-06-02 01:41:24 +00:00
/*!
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
2021-12-10 12:23:28 +00:00
protected :
2022-06-02 01:41:24 +00:00
// 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
int smooth ;
public :
void setSmooth ( int smooth ) ;
protected :
// 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 ;
2021-12-10 12:23:28 +00:00
} ;
/*! \file */
class QCP_LIB_DECL QCPCurveData
{
public :
2022-06-02 01:41:24 +00:00
QCPCurveData ( ) ;
QCPCurveData ( double t , double key , double value ) ;
double t , key , value ;
2021-12-10 12:23:28 +00:00
} ;
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 .
2022-06-02 01:41:24 +00:00
2021-12-10 12:23:28 +00:00
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
{
2022-06-02 01:41:24 +00:00
Q_OBJECT
/// \cond INCLUDE_QPROPERTIES
Q_PROPERTY ( QCPScatterStyle scatterStyle READ scatterStyle WRITE setScatterStyle )
Q_PROPERTY ( LineStyle lineStyle READ lineStyle WRITE setLineStyle )
/// \endcond
2021-12-10 12:23:28 +00:00
public :
2022-06-02 01:41:24 +00:00
/*!
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 ;
2021-12-10 12:23:28 +00:00
protected :
2022-06-02 01:41:24 +00:00
// 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 ;
2021-12-10 12:23:28 +00:00
} ;
/*! \file */
class QCP_LIB_DECL QCPBarsGroup : public QObject
{
2022-06-02 01:41:24 +00:00
Q_OBJECT
/// \cond INCLUDE_QPROPERTIES
Q_PROPERTY ( SpacingType spacingType READ spacingType WRITE setSpacingType )
Q_PROPERTY ( double spacing READ spacing WRITE setSpacing )
/// \endcond
2021-12-10 12:23:28 +00:00
public :
2022-06-02 01:41:24 +00:00
/*!
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 ) ;
2021-12-10 12:23:28 +00:00
protected :
2022-06-02 01:41:24 +00:00
// 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 ) ;
2021-12-10 12:23:28 +00:00
private :
2022-06-02 01:41:24 +00:00
Q_DISABLE_COPY ( QCPBarsGroup )
friend class QCPBars ;
2021-12-10 12:23:28 +00:00
} ;
class QCP_LIB_DECL QCPBarData
{
public :
2022-06-02 01:41:24 +00:00
QCPBarData ( ) ;
QCPBarData ( double key , double value ) ;
double key , value ;
2021-12-10 12:23:28 +00:00
} ;
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 .
2022-06-02 01:41:24 +00:00
2021-12-10 12:23:28 +00:00
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
{
2022-06-02 01:41:24 +00:00
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
2021-12-10 12:23:28 +00:00
public :
2022-06-02 01:41:24 +00:00
/*!
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 ;
2021-12-10 12:23:28 +00:00
protected :
2022-06-02 01:41:24 +00:00
// 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 ;
2021-12-10 12:23:28 +00:00
} ;
/*! \file */
class QCP_LIB_DECL QCPStatisticalBox : public QCPAbstractPlottable
{
2022-06-02 01:41:24 +00:00
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
2021-12-10 12:23:28 +00:00
public :
2022-06-02 01:41:24 +00:00
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 ;
2021-12-10 12:23:28 +00:00
protected :
2022-06-02 01:41:24 +00:00
// 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 ;
2021-12-10 12:23:28 +00:00
} ;
class QCP_LIB_DECL QCPColorMapData
{
public :
2022-06-02 01:41:24 +00:00
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 ;
2021-12-10 12:23:28 +00:00
protected :
2022-06-02 01:41:24 +00:00
// property members:
int mKeySize , mValueSize ;
QCPRange mKeyRange , mValueRange ;
bool mIsEmpty ;
// non-property members:
double * mData ;
QCPRange mDataBounds ;
bool mDataModified ;
friend class QCPColorMap ;
2021-12-10 12:23:28 +00:00
} ;
class QCP_LIB_DECL QCPColorMap : public QCPAbstractPlottable
{
2022-06-02 01:41:24 +00:00
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
2021-12-10 12:23:28 +00:00
public :
2022-06-02 01:41:24 +00:00
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 ;
2021-12-10 12:23:28 +00:00
signals :
2022-06-02 01:41:24 +00:00
void dataRangeChanged ( QCPRange newRange ) ;
void dataScaleTypeChanged ( QCPAxis : : ScaleType scaleType ) ;
void gradientChanged ( QCPColorGradient newGradient ) ;
2021-12-10 12:23:28 +00:00
protected :
2022-06-02 01:41:24 +00:00
// 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 ;
2021-12-10 12:23:28 +00:00
} ;
/*! \file */
class QCP_LIB_DECL QCPFinancialData
{
public :
2022-06-02 01:41:24 +00:00
QCPFinancialData ( ) ;
QCPFinancialData ( double key , double open , double high , double low , double close ) ;
double key , open , high , low , close ;
2021-12-10 12:23:28 +00:00
} ;
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 .
2022-06-02 01:41:24 +00:00
2021-12-10 12:23:28 +00:00
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
{
2022-06-02 01:41:24 +00:00
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
2021-12-10 12:23:28 +00:00
public :
2022-06-02 01:41:24 +00:00
/*!
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 ) ;
2021-12-10 12:23:28 +00:00
protected :
2022-06-02 01:41:24 +00:00
// 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 ;
2021-12-10 12:23:28 +00:00
} ;
class QCP_LIB_DECL QCPItemStraightLine : public QCPAbstractItem
{
2022-06-02 01:41:24 +00:00
Q_OBJECT
/// \cond INCLUDE_QPROPERTIES Q_PROPERTY(QPen pen READ pen WRITE setPen)
Q_PROPERTY ( QPen selectedPen READ selectedPen WRITE setSelectedPen )
/// \endcond
2021-12-10 12:23:28 +00:00
public :
2022-06-02 01:41:24 +00:00
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 ;
2021-12-10 12:23:28 +00:00
protected :
2022-06-02 01:41:24 +00:00
// 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 ;
2021-12-10 12:23:28 +00:00
} ;
class QCP_LIB_DECL QCPItemLine : public QCPAbstractItem
{
2022-06-02 01:41:24 +00:00
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
2021-12-10 12:23:28 +00:00
public :
2022-06-02 01:41:24 +00:00
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 ;
2021-12-10 12:23:28 +00:00
protected :
2022-06-02 01:41:24 +00:00
// 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 ;
2021-12-10 12:23:28 +00:00
} ;
class QCP_LIB_DECL QCPItemCurve : public QCPAbstractItem
{
2022-06-02 01:41:24 +00:00
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
2021-12-10 12:23:28 +00:00
public :
2022-06-02 01:41:24 +00:00
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 ;
2021-12-10 12:23:28 +00:00
protected :
2022-06-02 01:41:24 +00:00
// property members:
QPen mPen , mSelectedPen ;
QCPLineEnding mHead , mTail ;
// reimplemented virtual methods:
virtual void draw ( QCPPainter * painter ) ;
// non-virtual methods:
QPen mainPen ( ) const ;
2021-12-10 12:23:28 +00:00
} ;
class QCP_LIB_DECL QCPItemRect : public QCPAbstractItem
{
2022-06-02 01:41:24 +00:00
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
2021-12-10 12:23:28 +00:00
public :
2022-06-02 01:41:24 +00:00
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 ;
2021-12-10 12:23:28 +00:00
protected :
2022-06-02 01:41:24 +00:00
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 ;
2021-12-10 12:23:28 +00:00
} ;
class QCP_LIB_DECL QCPItemText : public QCPAbstractItem
{
2022-06-02 01:41:24 +00:00
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
2021-12-10 12:23:28 +00:00
public :
2022-06-02 01:41:24 +00:00
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 ;
2021-12-10 12:23:28 +00:00
protected :
2022-06-02 01:41:24 +00:00
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 ;
2021-12-10 12:23:28 +00:00
} ;
class QCP_LIB_DECL QCPItemEllipse : public QCPAbstractItem
{
2022-06-02 01:41:24 +00:00
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
2021-12-10 12:23:28 +00:00
public :
2022-06-02 01:41:24 +00:00
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 ;
2021-12-10 12:23:28 +00:00
protected :
2022-06-02 01:41:24 +00:00
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 ;
2021-12-10 12:23:28 +00:00
} ;
class QCP_LIB_DECL QCPItemPixmap : public QCPAbstractItem
{
2022-06-02 01:41:24 +00:00
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
2021-12-10 12:23:28 +00:00
public :
2022-06-02 01:41:24 +00:00
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 ;
2021-12-10 12:23:28 +00:00
protected :
2022-06-02 01:41:24 +00:00
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 ;
2021-12-10 12:23:28 +00:00
} ;
class QCP_LIB_DECL QCPItemTracer : public QCPAbstractItem
{
2022-06-02 01:41:24 +00:00
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
2021-12-10 12:23:28 +00:00
public :
2022-06-02 01:41:24 +00:00
/*!
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 ;
2021-12-10 12:23:28 +00:00
protected :
2022-06-02 01:41:24 +00:00
// 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 ;
2021-12-10 12:23:28 +00:00
} ;
class QCP_LIB_DECL QCPItemBracket : public QCPAbstractItem
{
2022-06-02 01:41:24 +00:00
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
2021-12-10 12:23:28 +00:00
public :
2022-06-02 01:41:24 +00:00
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 ;
2021-12-10 12:23:28 +00:00
protected :
2022-06-02 01:41:24 +00:00
// 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 ;
2021-12-10 12:23:28 +00:00
} ;
# endif // QCUSTOMPLOT_H