2013-08-27 18:13:20 +00:00
/***************************************************************************
* * * *
* * QCustomPlot , an easy to use , modern plotting widget for Qt * *
2014-03-22 14:31:20 +00:00
* * Copyright ( C ) 2011 , 2012 , 2013 , 2014 Emanuel Eichhammer * *
2013-08-27 18:13:20 +00:00
* * * *
* * 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 2 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/ **
* * Emanuel Eichhammer has granted Wireshark permission to use QCustomPlot * *
* * under the terms of the GNU General Public License version 2. * *
2014-03-22 14:31:20 +00:00
* * Date : 14.03 .14 * *
* * Version : 1.2 .0 * *
2013-08-27 18:13:20 +00:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
# ifndef QCUSTOMPLOT_H
# define QCUSTOMPLOT_H
# include <QObject>
2014-03-22 14:31:20 +00:00
# include <QPointer>
2013-08-27 18:13:20 +00:00
# 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>
2014-03-22 14:31:20 +00:00
# include <QPrintEngine>
2013-08-27 18:13:20 +00:00
# else
# include <QtNumeric>
2014-03-22 14:31:20 +00:00
# include <QtPrintSupport>
2013-08-27 18:13:20 +00:00
# endif
class QCPPainter ;
class QCustomPlot ;
class QCPLayerable ;
class QCPLayoutElement ;
class QCPLayout ;
class QCPAxis ;
class QCPAxisRect ;
2014-03-22 14:31:20 +00:00
class QCPAxisPainterPrivate ;
2013-08-27 18:13:20 +00:00
class QCPAbstractPlottable ;
class QCPGraph ;
class QCPAbstractItem ;
class QCPItemPosition ;
class QCPLayer ;
class QCPPlotTitle ;
class QCPLegend ;
class QCPAbstractLegendItem ;
2014-03-22 14:31:20 +00:00
class QCPColorMap ;
class QCPColorScale ;
2013-08-27 18:13:20 +00:00
/*! \file */
// decl definitions for shared library compilation/usage:
# if defined(QCUSTOMPLOT_COMPILE_LIBRARY)
# define QCP_LIB_DECL Q_DECL_EXPORT
# elif defined(QCUSTOMPLOT_USE_LIBRARY)
# define QCP_LIB_DECL Q_DECL_IMPORT
# else
# define QCP_LIB_DECL
# endif
/*!
The QCP Namespace contains general enums and QFlags used throughout the QCustomPlot library
*/
namespace QCP
{
/*!
Defines the sides of a rectangular entity to which margins can be applied .
\ see QCPLayoutElement : : setAutoMargins , QCPAxisRect : : setAutoMargins
*/
enum MarginSide { msLeft = 0x01 ///< <tt>0x01</tt> left margin
, msRight = 0x02 ///< <tt>0x02</tt> right margin
, msTop = 0x04 ///< <tt>0x04</tt> top margin
, msBottom = 0x08 ///< <tt>0x08</tt> bottom margin
, msAll = 0xFF ///< <tt>0xFF</tt> all margins
, msNone = 0x00 ///< <tt>0x00</tt> no margin
} ;
Q_DECLARE_FLAGS ( MarginSides , MarginSide )
/*!
Defines what objects of a plot can be forcibly drawn antialiased / not antialiased . If an object is
neither forcibly drawn antialiased nor forcibly drawn not antialiased , it is up to the respective
element how it is drawn . Typically it provides a \ a setAntialiased function for this .
\ c AntialiasedElements is a flag of or - combined elements of this enum type .
\ see QCustomPlot : : setAntialiasedElements , QCustomPlot : : setNotAntialiasedElements
*/
enum AntialiasedElement { aeAxes = 0x0001 ///< <tt>0x0001</tt> Axis base line and tick marks
, aeGrid = 0x0002 ///< <tt>0x0002</tt> Grid lines
, aeSubGrid = 0x0004 ///< <tt>0x0004</tt> Sub grid lines
, aeLegend = 0x0008 ///< <tt>0x0008</tt> Legend box
, aeLegendItems = 0x0010 ///< <tt>0x0010</tt> Legend items
, aePlottables = 0x0020 ///< <tt>0x0020</tt> Main lines of plottables (excluding error bars, see element \ref aeErrorBars)
, aeItems = 0x0040 ///< <tt>0x0040</tt> Main lines of items
, aeScatters = 0x0080 ///< <tt>0x0080</tt> Scatter symbols of plottables (excluding scatter symbols of type ssPixmap)
, aeErrorBars = 0x0100 ///< <tt>0x0100</tt> Error bars
, aeFills = 0x0200 ///< <tt>0x0200</tt> Borders of fills (e.g. under or between graphs)
, aeZeroLine = 0x0400 ///< <tt>0x0400</tt> Zero-lines, see \ref QCPGrid::setZeroLinePen
, aeAll = 0xFFFF ///< <tt>0xFFFF</tt> All elements
, aeNone = 0x0000 ///< <tt>0x0000</tt> No elements
} ;
Q_DECLARE_FLAGS ( AntialiasedElements , AntialiasedElement )
/*!
Defines plotting hints that control various aspects of the quality and speed of plotting .
\ see QCustomPlot : : setPlottingHints
*/
enum PlottingHint { phNone = 0x000 ///< <tt>0x000</tt> No hints are set
, phFastPolylines = 0x001 ///< <tt>0x001</tt> Graph/Curve lines are drawn with a faster method. This reduces the quality
///< especially of the line segment joins. (Only relevant for solid line pens.)
2014-03-22 14:31:20 +00:00
, 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).
2013-08-27 18:13:20 +00:00
, phCacheLabels = 0x004 ///< <tt>0x004</tt> axis (tick) labels will be cached as pixmaps, increasing replot performance.
} ;
Q_DECLARE_FLAGS ( PlottingHints , PlottingHint )
/*!
Defines the mouse interactions possible with QCustomPlot .
\ c Interactions is a flag of or - combined elements of this enum type .
\ see QCustomPlot : : setInteractions
*/
enum Interaction { iRangeDrag = 0x001 ///< <tt>0x001</tt> Axis ranges are draggable (see \ref QCPAxisRect::setRangeDrag, \ref QCPAxisRect::setRangeDragAxes)
, iRangeZoom = 0x002 ///< <tt>0x002</tt> Axis ranges are zoomable with the mouse wheel (see \ref QCPAxisRect::setRangeZoom, \ref QCPAxisRect::setRangeZoomAxes)
, iMultiSelect = 0x004 ///< <tt>0x004</tt> The user can select multiple objects by holding the modifier set by \ref QCustomPlot::setMultiSelectModifier while clicking
, iSelectPlottables = 0x008 ///< <tt>0x008</tt> Plottables are selectable (e.g. graphs, curves, bars,... see QCPAbstractPlottable)
, iSelectAxes = 0x010 ///< <tt>0x010</tt> Axes are selectable (or parts of them, see QCPAxis::setSelectableParts)
, iSelectLegend = 0x020 ///< <tt>0x020</tt> Legends are selectable (or their child items, see QCPLegend::setSelectableParts)
, iSelectItems = 0x040 ///< <tt>0x040</tt> Items are selectable (Rectangles, Arrows, Textitems, etc. see \ref QCPAbstractItem)
, iSelectOther = 0x080 ///< <tt>0x080</tt> All other objects are selectable (e.g. your own derived layerables, the plot title,...)
} ;
Q_DECLARE_FLAGS ( Interactions , Interaction )
/*! \internal
Returns whether the specified \ a value is considered an invalid data value for plottables ( i . e .
is \ e nan or \ e + / - inf ) . This function is used to check data validity upon replots , when the
compiler flag \ c QCUSTOMPLOT_CHECK_DATA is set .
*/
inline bool isInvalidData ( double value )
{
2014-03-22 14:31:20 +00:00
return qIsNaN ( value ) | | qIsInf ( value ) ;
2013-08-27 18:13:20 +00:00
}
/*! \internal
\ overload
Checks two arguments instead of one .
*/
inline bool isInvalidData ( double value1 , double value2 )
{
return isInvalidData ( value1 ) | | isInvalidData ( value2 ) ;
}
/*! \internal
Sets the specified \ a side of \ a margins to \ a value
\ see getMarginValue
*/
inline void setMarginValue ( QMargins & margins , QCP : : MarginSide side , int value )
{
switch ( side )
{
case QCP : : msLeft : margins . setLeft ( value ) ; break ;
case QCP : : msRight : margins . setRight ( value ) ; break ;
case QCP : : msTop : margins . setTop ( value ) ; break ;
case QCP : : msBottom : margins . setBottom ( value ) ; break ;
case QCP : : msAll : margins = QMargins ( value , value , value , value ) ; break ;
default : break ;
}
}
/*! \internal
Returns the value of the specified \ a side of \ a margins . If \ a side is \ ref QCP : : msNone or
\ ref QCP : : msAll , returns 0.
\ see setMarginValue
*/
inline int getMarginValue ( const QMargins & margins , QCP : : MarginSide side )
{
switch ( side )
{
case QCP : : msLeft : return margins . left ( ) ;
case QCP : : msRight : return margins . right ( ) ;
case QCP : : msTop : return margins . top ( ) ;
case QCP : : msBottom : return margins . bottom ( ) ;
default : break ;
}
return 0 ;
}
} // end of namespace QCP
Q_DECLARE_OPERATORS_FOR_FLAGS ( QCP : : AntialiasedElements )
Q_DECLARE_OPERATORS_FOR_FLAGS ( QCP : : PlottingHints )
Q_DECLARE_OPERATORS_FOR_FLAGS ( QCP : : MarginSides )
Q_DECLARE_OPERATORS_FOR_FLAGS ( QCP : : Interactions )
class QCP_LIB_DECL QCPScatterStyle
{
Q_GADGET
public :
/*!
Defines the shape used for scatter points .
On plottables / items that draw scatters , the sizes of these visualizations ( with exception of
\ ref ssDot and \ ref ssPixmap ) can be controlled with the \ ref setSize function . Scatters are
drawn with the pen and brush specified with \ ref setPen and \ ref setBrush .
*/
Q_ENUMS ( ScatterShape )
enum ScatterShape { ssNone ///< no scatter symbols are drawn (e.g. in QCPGraph, data only represented with lines)
, ssDot ///< \enumimage{ssDot.png} a single pixel (use \ref ssDisc or \ref ssCircle if you want a round shape with a certain radius)
, ssCross ///< \enumimage{ssCross.png} a cross
, ssPlus ///< \enumimage{ssPlus.png} a plus
, ssCircle ///< \enumimage{ssCircle.png} a circle
2014-03-22 14:31:20 +00:00
, ssDisc ///< \enumimage{ssDisc.png} a circle which is filled with the pen's color (not the brush as with ssCircle)
2013-08-27 18:13:20 +00:00
, 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
2014-03-22 14:31:20 +00:00
, ssPixmap ///< a custom pixmap specified by \ref setPixmap, centered on the data point coordinates
2013-08-27 18:13:20 +00:00
, ssCustom ///< custom painter operations are performed per scatter (As QPainterPath, see \ref setCustomPath)
} ;
QCPScatterStyle ( ) ;
QCPScatterStyle ( ScatterShape shape , double size = 6 ) ;
QCPScatterStyle ( ScatterShape shape , const QColor & color , double size ) ;
QCPScatterStyle ( ScatterShape shape , const QColor & color , const QColor & fill , double size ) ;
QCPScatterStyle ( ScatterShape shape , const QPen & pen , const QBrush & brush , double size ) ;
QCPScatterStyle ( const QPixmap & pixmap ) ;
QCPScatterStyle ( const QPainterPath & customPath , const QPen & pen , const QBrush & brush = Qt : : NoBrush , double size = 6 ) ;
// getters:
double size ( ) const { return mSize ; }
ScatterShape shape ( ) const { return mShape ; }
QPen pen ( ) const { return mPen ; }
QBrush brush ( ) const { return mBrush ; }
QPixmap pixmap ( ) const { return mPixmap ; }
QPainterPath customPath ( ) const { return mCustomPath ; }
// setters:
void setSize ( double size ) ;
void setShape ( ScatterShape shape ) ;
void setPen ( const QPen & pen ) ;
void setBrush ( const QBrush & brush ) ;
void setPixmap ( const QPixmap & pixmap ) ;
void setCustomPath ( const QPainterPath & customPath ) ;
// non-property methods:
bool isNone ( ) const { return mShape = = ssNone ; }
bool isPenDefined ( ) const { return mPenDefined ; }
void applyTo ( QCPPainter * painter , const QPen & defaultPen ) const ;
void drawShape ( QCPPainter * painter , QPointF pos ) const ;
void drawShape ( QCPPainter * painter , double x , double y ) const ;
protected :
// property members:
double mSize ;
ScatterShape mShape ;
QPen mPen ;
QBrush mBrush ;
QPixmap mPixmap ;
QPainterPath mCustomPath ;
// non-property members:
bool mPenDefined ;
} ;
Q_DECLARE_TYPEINFO ( QCPScatterStyle , Q_MOVABLE_TYPE ) ;
class QCP_LIB_DECL QCPPainter : public QPainter
{
Q_GADGET
public :
/*!
Defines special modes the painter can operate in . They disable or enable certain subsets of features / fixes / workarounds ,
depending on whether they are wanted on the respective output device .
*/
2014-03-22 14:31:20 +00:00
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.)
2013-08-27 18:13:20 +00:00
} ;
Q_FLAGS ( PainterMode PainterModes )
Q_DECLARE_FLAGS ( PainterModes , PainterMode )
QCPPainter ( ) ;
QCPPainter ( QPaintDevice * device ) ;
~ QCPPainter ( ) ;
// getters:
bool antialiasing ( ) const { return testRenderHint ( QPainter : : Antialiasing ) ; }
PainterModes modes ( ) const { return mModes ; }
// setters:
void setAntialiasing ( bool enabled ) ;
void setMode ( PainterMode mode , bool enabled = true ) ;
void setModes ( PainterModes modes ) ;
// methods hiding non-virtual base class functions (QPainter bug workarounds):
bool begin ( QPaintDevice * device ) ;
void setPen ( const QPen & pen ) ;
void setPen ( const QColor & color ) ;
void setPen ( Qt : : PenStyle penStyle ) ;
void drawLine ( const QLineF & line ) ;
void drawLine ( const QPointF & p1 , const QPointF & p2 ) { drawLine ( QLineF ( p1 , p2 ) ) ; }
void save ( ) ;
void restore ( ) ;
// non-virtual methods:
void makeNonCosmetic ( ) ;
protected :
// property members:
PainterModes mModes ;
bool mIsAntialiasing ;
// non-property members:
QStack < bool > mAntialiasingStack ;
} ;
Q_DECLARE_OPERATORS_FOR_FLAGS ( QCPPainter : : PainterModes )
class QCP_LIB_DECL QCPLayer : public QObject
{
Q_OBJECT
/// \cond INCLUDE_QPROPERTIES
Q_PROPERTY ( QCustomPlot * parentPlot READ parentPlot )
Q_PROPERTY ( QString name READ name )
Q_PROPERTY ( int index READ index )
Q_PROPERTY ( QList < QCPLayerable * > children READ children )
2014-03-22 14:31:20 +00:00
Q_PROPERTY ( bool visible READ visible WRITE setVisible )
2013-08-27 18:13:20 +00:00
/// \endcond
public :
QCPLayer ( QCustomPlot * parentPlot , const QString & layerName ) ;
~ QCPLayer ( ) ;
// getters:
QCustomPlot * parentPlot ( ) const { return mParentPlot ; }
QString name ( ) const { return mName ; }
int index ( ) const { return mIndex ; }
QList < QCPLayerable * > children ( ) const { return mChildren ; }
2014-03-22 14:31:20 +00:00
bool visible ( ) const { return mVisible ; }
// setters:
void setVisible ( bool visible ) ;
2013-08-27 18:13:20 +00:00
protected :
// property members:
QCustomPlot * mParentPlot ;
QString mName ;
int mIndex ;
QList < QCPLayerable * > mChildren ;
2014-03-22 14:31:20 +00:00
bool mVisible ;
2013-08-27 18:13:20 +00:00
// non-virtual methods:
void addChild ( QCPLayerable * layerable , bool prepend ) ;
void removeChild ( QCPLayerable * layerable ) ;
private :
Q_DISABLE_COPY ( QCPLayer )
friend class QCustomPlot ;
friend class QCPLayerable ;
} ;
class QCP_LIB_DECL QCPLayerable : public QObject
{
Q_OBJECT
/// \cond INCLUDE_QPROPERTIES
Q_PROPERTY ( bool visible READ visible WRITE setVisible )
Q_PROPERTY ( QCustomPlot * parentPlot READ parentPlot )
Q_PROPERTY ( QCPLayerable * parentLayerable READ parentLayerable )
2014-03-22 14:31:20 +00:00
Q_PROPERTY ( QCPLayer * layer READ layer WRITE setLayer NOTIFY layerChanged )
2013-08-27 18:13:20 +00:00
Q_PROPERTY ( bool antialiased READ antialiased WRITE setAntialiased )
/// \endcond
public :
QCPLayerable ( QCustomPlot * plot , QString targetLayer = " " , QCPLayerable * parentLayerable = 0 ) ;
~ QCPLayerable ( ) ;
// getters:
bool visible ( ) const { return mVisible ; }
QCustomPlot * parentPlot ( ) const { return mParentPlot ; }
QCPLayerable * parentLayerable ( ) const { return mParentLayerable . data ( ) ; }
QCPLayer * layer ( ) const { return mLayer ; }
bool antialiased ( ) const { return mAntialiased ; }
// setters:
void setVisible ( bool on ) ;
2014-03-22 14:31:20 +00:00
Q_SLOT bool setLayer ( QCPLayer * layer ) ;
2013-08-27 18:13:20 +00:00
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 ;
2014-03-22 14:31:20 +00:00
signals :
void layerChanged ( QCPLayer * newLayer ) ;
2013-08-27 18:13:20 +00:00
protected :
// property members:
bool mVisible ;
QCustomPlot * mParentPlot ;
2014-03-22 14:31:20 +00:00
QPointer < QCPLayerable > mParentLayerable ;
2013-08-27 18:13:20 +00:00
QCPLayer * mLayer ;
bool mAntialiased ;
// introduced virtual methods:
virtual void parentPlotInitialized ( QCustomPlot * parentPlot ) ;
virtual QCP : : Interaction selectionCategory ( ) const ;
virtual QRect clipRect ( ) const ;
virtual void applyDefaultAntialiasingHint ( QCPPainter * painter ) const = 0 ;
virtual void draw ( QCPPainter * painter ) = 0 ;
// events:
virtual void selectEvent ( QMouseEvent * event , bool additive , const QVariant & details , bool * selectionStateChanged ) ;
virtual void deselectEvent ( bool * selectionStateChanged ) ;
// non-property methods:
void initializeParentPlot ( QCustomPlot * parentPlot ) ;
void setParentLayerable ( QCPLayerable * parentLayerable ) ;
bool moveToLayer ( QCPLayer * layer , bool prepend ) ;
void applyAntialiasingHint ( QCPPainter * painter , bool localAntialiased , QCP : : AntialiasedElement overrideElement ) const ;
private :
Q_DISABLE_COPY ( QCPLayerable )
friend class QCustomPlot ;
friend class QCPAxisRect ;
} ;
class QCP_LIB_DECL QCPRange
{
public :
double lower , upper ;
QCPRange ( ) ;
QCPRange ( double lower , double upper ) ;
2014-03-22 14:31:20 +00:00
bool operator = = ( const QCPRange & other ) { return lower = = other . lower & & upper = = other . upper ; }
bool operator ! = ( const QCPRange & other ) { return ! ( * this = = other ) ; }
QCPRange & operator + = ( const double & value ) { lower + = value ; upper + = value ; return * this ; }
QCPRange & operator - = ( const double & value ) { lower - = value ; upper - = value ; return * this ; }
QCPRange & operator * = ( const double & value ) { lower * = value ; upper * = value ; return * this ; }
QCPRange & operator / = ( const double & value ) { lower / = value ; upper / = value ; return * this ; }
friend inline const QCPRange operator + ( const QCPRange & , double ) ;
friend inline const QCPRange operator + ( double , const QCPRange & ) ;
friend inline const QCPRange operator - ( const QCPRange & range , double value ) ;
friend inline const QCPRange operator * ( const QCPRange & range , double value ) ;
friend inline const QCPRange operator * ( double value , const QCPRange & range ) ;
friend inline const QCPRange operator / ( const QCPRange & range , double value ) ;
2013-08-27 18:13:20 +00:00
double size ( ) const ;
double center ( ) const ;
void normalize ( ) ;
2014-03-22 14:31:20 +00:00
void expand ( const QCPRange & otherRange ) ;
QCPRange expanded ( const QCPRange & otherRange ) const ;
2013-08-27 18:13:20 +00:00
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;
2014-03-22 14:31:20 +00:00
2013-08-27 18:13:20 +00:00
} ;
Q_DECLARE_TYPEINFO ( QCPRange , Q_MOVABLE_TYPE ) ;
2014-03-22 14:31:20 +00:00
/* documentation of inline functions */
/*! \fn QCPRange &QCPRange::operator+=(const double& value)
Adds \ a value to both boundaries of the range .
*/
/*! \fn QCPRange &QCPRange::operator-=(const double& value)
Subtracts \ a value from both boundaries of the range .
*/
/*! \fn QCPRange &QCPRange::operator*=(const double& value)
Multiplies both boundaries of the range by \ a value .
*/
/*! \fn QCPRange &QCPRange::operator/=(const double& value)
Divides both boundaries of the range by \ a value .
*/
/* end documentation of inline functions */
/*!
Adds \ a value to both boundaries of the range .
*/
inline const QCPRange operator + ( const QCPRange & range , double value )
{
QCPRange result ( range ) ;
result + = value ;
return result ;
}
/*!
Adds \ a value to both boundaries of the range .
*/
inline const QCPRange operator + ( double value , const QCPRange & range )
{
QCPRange result ( range ) ;
result + = value ;
return result ;
}
/*!
Subtracts \ a value from both boundaries of the range .
*/
inline const QCPRange operator - ( const QCPRange & range , double value )
{
QCPRange result ( range ) ;
result - = value ;
return result ;
}
/*!
Multiplies both boundaries of the range by \ a value .
*/
inline const QCPRange operator * ( const QCPRange & range , double value )
{
QCPRange result ( range ) ;
result * = value ;
return result ;
}
/*!
Multiplies both boundaries of the range by \ a value .
*/
inline const QCPRange operator * ( double value , const QCPRange & range )
{
QCPRange result ( range ) ;
result * = value ;
return result ;
}
/*!
Divides both boundaries of the range by \ a value .
*/
inline const QCPRange operator / ( const QCPRange & range , double value )
{
QCPRange result ( range ) ;
result / = value ;
return result ;
}
2013-08-27 18:13:20 +00:00
class QCP_LIB_DECL QCPMarginGroup : public QObject
{
Q_OBJECT
public :
QCPMarginGroup ( QCustomPlot * parentPlot ) ;
~ QCPMarginGroup ( ) ;
// non-virtual methods:
QList < QCPLayoutElement * > elements ( QCP : : MarginSide side ) const { return mChildren . value ( side ) ; }
bool isEmpty ( ) const ;
void clear ( ) ;
protected :
// non-property members:
QCustomPlot * mParentPlot ;
QHash < QCP : : MarginSide , QList < QCPLayoutElement * > > mChildren ;
// non-virtual methods:
int commonMargin ( QCP : : MarginSide side ) const ;
void addChild ( QCP : : MarginSide side , QCPLayoutElement * element ) ;
void removeChild ( QCP : : MarginSide side , QCPLayoutElement * element ) ;
private :
Q_DISABLE_COPY ( QCPMarginGroup )
friend class QCPLayoutElement ;
} ;
class QCP_LIB_DECL QCPLayoutElement : public QCPLayerable
{
Q_OBJECT
/// \cond INCLUDE_QPROPERTIES
Q_PROPERTY ( QCPLayout * layout READ layout )
Q_PROPERTY ( QRect rect READ rect )
Q_PROPERTY ( QRect outerRect READ outerRect WRITE setOuterRect )
Q_PROPERTY ( QMargins margins READ margins WRITE setMargins )
Q_PROPERTY ( QMargins minimumMargins READ minimumMargins WRITE setMinimumMargins )
Q_PROPERTY ( QSize minimumSize READ minimumSize WRITE setMinimumSize )
Q_PROPERTY ( QSize maximumSize READ maximumSize WRITE setMaximumSize )
/// \endcond
public :
2014-03-22 14:31:20 +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 )
2013-08-27 18:13:20 +00:00
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:
2014-03-22 14:31:20 +00:00
virtual void update ( UpdatePhase phase ) ;
2013-08-27 18:13:20 +00:00
virtual QSize minimumSizeHint ( ) const ;
virtual QSize maximumSizeHint ( ) const ;
virtual QList < QCPLayoutElement * > elements ( bool recursive ) const ;
// reimplemented virtual methods:
virtual double selectTest ( const QPointF & pos , bool onlySelectable , QVariant * details = 0 ) const ;
protected :
// property members:
QCPLayout * mParentLayout ;
QSize mMinimumSize , mMaximumSize ;
QRect mRect , mOuterRect ;
QMargins mMargins , mMinimumMargins ;
QCP : : MarginSides mAutoMargins ;
QHash < QCP : : MarginSide , QCPMarginGroup * > mMarginGroups ;
// introduced virtual methods:
virtual int calculateAutoMargin ( QCP : : MarginSide side ) ;
// events:
virtual void mousePressEvent ( QMouseEvent * event ) { Q_UNUSED ( event ) }
virtual void mouseMoveEvent ( QMouseEvent * event ) { Q_UNUSED ( event ) }
virtual void mouseReleaseEvent ( QMouseEvent * event ) { Q_UNUSED ( event ) }
virtual void mouseDoubleClickEvent ( QMouseEvent * event ) { Q_UNUSED ( event ) }
virtual void wheelEvent ( QWheelEvent * event ) { Q_UNUSED ( event ) }
// reimplemented virtual methods:
virtual void applyDefaultAntialiasingHint ( QCPPainter * painter ) const { Q_UNUSED ( painter ) }
virtual void draw ( QCPPainter * painter ) { Q_UNUSED ( painter ) }
virtual void parentPlotInitialized ( QCustomPlot * parentPlot ) ;
private :
Q_DISABLE_COPY ( QCPLayoutElement )
friend class QCustomPlot ;
friend class QCPLayout ;
friend class QCPMarginGroup ;
} ;
class QCP_LIB_DECL QCPLayout : public QCPLayoutElement
{
Q_OBJECT
public :
explicit QCPLayout ( ) ;
// reimplemented virtual methods:
2014-03-22 14:31:20 +00:00
virtual void update ( UpdatePhase phase ) ;
2013-08-27 18:13:20 +00:00
virtual QList < QCPLayoutElement * > elements ( bool recursive ) const ;
// introduced virtual methods:
virtual int elementCount ( ) const = 0 ;
virtual QCPLayoutElement * elementAt ( int index ) const = 0 ;
virtual QCPLayoutElement * takeAt ( int index ) = 0 ;
virtual bool take ( QCPLayoutElement * element ) = 0 ;
virtual void simplify ( ) ;
// non-virtual methods:
bool removeAt ( int index ) ;
bool remove ( QCPLayoutElement * element ) ;
void clear ( ) ;
protected :
// introduced virtual methods:
virtual void updateLayout ( ) ;
// non-virtual methods:
void sizeConstraintsChanged ( ) const ;
void adoptElement ( QCPLayoutElement * el ) ;
void releaseElement ( QCPLayoutElement * el ) ;
QVector < int > getSectionSizes ( QVector < int > maxSizes , QVector < int > minSizes , QVector < double > stretchFactors , int totalSize ) const ;
private :
Q_DISABLE_COPY ( QCPLayout )
friend class QCPLayoutElement ;
} ;
class QCP_LIB_DECL QCPLayoutGrid : public QCPLayout
{
Q_OBJECT
/// \cond INCLUDE_QPROPERTIES
Q_PROPERTY ( int rowCount READ rowCount )
Q_PROPERTY ( int columnCount READ columnCount )
Q_PROPERTY ( QList < double > columnStretchFactors READ columnStretchFactors WRITE setColumnStretchFactors )
Q_PROPERTY ( QList < double > rowStretchFactors READ rowStretchFactors WRITE setRowStretchFactors )
Q_PROPERTY ( int columnSpacing READ columnSpacing WRITE setColumnSpacing )
Q_PROPERTY ( int rowSpacing READ rowSpacing WRITE setRowSpacing )
/// \endcond
public :
explicit QCPLayoutGrid ( ) ;
virtual ~ QCPLayoutGrid ( ) ;
// getters:
int rowCount ( ) const ;
int columnCount ( ) const ;
QList < double > columnStretchFactors ( ) const { return mColumnStretchFactors ; }
QList < double > rowStretchFactors ( ) const { return mRowStretchFactors ; }
int columnSpacing ( ) const { return mColumnSpacing ; }
int rowSpacing ( ) const { return mRowSpacing ; }
// setters:
void setColumnStretchFactor ( int column , double factor ) ;
void setColumnStretchFactors ( const QList < double > & factors ) ;
void setRowStretchFactor ( int row , double factor ) ;
void setRowStretchFactors ( const QList < double > & factors ) ;
void setColumnSpacing ( int pixels ) ;
void setRowSpacing ( int pixels ) ;
// reimplemented virtual methods:
virtual void updateLayout ( ) ;
virtual int elementCount ( ) const ;
virtual QCPLayoutElement * elementAt ( int index ) const ;
virtual QCPLayoutElement * takeAt ( int index ) ;
virtual bool take ( QCPLayoutElement * element ) ;
virtual QList < QCPLayoutElement * > elements ( bool recursive ) const ;
virtual void simplify ( ) ;
virtual QSize minimumSizeHint ( ) const ;
virtual QSize maximumSizeHint ( ) const ;
// non-virtual methods:
QCPLayoutElement * element ( int row , int column ) const ;
bool addElement ( int row , int column , QCPLayoutElement * element ) ;
bool hasElement ( int row , int column ) ;
void expandTo ( int newRowCount , int newColumnCount ) ;
void insertRow ( int newIndex ) ;
void insertColumn ( int newIndex ) ;
protected :
// property members:
QList < QList < QCPLayoutElement * > > mElements ;
QList < double > mColumnStretchFactors ;
QList < double > mRowStretchFactors ;
int mColumnSpacing , mRowSpacing ;
// non-virtual methods:
void getMinimumRowColSizes ( QVector < int > * minColWidths , QVector < int > * minRowHeights ) const ;
void getMaximumRowColSizes ( QVector < int > * maxColWidths , QVector < int > * maxRowHeights ) const ;
private :
Q_DISABLE_COPY ( QCPLayoutGrid )
} ;
class QCP_LIB_DECL QCPLayoutInset : public QCPLayout
{
Q_OBJECT
public :
/*!
Defines how the placement and sizing is handled for a certain element in a QCPLayoutInset .
*/
2014-03-22 14:31:20 +00:00
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
2013-08-27 18:13:20 +00:00
} ;
explicit QCPLayoutInset ( ) ;
virtual ~ QCPLayoutInset ( ) ;
// getters:
InsetPlacement insetPlacement ( int index ) const ;
Qt : : Alignment insetAlignment ( int index ) const ;
QRectF insetRect ( int index ) const ;
// setters:
void setInsetPlacement ( int index , InsetPlacement placement ) ;
void setInsetAlignment ( int index , Qt : : Alignment alignment ) ;
void setInsetRect ( int index , const QRectF & rect ) ;
// reimplemented virtual methods:
virtual void updateLayout ( ) ;
virtual int elementCount ( ) const ;
virtual QCPLayoutElement * elementAt ( int index ) const ;
virtual QCPLayoutElement * takeAt ( int index ) ;
virtual bool take ( QCPLayoutElement * element ) ;
virtual void simplify ( ) { }
virtual double selectTest ( const QPointF & pos , bool onlySelectable , QVariant * details = 0 ) const ;
// non-virtual methods:
void addElement ( QCPLayoutElement * element , Qt : : Alignment alignment ) ;
void addElement ( QCPLayoutElement * element , const QRectF & rect ) ;
protected :
// property members:
QList < QCPLayoutElement * > mElements ;
QList < InsetPlacement > mInsetPlacement ;
QList < Qt : : Alignment > mInsetAlignment ;
QList < QRectF > mInsetRect ;
private :
Q_DISABLE_COPY ( QCPLayoutInset )
} ;
class QCP_LIB_DECL QCPLineEnding
{
Q_GADGET
public :
/*!
Defines the type of ending decoration for line - like items , e . g . an arrow .
\ image html QCPLineEnding . png
The width and length of these decorations can be controlled with the functions \ ref setWidth
and \ ref setLength . Some decorations like \ ref esDisc , \ ref esSquare , \ ref esDiamond and \ ref esBar only
support a width , the length property is ignored .
2014-03-22 14:31:20 +00:00
\ see QCPItemLine : : setHead , QCPItemLine : : setTail , QCPItemCurve : : setHead , QCPItemCurve : : setTail , QCPAxis : : setLowerEnding , QCPAxis : : setUpperEnding
2013-08-27 18:13:20 +00:00
*/
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
2014-03-22 14:31:20 +00:00
, esDiamond ///< A filled diamond (45 rotated square)
2013-08-27 18:13:20 +00:00
, esBar ///< A bar perpendicular to the line
2014-03-22 14:31:20 +00:00
, esHalfBar ///< A bar perpendicular to the line, pointing out to only one side (to which side can be changed with \ref setInverted)
2013-08-27 18:13:20 +00:00
, esSkewedBar ///< A bar that is skewed (skew controllable via \ref setLength)
} ;
QCPLineEnding ( ) ;
QCPLineEnding ( EndingStyle style , double width = 8 , double length = 10 , bool inverted = false ) ;
// getters:
EndingStyle style ( ) const { return mStyle ; }
double width ( ) const { return mWidth ; }
double length ( ) const { return mLength ; }
bool inverted ( ) const { return mInverted ; }
// setters:
void setStyle ( EndingStyle style ) ;
void setWidth ( double width ) ;
void setLength ( double length ) ;
void setInverted ( bool inverted ) ;
// non-property methods:
double boundingDistance ( ) const ;
double realLength ( ) const ;
void draw ( QCPPainter * painter , const QVector2D & pos , const QVector2D & dir ) const ;
void draw ( QCPPainter * painter , const QVector2D & pos , double angle ) const ;
protected :
// property members:
EndingStyle mStyle ;
double mWidth , mLength ;
bool mInverted ;
} ;
Q_DECLARE_TYPEINFO ( QCPLineEnding , Q_MOVABLE_TYPE ) ;
class QCP_LIB_DECL QCPGrid : public QCPLayerable
{
Q_OBJECT
/// \cond INCLUDE_QPROPERTIES
Q_PROPERTY ( bool subGridVisible READ subGridVisible WRITE setSubGridVisible )
Q_PROPERTY ( bool antialiasedSubGrid READ antialiasedSubGrid WRITE setAntialiasedSubGrid )
Q_PROPERTY ( bool antialiasedZeroLine READ antialiasedZeroLine WRITE setAntialiasedZeroLine )
Q_PROPERTY ( QPen pen READ pen WRITE setPen )
Q_PROPERTY ( QPen subGridPen READ subGridPen WRITE setSubGridPen )
Q_PROPERTY ( QPen zeroLinePen READ zeroLinePen WRITE setZeroLinePen )
/// \endcond
public :
QCPGrid ( QCPAxis * parentAxis ) ;
// getters:
bool subGridVisible ( ) const { return mSubGridVisible ; }
bool antialiasedSubGrid ( ) const { return mAntialiasedSubGrid ; }
bool antialiasedZeroLine ( ) const { return mAntialiasedZeroLine ; }
QPen pen ( ) const { return mPen ; }
QPen subGridPen ( ) const { return mSubGridPen ; }
QPen zeroLinePen ( ) const { return mZeroLinePen ; }
// setters:
void setSubGridVisible ( bool visible ) ;
void setAntialiasedSubGrid ( bool enabled ) ;
void setAntialiasedZeroLine ( bool enabled ) ;
void setPen ( const QPen & pen ) ;
void setSubGridPen ( const QPen & pen ) ;
void setZeroLinePen ( const QPen & pen ) ;
protected :
// property members:
bool mSubGridVisible ;
bool mAntialiasedSubGrid , mAntialiasedZeroLine ;
QPen mPen , mSubGridPen , mZeroLinePen ;
// non-property members:
QCPAxis * mParentAxis ;
// reimplemented virtual methods:
virtual void applyDefaultAntialiasingHint ( QCPPainter * painter ) const ;
virtual void draw ( QCPPainter * painter ) ;
// non-virtual methods:
void drawGridLines ( QCPPainter * painter ) const ;
void drawSubGridLines ( QCPPainter * painter ) const ;
friend class QCPAxis ;
} ;
class QCP_LIB_DECL QCPAxis : public QCPLayerable
{
Q_OBJECT
/// \cond INCLUDE_QPROPERTIES
Q_PROPERTY ( AxisType axisType READ axisType )
Q_PROPERTY ( QCPAxisRect * axisRect READ axisRect )
2014-03-22 14:31:20 +00:00
Q_PROPERTY ( ScaleType scaleType READ scaleType WRITE setScaleType NOTIFY scaleTypeChanged )
2013-08-27 18:13:20 +00:00
Q_PROPERTY ( double scaleLogBase READ scaleLogBase WRITE setScaleLogBase )
2014-03-22 14:31:20 +00:00
Q_PROPERTY ( QCPRange range READ range WRITE setRange NOTIFY rangeChanged )
2013-08-27 18:13:20 +00:00
Q_PROPERTY ( bool rangeReversed READ rangeReversed WRITE setRangeReversed )
Q_PROPERTY ( bool autoTicks READ autoTicks WRITE setAutoTicks )
Q_PROPERTY ( int autoTickCount READ autoTickCount WRITE setAutoTickCount )
Q_PROPERTY ( bool autoTickLabels READ autoTickLabels WRITE setAutoTickLabels )
Q_PROPERTY ( bool autoTickStep READ autoTickStep WRITE setAutoTickStep )
Q_PROPERTY ( bool autoSubTicks READ autoSubTicks WRITE setAutoSubTicks )
Q_PROPERTY ( bool ticks READ ticks WRITE setTicks )
Q_PROPERTY ( bool tickLabels READ tickLabels WRITE setTickLabels )
Q_PROPERTY ( int tickLabelPadding READ tickLabelPadding WRITE setTickLabelPadding )
Q_PROPERTY ( LabelType tickLabelType READ tickLabelType WRITE setTickLabelType )
Q_PROPERTY ( QFont tickLabelFont READ tickLabelFont WRITE setTickLabelFont )
Q_PROPERTY ( QColor tickLabelColor READ tickLabelColor WRITE setTickLabelColor )
Q_PROPERTY ( double tickLabelRotation READ tickLabelRotation WRITE setTickLabelRotation )
Q_PROPERTY ( QString dateTimeFormat READ dateTimeFormat WRITE setDateTimeFormat )
2014-03-22 14:31:20 +00:00
Q_PROPERTY ( Qt : : TimeSpec dateTimeSpec READ dateTimeSpec WRITE setDateTimeSpec )
2013-08-27 18:13:20 +00:00
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 )
2014-03-22 14:31:20 +00:00
Q_PROPERTY ( SelectableParts selectedParts READ selectedParts WRITE setSelectedParts NOTIFY selectionChanged )
Q_PROPERTY ( SelectableParts selectableParts READ selectableParts WRITE setSelectableParts NOTIFY selectableChanged )
2013-08-27 18:13:20 +00:00
Q_PROPERTY ( QFont selectedTickLabelFont READ selectedTickLabelFont WRITE setSelectedTickLabelFont )
Q_PROPERTY ( QFont selectedLabelFont READ selectedLabelFont WRITE setSelectedLabelFont )
Q_PROPERTY ( QColor selectedTickLabelColor READ selectedTickLabelColor WRITE setSelectedTickLabelColor )
Q_PROPERTY ( QColor selectedLabelColor READ selectedLabelColor WRITE setSelectedLabelColor )
Q_PROPERTY ( QPen selectedBasePen READ selectedBasePen WRITE setSelectedBasePen )
Q_PROPERTY ( QPen selectedTickPen READ selectedTickPen WRITE setSelectedTickPen )
Q_PROPERTY ( QPen selectedSubTickPen READ selectedSubTickPen WRITE setSelectedSubTickPen )
Q_PROPERTY ( QCPLineEnding lowerEnding READ lowerEnding WRITE setLowerEnding )
Q_PROPERTY ( QCPLineEnding upperEnding READ upperEnding WRITE setUpperEnding )
Q_PROPERTY ( QCPGrid * grid READ grid )
/// \endcond
public :
/*!
Defines at which side of the axis rect the axis will appear . This also affects how the tick
marks are drawn , on which side the labels are placed etc .
*/
enum AxisType { atLeft = 0x01 ///< <tt>0x01</tt> Axis is vertical and on the left side of the axis rect
, atRight = 0x02 ///< <tt>0x02</tt> Axis is vertical and on the right side of the axis rect
, atTop = 0x04 ///< <tt>0x04</tt> Axis is horizontal and on the top side of the axis rect
, atBottom = 0x08 ///< <tt>0x08</tt> Axis is horizontal and on the bottom side of the axis rect
} ;
Q_FLAGS ( AxisType AxisTypes )
Q_DECLARE_FLAGS ( AxisTypes , AxisType )
/*!
When automatic tick label generation is enabled ( \ ref setAutoTickLabels ) , defines how the
coordinate of the tick is interpreted , i . e . translated into a string .
\ see setTickLabelType
*/
enum LabelType { ltNumber ///< Tick coordinate is regarded as normal number and will be displayed as such. (see \ref setNumberFormat)
, ltDateTime ///< Tick coordinate is regarded as a date/time (seconds since 1970-01-01T00:00:00 UTC) and will be displayed and formatted as such. (for details, see \ref setDateTimeFormat)
} ;
Q_ENUMS ( LabelType )
/*!
Defines the scale of an axis .
\ see setScaleType
*/
enum ScaleType { stLinear ///< Linear scaling
, stLogarithmic ///< Logarithmic scaling with correspondingly transformed plots and (major) tick marks at every base power (see \ref setScaleLogBase).
} ;
Q_ENUMS ( ScaleType )
/*!
Defines the selectable parts of an axis .
\ see setSelectableParts , setSelectedParts
*/
enum SelectablePart { spNone = 0 ///< None of the selectable parts
, spAxis = 0x001 ///< The axis backbone and tick marks
, spTickLabels = 0x002 ///< Tick labels (numbers) of this axis (as a whole, not individually)
, spAxisLabel = 0x004 ///< The axis label
} ;
Q_FLAGS ( SelectablePart SelectableParts )
Q_DECLARE_FLAGS ( SelectableParts , SelectablePart )
explicit QCPAxis ( QCPAxisRect * parent , AxisType type ) ;
2014-03-22 14:31:20 +00:00
virtual ~ QCPAxis ( ) ;
2013-08-27 18:13:20 +00:00
// 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 ; }
2014-03-22 14:31:20 +00:00
int tickLabelPadding ( ) const ;
2013-08-27 18:13:20 +00:00
LabelType tickLabelType ( ) const { return mTickLabelType ; }
QFont tickLabelFont ( ) const { return mTickLabelFont ; }
QColor tickLabelColor ( ) const { return mTickLabelColor ; }
2014-03-22 14:31:20 +00:00
double tickLabelRotation ( ) const ;
2013-08-27 18:13:20 +00:00
QString dateTimeFormat ( ) const { return mDateTimeFormat ; }
2014-03-22 14:31:20 +00:00
Qt : : TimeSpec dateTimeSpec ( ) const { return mDateTimeSpec ; }
2013-08-27 18:13:20 +00:00
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 ; }
2014-03-22 14:31:20 +00:00
int tickLengthIn ( ) const ;
int tickLengthOut ( ) const ;
2013-08-27 18:13:20 +00:00
int subTickCount ( ) const { return mSubTickCount ; }
2014-03-22 14:31:20 +00:00
int subTickLengthIn ( ) const ;
int subTickLengthOut ( ) const ;
2013-08-27 18:13:20 +00:00
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 ; }
2014-03-22 14:31:20 +00:00
int labelPadding ( ) const ;
2013-08-27 18:13:20 +00:00
int padding ( ) const { return mPadding ; }
2014-03-22 14:31:20 +00:00
int offset ( ) const ;
2013-08-27 18:13:20 +00:00
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 ; }
2014-03-22 14:31:20 +00:00
QCPLineEnding lowerEnding ( ) const ;
QCPLineEnding upperEnding ( ) const ;
2013-08-27 18:13:20 +00:00
QCPGrid * grid ( ) const { return mGrid ; }
// setters:
2014-03-22 14:31:20 +00:00
Q_SLOT void setScaleType ( QCPAxis : : ScaleType type ) ;
2013-08-27 18:13:20 +00:00
void setScaleLogBase ( double base ) ;
Q_SLOT void setRange ( const QCPRange & range ) ;
void setRange ( double lower , double upper ) ;
void setRange ( double position , double size , Qt : : AlignmentFlag alignment ) ;
void setRangeLower ( double lower ) ;
void setRangeUpper ( double upper ) ;
void setRangeReversed ( bool reversed ) ;
void setAutoTicks ( bool on ) ;
void setAutoTickCount ( int approximateCount ) ;
void setAutoTickLabels ( bool on ) ;
void setAutoTickStep ( bool on ) ;
void setAutoSubTicks ( bool on ) ;
void setTicks ( bool show ) ;
void setTickLabels ( bool show ) ;
void setTickLabelPadding ( int padding ) ;
void setTickLabelType ( LabelType type ) ;
void setTickLabelFont ( const QFont & font ) ;
void setTickLabelColor ( const QColor & color ) ;
void setTickLabelRotation ( double degrees ) ;
void setDateTimeFormat ( const QString & format ) ;
2014-03-22 14:31:20 +00:00
void setDateTimeSpec ( const Qt : : TimeSpec & timeSpec ) ;
2013-08-27 18:13:20 +00:00
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 ;
2014-03-22 14:31:20 +00:00
// non-property methods:
2013-08-27 18:13:20 +00:00
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 ) ;
2014-03-22 14:31:20 +00:00
void rescale ( bool onlyVisiblePlottables = false ) ;
2013-08-27 18:13:20 +00:00
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 ) ;
2014-03-22 14:31:20 +00:00
static Qt : : Orientation orientation ( AxisType type ) { return type = = atBottom | | type = = atTop ? Qt : : Horizontal : Qt : : Vertical ; }
static AxisType opposite ( AxisType type ) ;
2013-08-27 18:13:20 +00:00
signals :
void ticksRequest ( ) ;
void rangeChanged ( const QCPRange & newRange ) ;
2014-03-22 14:31:20 +00:00
void rangeChanged ( const QCPRange & newRange , const QCPRange & oldRange ) ;
void scaleTypeChanged ( QCPAxis : : ScaleType scaleType ) ;
2013-08-27 18:13:20 +00:00
void selectionChanged ( const QCPAxis : : SelectableParts & parts ) ;
2014-03-22 14:31:20 +00:00
void selectableChanged ( const QCPAxis : : SelectableParts & parts ) ;
2013-08-27 18:13:20 +00:00
protected :
// property members:
// axis base:
AxisType mAxisType ;
QCPAxisRect * mAxisRect ;
2014-03-22 14:31:20 +00:00
//int mOffset; // in QCPAxisPainter
int mPadding ;
2013-08-27 18:13:20 +00:00
Qt : : Orientation mOrientation ;
SelectableParts mSelectableParts , mSelectedParts ;
QPen mBasePen , mSelectedBasePen ;
2014-03-22 14:31:20 +00:00
//QCPLineEnding mLowerEnding, mUpperEnding; // in QCPAxisPainter
2013-08-27 18:13:20 +00:00
// axis label:
2014-03-22 14:31:20 +00:00
//int mLabelPadding; // in QCPAxisPainter
2013-08-27 18:13:20 +00:00
QString mLabel ;
QFont mLabelFont , mSelectedLabelFont ;
QColor mLabelColor , mSelectedLabelColor ;
// tick labels:
2014-03-22 14:31:20 +00:00
//int mTickLabelPadding; // in QCPAxisPainter
2013-08-27 18:13:20 +00:00
bool mTickLabels , mAutoTickLabels ;
2014-03-22 14:31:20 +00:00
//double mTickLabelRotation; // in QCPAxisPainter
2013-08-27 18:13:20 +00:00
LabelType mTickLabelType ;
QFont mTickLabelFont , mSelectedTickLabelFont ;
QColor mTickLabelColor , mSelectedTickLabelColor ;
QString mDateTimeFormat ;
2014-03-22 14:31:20 +00:00
Qt : : TimeSpec mDateTimeSpec ;
2013-08-27 18:13:20 +00:00
int mNumberPrecision ;
char mNumberFormatChar ;
bool mNumberBeautifulPowers ;
2014-03-22 14:31:20 +00:00
//bool mNumberMultiplyCross; // QCPAxisPainter
2013-08-27 18:13:20 +00:00
// ticks and subticks:
bool mTicks ;
double mTickStep ;
int mSubTickCount , mAutoTickCount ;
bool mAutoTicks , mAutoTickStep , mAutoSubTicks ;
2014-03-22 14:31:20 +00:00
//int mTickLengthIn, mTickLengthOut, mSubTickLengthIn, mSubTickLengthOut; // QCPAxisPainter
2013-08-27 18:13:20 +00:00
QPen mTickPen , mSelectedTickPen ;
QPen mSubTickPen , mSelectedSubTickPen ;
// scale and range:
QCPRange mRange ;
bool mRangeReversed ;
ScaleType mScaleType ;
double mScaleLogBase , mScaleLogBaseLogInv ;
// non-property members:
QCPGrid * mGrid ;
2014-03-22 14:31:20 +00:00
QCPAxisPainterPrivate * mAxisPainter ;
2013-08-27 18:13:20 +00:00
int mLowestVisibleTick , mHighestVisibleTick ;
QVector < double > mTickVector ;
QVector < QString > mTickVectorLabels ;
QVector < double > mSubTickVector ;
bool mCachedMarginValid ;
int mCachedMargin ;
// introduced virtual methods:
virtual void setupTickVectors ( ) ;
virtual void generateAutoTicks ( ) ;
virtual int calculateAutoSubTickCount ( double tickStep ) const ;
virtual int calculateMargin ( ) ;
// reimplemented virtual methods:
virtual void applyDefaultAntialiasingHint ( QCPPainter * painter ) const ;
virtual void draw ( QCPPainter * painter ) ;
virtual QCP : : Interaction selectionCategory ( ) const ;
// events:
virtual void selectEvent ( QMouseEvent * event , bool additive , const QVariant & details , bool * selectionStateChanged ) ;
virtual void deselectEvent ( bool * selectionStateChanged ) ;
// non-virtual methods:
void visibleTickBounds ( int & lowIndex , int & highIndex ) const ;
double baseLog ( double value ) const ;
double basePow ( double value ) const ;
QPen getBasePen ( ) const ;
QPen getTickPen ( ) const ;
QPen getSubTickPen ( ) const ;
QFont getTickLabelFont ( ) const ;
QFont getLabelFont ( ) const ;
QColor getTickLabelColor ( ) const ;
QColor getLabelColor ( ) const ;
private :
Q_DISABLE_COPY ( QCPAxis )
friend class QCustomPlot ;
friend class QCPGrid ;
friend class QCPAxisRect ;
} ;
Q_DECLARE_OPERATORS_FOR_FLAGS ( QCPAxis : : SelectableParts )
Q_DECLARE_OPERATORS_FOR_FLAGS ( QCPAxis : : AxisTypes )
Q_DECLARE_METATYPE ( QCPAxis : : SelectablePart )
2014-03-22 14:31:20 +00:00
class QCPAxisPainterPrivate
{
public :
explicit QCPAxisPainterPrivate ( QCustomPlot * parentPlot ) ;
virtual ~ QCPAxisPainterPrivate ( ) ;
virtual void draw ( QCPPainter * painter ) ;
virtual int size ( ) const ;
void clearCache ( ) ;
QRect axisSelectionBox ( ) const { return mAxisSelectionBox ; }
QRect tickLabelsSelectionBox ( ) const { return mTickLabelsSelectionBox ; }
QRect labelSelectionBox ( ) const { return mLabelSelectionBox ; }
// public property members:
QCPAxis : : AxisType type ;
QPen basePen ;
QCPLineEnding lowerEnding , upperEnding ; // directly accessed by QCPAxis setters/getters
int labelPadding ; // directly accessed by QCPAxis setters/getters
QFont labelFont ;
QColor labelColor ;
QString label ;
int tickLabelPadding ; // directly accessed by QCPAxis setters/getters
double tickLabelRotation ; // directly accessed by QCPAxis setters/getters
bool substituteExponent ;
bool numberMultiplyCross ; // directly accessed by QCPAxis setters/getters
int tickLengthIn , tickLengthOut , subTickLengthIn , subTickLengthOut ; // directly accessed by QCPAxis setters/getters
QPen tickPen , subTickPen ;
QFont tickLabelFont ;
QColor tickLabelColor ;
QRect alignmentRect , viewportRect ;
double offset ; // directly accessed by QCPAxis setters/getters
bool abbreviateDecimalPowers ;
bool reversedEndings ;
QVector < double > subTickPositions ;
QVector < double > tickPositions ;
QVector < QString > tickLabels ;
protected :
struct CachedLabel
{
QPointF offset ;
QPixmap pixmap ;
} ;
struct TickLabelData
{
QString basePart , expPart ;
QRect baseBounds , expBounds , totalBounds , rotatedTotalBounds ;
QFont baseFont , expFont ;
} ;
QCustomPlot * mParentPlot ;
QByteArray mLabelParameterHash ; // to determine whether mLabelCache needs to be cleared due to changed parameters
QCache < QString , CachedLabel > mLabelCache ;
QRect mAxisSelectionBox , mTickLabelsSelectionBox , mLabelSelectionBox ;
virtual QByteArray generateLabelParameterHash ( ) const ;
virtual void placeTickLabel ( QCPPainter * painter , double position , int distanceToAxis , const QString & text , QSize * tickLabelsSize ) ;
virtual void drawTickLabel ( QCPPainter * painter , double x , double y , const TickLabelData & labelData ) const ;
virtual TickLabelData getTickLabelData ( const QFont & font , const QString & text ) const ;
virtual QPointF getTickLabelDrawOffset ( const TickLabelData & labelData ) const ;
virtual void getMaxTickLabelSize ( const QFont & font , const QString & text , QSize * tickLabelsSize ) const ;
} ;
2013-08-27 18:13:20 +00:00
class QCP_LIB_DECL QCPAbstractPlottable : public QCPLayerable
{
Q_OBJECT
/// \cond INCLUDE_QPROPERTIES
Q_PROPERTY ( QString name READ name WRITE setName )
Q_PROPERTY ( bool antialiasedFill READ antialiasedFill WRITE setAntialiasedFill )
Q_PROPERTY ( bool antialiasedScatters READ antialiasedScatters WRITE setAntialiasedScatters )
Q_PROPERTY ( bool antialiasedErrorBars READ antialiasedErrorBars WRITE setAntialiasedErrorBars )
Q_PROPERTY ( QPen pen READ pen WRITE setPen )
Q_PROPERTY ( QPen selectedPen READ selectedPen WRITE setSelectedPen )
Q_PROPERTY ( QBrush brush READ brush WRITE setBrush )
Q_PROPERTY ( QBrush selectedBrush READ selectedBrush WRITE setSelectedBrush )
Q_PROPERTY ( QCPAxis * keyAxis READ keyAxis WRITE setKeyAxis )
Q_PROPERTY ( QCPAxis * valueAxis READ valueAxis WRITE setValueAxis )
2014-03-22 14:31:20 +00:00
Q_PROPERTY ( bool selectable READ selectable WRITE setSelectable NOTIFY selectableChanged )
Q_PROPERTY ( bool selected READ selected WRITE setSelected NOTIFY selectionChanged )
2013-08-27 18:13:20 +00:00
/// \endcond
public :
QCPAbstractPlottable ( QCPAxis * keyAxis , QCPAxis * valueAxis ) ;
// getters:
QString name ( ) const { return mName ; }
bool antialiasedFill ( ) const { return mAntialiasedFill ; }
bool antialiasedScatters ( ) const { return mAntialiasedScatters ; }
bool antialiasedErrorBars ( ) const { return mAntialiasedErrorBars ; }
QPen pen ( ) const { return mPen ; }
QPen selectedPen ( ) const { return mSelectedPen ; }
QBrush brush ( ) const { return mBrush ; }
QBrush selectedBrush ( ) const { return mSelectedBrush ; }
QCPAxis * keyAxis ( ) const { return mKeyAxis . data ( ) ; }
QCPAxis * valueAxis ( ) const { return mValueAxis . data ( ) ; }
bool selectable ( ) const { return mSelectable ; }
bool selected ( ) const { return mSelected ; }
// setters:
void setName ( const QString & name ) ;
void setAntialiasedFill ( bool enabled ) ;
void setAntialiasedScatters ( bool enabled ) ;
void setAntialiasedErrorBars ( bool enabled ) ;
void setPen ( const QPen & pen ) ;
void setSelectedPen ( const QPen & pen ) ;
void setBrush ( const QBrush & brush ) ;
void setSelectedBrush ( const QBrush & brush ) ;
void setKeyAxis ( QCPAxis * axis ) ;
void setValueAxis ( QCPAxis * axis ) ;
Q_SLOT void setSelectable ( bool selectable ) ;
Q_SLOT void setSelected ( bool selected ) ;
// introduced virtual methods:
virtual void clearData ( ) = 0 ;
virtual double selectTest ( const QPointF & pos , bool onlySelectable , QVariant * details = 0 ) const = 0 ;
virtual bool addToLegend ( ) ;
virtual bool removeFromLegend ( ) const ;
// non-property methods:
void rescaleAxes ( bool onlyEnlarge = false ) const ;
void rescaleKeyAxis ( bool onlyEnlarge = false ) const ;
void rescaleValueAxis ( bool onlyEnlarge = false ) const ;
signals :
void selectionChanged ( bool selected ) ;
2014-03-22 14:31:20 +00:00
void selectableChanged ( bool selectable ) ;
2013-08-27 18:13:20 +00:00
protected :
/*!
Represents negative and positive sign domain for passing to \ ref getKeyRange and \ ref getValueRange .
*/
enum SignDomain { sdNegative ///< The negative sign domain, i.e. numbers smaller than zero
, sdBoth ///< Both sign domains, including zero, i.e. all (rational) numbers
, sdPositive ///< The positive sign domain, i.e. numbers greater than zero
} ;
// property members:
QString mName ;
bool mAntialiasedFill , mAntialiasedScatters , mAntialiasedErrorBars ;
QPen mPen , mSelectedPen ;
QBrush mBrush , mSelectedBrush ;
2014-03-22 14:31:20 +00:00
QPointer < QCPAxis > mKeyAxis , mValueAxis ;
2013-08-27 18:13:20 +00:00
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 ;
2014-03-22 14:31:20 +00:00
virtual QCPRange getKeyRange ( bool & foundRange , SignDomain inSignDomain = sdBoth ) const = 0 ;
virtual QCPRange getValueRange ( bool & foundRange , SignDomain inSignDomain = sdBoth ) const = 0 ;
2013-08-27 18:13:20 +00:00
// non-virtual methods:
void coordsToPixels ( double key , double value , double & x , double & y ) const ;
const QPointF coordsToPixels ( double key , double value ) const ;
void pixelsToCoords ( double x , double y , double & key , double & value ) const ;
void pixelsToCoords ( const QPointF & pixelPos , double & key , double & value ) const ;
QPen mainPen ( ) const ;
QBrush mainBrush ( ) const ;
void applyFillAntialiasingHint ( QCPPainter * painter ) const ;
void applyScattersAntialiasingHint ( QCPPainter * painter ) const ;
void applyErrorBarsAntialiasingHint ( QCPPainter * painter ) const ;
double distSqrToLine ( const QPointF & start , const QPointF & end , const QPointF & point ) const ;
private :
Q_DISABLE_COPY ( QCPAbstractPlottable )
friend class QCustomPlot ;
2014-03-22 14:31:20 +00:00
friend class QCPAxis ;
2013-08-27 18:13:20 +00:00
friend class QCPPlottableLegendItem ;
} ;
class QCP_LIB_DECL QCPItemAnchor
{
public :
QCPItemAnchor ( QCustomPlot * parentPlot , QCPAbstractItem * parentItem , const QString name , int anchorId = - 1 ) ;
virtual ~ QCPItemAnchor ( ) ;
// getters:
QString name ( ) const { return mName ; }
virtual QPointF pixelPoint ( ) const ;
protected :
// property members:
QString mName ;
// non-property members:
QCustomPlot * mParentPlot ;
QCPAbstractItem * mParentItem ;
int mAnchorId ;
QSet < QCPItemPosition * > mChildren ;
// introduced virtual methods:
virtual QCPItemPosition * toQCPItemPosition ( ) { return 0 ; }
// non-virtual methods:
void addChild ( QCPItemPosition * pos ) ; // called from pos when this anchor is set as parent
void removeChild ( QCPItemPosition * pos ) ; // called from pos when its parent anchor is reset or pos deleted
private :
Q_DISABLE_COPY ( QCPItemAnchor )
friend class QCPItemPosition ;
} ;
class QCP_LIB_DECL QCPItemPosition : public QCPItemAnchor
{
public :
/*!
Defines the ways an item position can be specified . Thus it defines what the numbers passed to
\ ref setCoords actually mean .
\ see setType
*/
enum PositionType { ptAbsolute ///< Static positioning in pixels, starting from the top left corner of the viewport/widget.
2014-03-22 14:31:20 +00:00
, 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.
2013-08-27 18:13:20 +00:00
, ptPlotCoords ///< Dynamic positioning at a plot coordinate defined by two axes (see \ref setAxes).
} ;
QCPItemPosition ( QCustomPlot * parentPlot , QCPAbstractItem * parentItem , const QString name ) ;
virtual ~ QCPItemPosition ( ) ;
// getters:
PositionType type ( ) const { return mPositionType ; }
QCPItemAnchor * parentAnchor ( ) const { return mParentAnchor ; }
double key ( ) const { return mKey ; }
double value ( ) const { return mValue ; }
QPointF coords ( ) const { return QPointF ( mKey , mValue ) ; }
QCPAxis * keyAxis ( ) const { return mKeyAxis . data ( ) ; }
QCPAxis * valueAxis ( ) const { return mValueAxis . data ( ) ; }
2014-03-22 14:31:20 +00:00
QCPAxisRect * axisRect ( ) const ;
2013-08-27 18:13:20 +00:00
virtual QPointF pixelPoint ( ) const ;
// setters:
void setType ( PositionType type ) ;
bool setParentAnchor ( QCPItemAnchor * parentAnchor , bool keepPixelPosition = false ) ;
void setCoords ( double key , double value ) ;
void setCoords ( const QPointF & coords ) ;
void setAxes ( QCPAxis * keyAxis , QCPAxis * valueAxis ) ;
void setAxisRect ( QCPAxisRect * axisRect ) ;
void setPixelPoint ( const QPointF & pixelPoint ) ;
protected :
// property members:
PositionType mPositionType ;
2014-03-22 14:31:20 +00:00
QPointer < QCPAxis > mKeyAxis , mValueAxis ;
QPointer < QCPAxisRect > mAxisRect ;
2013-08-27 18:13:20 +00:00
double mKey , mValue ;
QCPItemAnchor * mParentAnchor ;
// reimplemented virtual methods:
virtual QCPItemPosition * toQCPItemPosition ( ) { return this ; }
private :
Q_DISABLE_COPY ( QCPItemPosition )
} ;
class QCP_LIB_DECL QCPAbstractItem : public QCPLayerable
{
Q_OBJECT
/// \cond INCLUDE_QPROPERTIES
Q_PROPERTY ( bool clipToAxisRect READ clipToAxisRect WRITE setClipToAxisRect )
Q_PROPERTY ( QCPAxisRect * clipAxisRect READ clipAxisRect WRITE setClipAxisRect )
2014-03-22 14:31:20 +00:00
Q_PROPERTY ( bool selectable READ selectable WRITE setSelectable NOTIFY selectableChanged )
Q_PROPERTY ( bool selected READ selected WRITE setSelected NOTIFY selectionChanged )
2013-08-27 18:13:20 +00:00
/// \endcond
public :
QCPAbstractItem ( QCustomPlot * parentPlot ) ;
virtual ~ QCPAbstractItem ( ) ;
// getters:
bool clipToAxisRect ( ) const { return mClipToAxisRect ; }
2014-03-22 14:31:20 +00:00
QCPAxisRect * clipAxisRect ( ) const ;
2013-08-27 18:13:20 +00:00
bool selectable ( ) const { return mSelectable ; }
bool selected ( ) const { return mSelected ; }
// setters:
void setClipToAxisRect ( bool clip ) ;
void setClipAxisRect ( QCPAxisRect * rect ) ;
2014-03-22 14:31:20 +00:00
Q_SLOT void setSelectable ( bool selectable ) ;
Q_SLOT void setSelected ( bool selected ) ;
2013-08-27 18:13:20 +00:00
// reimplemented virtual methods:
virtual double selectTest ( const QPointF & pos , bool onlySelectable , QVariant * details = 0 ) const = 0 ;
// non-virtual methods:
QList < QCPItemPosition * > positions ( ) const { return mPositions ; }
QList < QCPItemAnchor * > anchors ( ) const { return mAnchors ; }
QCPItemPosition * position ( const QString & name ) const ;
QCPItemAnchor * anchor ( const QString & name ) const ;
bool hasAnchor ( const QString & name ) const ;
signals :
void selectionChanged ( bool selected ) ;
2014-03-22 14:31:20 +00:00
void selectableChanged ( bool selectable ) ;
2013-08-27 18:13:20 +00:00
protected :
// property members:
bool mClipToAxisRect ;
2014-03-22 14:31:20 +00:00
QPointer < QCPAxisRect > mClipAxisRect ;
2013-08-27 18:13:20 +00:00
QList < QCPItemPosition * > mPositions ;
QList < QCPItemAnchor * > mAnchors ;
bool mSelectable , mSelected ;
// reimplemented virtual methods:
virtual QCP : : Interaction selectionCategory ( ) const ;
virtual QRect clipRect ( ) const ;
virtual void applyDefaultAntialiasingHint ( QCPPainter * painter ) const ;
virtual void draw ( QCPPainter * painter ) = 0 ;
// events:
virtual void selectEvent ( QMouseEvent * event , bool additive , const QVariant & details , bool * selectionStateChanged ) ;
virtual void deselectEvent ( bool * selectionStateChanged ) ;
// introduced virtual methods:
virtual QPointF anchorPixelPoint ( int anchorId ) const ;
// non-virtual methods:
double distSqrToLine ( const QPointF & start , const QPointF & end , const QPointF & point ) const ;
double rectSelectTest ( const QRectF & rect , const QPointF & pos , bool filledRect ) const ;
QCPItemPosition * createPosition ( const QString & name ) ;
QCPItemAnchor * createAnchor ( const QString & name , int anchorId ) ;
private :
Q_DISABLE_COPY ( QCPAbstractItem )
friend class QCustomPlot ;
friend class QCPItemAnchor ;
} ;
class QCP_LIB_DECL QCustomPlot : public QWidget
{
Q_OBJECT
/// \cond INCLUDE_QPROPERTIES
Q_PROPERTY ( QRect viewport READ viewport WRITE setViewport )
Q_PROPERTY ( QPixmap background READ background WRITE setBackground )
Q_PROPERTY ( bool backgroundScaled READ backgroundScaled WRITE setBackgroundScaled )
Q_PROPERTY ( Qt : : AspectRatioMode backgroundScaledMode READ backgroundScaledMode WRITE setBackgroundScaledMode )
Q_PROPERTY ( QCPLayoutGrid * plotLayout READ plotLayout )
Q_PROPERTY ( bool autoAddPlottableToLegend READ autoAddPlottableToLegend WRITE setAutoAddPlottableToLegend )
Q_PROPERTY ( int selectionTolerance READ selectionTolerance WRITE setSelectionTolerance )
Q_PROPERTY ( bool noAntialiasingOnDrag READ noAntialiasingOnDrag WRITE setNoAntialiasingOnDrag )
Q_PROPERTY ( Qt : : KeyboardModifier multiSelectModifier READ multiSelectModifier WRITE setMultiSelectModifier )
/// \endcond
public :
/*!
Defines how a layer should be inserted relative to an other layer .
\ see addLayer , moveLayer
*/
enum LayerInsertMode { limBelow ///< Layer is inserted below other layer
, limAbove ///< Layer is inserted above other layer
} ;
Q_ENUMS ( LayerInsertMode )
2014-03-22 14:31:20 +00:00
/*!
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.
} ;
2013-08-27 18:13:20 +00:00
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 ;
2014-03-22 14:31:20 +00:00
Q_SLOT void rescaleAxes ( bool onlyVisiblePlottables = false ) ;
2013-08-27 18:13:20 +00:00
QList < QCPAxis * > selectedAxes ( ) const ;
QList < QCPLegend * > selectedLegends ( ) const ;
Q_SLOT void deselectAll ( ) ;
2014-03-22 14:31:20 +00:00
bool savePdf ( const QString & fileName , bool noCosmeticPen = false , int width = 0 , int height = 0 , const QString & pdfCreator = " " , const QString & pdfTitle = " " ) ;
2013-08-27 18:13:20 +00:00
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 ) ;
2014-03-22 14:31:20 +00:00
Q_SLOT void replot ( QCustomPlot : : RefreshPriority refreshPriority = QCustomPlot : : rpHint ) ;
2013-08-27 18:13:20 +00:00
QCPAxis * xAxis , * yAxis , * xAxis2 , * yAxis2 ;
QCPLegend * legend ;
signals :
void mouseDoubleClick ( QMouseEvent * event ) ;
void mousePress ( QMouseEvent * event ) ;
void mouseMove ( QMouseEvent * event ) ;
void mouseRelease ( QMouseEvent * event ) ;
void mouseWheel ( QWheelEvent * event ) ;
void plottableClick ( QCPAbstractPlottable * plottable , QMouseEvent * event ) ;
void plottableDoubleClick ( QCPAbstractPlottable * plottable , QMouseEvent * event ) ;
void itemClick ( QCPAbstractItem * item , QMouseEvent * event ) ;
void itemDoubleClick ( QCPAbstractItem * item , QMouseEvent * event ) ;
void axisClick ( QCPAxis * axis , QCPAxis : : SelectablePart part , QMouseEvent * event ) ;
void axisDoubleClick ( QCPAxis * axis , QCPAxis : : SelectablePart part , QMouseEvent * event ) ;
void legendClick ( QCPLegend * legend , QCPAbstractLegendItem * item , QMouseEvent * event ) ;
void legendDoubleClick ( QCPLegend * legend , QCPAbstractLegendItem * item , QMouseEvent * event ) ;
void titleClick ( QMouseEvent * event , QCPPlotTitle * title ) ;
void titleDoubleClick ( QMouseEvent * event , QCPPlotTitle * title ) ;
void selectionChangedByUser ( ) ;
void beforeReplot ( ) ;
void afterReplot ( ) ;
protected :
// property members:
QRect mViewport ;
QCPLayoutGrid * mPlotLayout ;
bool mAutoAddPlottableToLegend ;
QList < QCPAbstractPlottable * > mPlottables ;
QList < QCPGraph * > mGraphs ; // extra list of plottables also in mPlottables that are of type QCPGraph
QList < QCPAbstractItem * > mItems ;
QList < QCPLayer * > mLayers ;
QCP : : AntialiasedElements mAntialiasedElements , mNotAntialiasedElements ;
QCP : : Interactions mInteractions ;
int mSelectionTolerance ;
bool mNoAntialiasingOnDrag ;
QBrush mBackgroundBrush ;
QPixmap mBackgroundPixmap ;
QPixmap mScaledBackgroundPixmap ;
bool mBackgroundScaled ;
Qt : : AspectRatioMode mBackgroundScaledMode ;
QCPLayer * mCurrentLayer ;
QCP : : PlottingHints mPlottingHints ;
Qt : : KeyboardModifier mMultiSelectModifier ;
// non-property members:
QPixmap mPaintBuffer ;
QPoint mMousePressPos ;
2014-03-22 14:31:20 +00:00
QPointer < QCPLayoutElement > mMouseEventElement ;
2013-08-27 18:13:20 +00:00
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 ;
} ;
2014-03-22 14:31:20 +00:00
class QCP_LIB_DECL QCPColorGradient
2013-08-27 18:13:20 +00:00
{
2014-03-22 14:31:20 +00:00
Q_GADGET
2013-08-27 18:13:20 +00:00
public :
/*!
2014-03-22 14:31:20 +00:00
Defines the color spaces in which color interpolation between gradient stops can be performed .
\ see setColorInterpolation
2013-08-27 18:13:20 +00:00
*/
2014-03-22 14:31:20 +00:00
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 )
2013-08-27 18:13:20 +00:00
/*!
2014-03-22 14:31:20 +00:00
Defines the available presets that can be loaded with \ ref loadPreset . See the documentation
there for an image of the presets .
2013-08-27 18:13:20 +00:00
*/
2014-03-22 14:31:20 +00:00
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 )
2013-08-27 18:13:20 +00:00
2014-03-22 14:31:20 +00:00
QCPColorGradient ( GradientPreset preset = gpCold ) ;
bool operator = = ( const QCPColorGradient & other ) const ;
bool operator ! = ( const QCPColorGradient & other ) const { return ! ( * this = = other ) ; }
2013-08-27 18:13:20 +00:00
// getters:
2014-03-22 14:31:20 +00:00
int levelCount ( ) const { return mLevelCount ; }
QMap < double , QColor > colorStops ( ) const { return mColorStops ; }
ColorInterpolation colorInterpolation ( ) const { return mColorInterpolation ; }
bool periodic ( ) const { return mPeriodic ; }
2013-08-27 18:13:20 +00:00
// setters:
2014-03-22 14:31:20 +00:00
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 ) ;
2013-08-27 18:13:20 +00:00
// non-property methods:
2014-03-22 14:31:20 +00:00
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 ;
2013-08-27 18:13:20 +00:00
protected :
2014-03-22 14:31:20 +00:00
void updateColorBuffer ( ) ;
2013-08-27 18:13:20 +00:00
2014-03-22 14:31:20 +00:00
// property members:
int mLevelCount ;
QMap < double , QColor > mColorStops ;
ColorInterpolation mColorInterpolation ;
bool mPeriodic ;
2013-08-27 18:13:20 +00:00
2014-03-22 14:31:20 +00:00
// non-property members:
QVector < QRgb > mColorBuffer ;
bool mColorBufferInvalidated ;
2013-08-27 18:13:20 +00:00
} ;
2014-03-22 14:31:20 +00:00
class QCP_LIB_DECL QCPAxisRect : public QCPLayoutElement
2013-08-27 18:13:20 +00:00
{
2014-03-22 14:31:20 +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
public :
explicit QCPAxisRect ( QCustomPlot * parentPlot , bool setupDefaultAxes = true ) ;
virtual ~ QCPAxisRect ( ) ;
// getters:
QPixmap background ( ) const { return mBackgroundPixmap ; }
bool backgroundScaled ( ) const { return mBackgroundScaled ; }
Qt : : AspectRatioMode backgroundScaledMode ( ) const { return mBackgroundScaledMode ; }
Qt : : Orientations rangeDrag ( ) const { return mRangeDrag ; }
Qt : : Orientations rangeZoom ( ) const { return mRangeZoom ; }
QCPAxis * rangeDragAxis ( Qt : : Orientation orientation ) ;
QCPAxis * rangeZoomAxis ( Qt : : Orientation orientation ) ;
double rangeZoomFactor ( Qt : : Orientation orientation ) ;
// setters:
void setBackground ( const QPixmap & pm ) ;
void setBackground ( const QPixmap & pm , bool scaled , Qt : : AspectRatioMode mode = Qt : : KeepAspectRatioByExpanding ) ;
void setBackground ( const QBrush & brush ) ;
void setBackgroundScaled ( bool scaled ) ;
void setBackgroundScaledMode ( Qt : : AspectRatioMode mode ) ;
void setRangeDrag ( Qt : : Orientations orientations ) ;
void setRangeZoom ( Qt : : Orientations orientations ) ;
void setRangeDragAxes ( QCPAxis * horizontal , QCPAxis * vertical ) ;
void setRangeZoomAxes ( QCPAxis * horizontal , QCPAxis * vertical ) ;
void setRangeZoomFactor ( double horizontalFactor , double verticalFactor ) ;
void setRangeZoomFactor ( double factor ) ;
// non-property methods:
int axisCount ( QCPAxis : : AxisType type ) const ;
QCPAxis * axis ( QCPAxis : : AxisType type , int index = 0 ) const ;
QList < QCPAxis * > axes ( QCPAxis : : AxisTypes types ) const ;
QList < QCPAxis * > axes ( ) const ;
QCPAxis * addAxis ( QCPAxis : : AxisType type ) ;
QList < QCPAxis * > addAxes ( QCPAxis : : AxisTypes types ) ;
bool removeAxis ( QCPAxis * axis ) ;
QCPLayoutInset * insetLayout ( ) const { return mInsetLayout ; }
void setupFullAxesBox ( bool connectRanges = false ) ;
QList < QCPAbstractPlottable * > plottables ( ) const ;
QList < QCPGraph * > graphs ( ) const ;
QList < QCPAbstractItem * > items ( ) const ;
// read-only interface imitating a QRect:
int left ( ) const { return mRect . left ( ) ; }
int right ( ) const { return mRect . right ( ) ; }
int top ( ) const { return mRect . top ( ) ; }
int bottom ( ) const { return mRect . bottom ( ) ; }
int width ( ) const { return mRect . width ( ) ; }
int height ( ) const { return mRect . height ( ) ; }
QSize size ( ) const { return mRect . size ( ) ; }
QPoint topLeft ( ) const { return mRect . topLeft ( ) ; }
QPoint topRight ( ) const { return mRect . topRight ( ) ; }
QPoint bottomLeft ( ) const { return mRect . bottomLeft ( ) ; }
QPoint bottomRight ( ) const { return mRect . bottomRight ( ) ; }
QPoint center ( ) const { return mRect . center ( ) ; }
// reimplemented virtual methods:
virtual void update ( UpdatePhase phase ) ;
virtual QList < QCPLayoutElement * > elements ( bool recursive ) const ;
protected :
// property members:
QBrush mBackgroundBrush ;
QPixmap mBackgroundPixmap ;
QPixmap mScaledBackgroundPixmap ;
bool mBackgroundScaled ;
Qt : : AspectRatioMode mBackgroundScaledMode ;
QCPLayoutInset * mInsetLayout ;
Qt : : Orientations mRangeDrag , mRangeZoom ;
QPointer < QCPAxis > mRangeDragHorzAxis , mRangeDragVertAxis , mRangeZoomHorzAxis , mRangeZoomVertAxis ;
double mRangeZoomFactorHorz , mRangeZoomFactorVert ;
// non-property members:
QCPRange mDragStartHorzRange , mDragStartVertRange ;
QCP : : AntialiasedElements mAADragBackup , mNotAADragBackup ;
QPoint mDragStart ;
bool mDragging ;
QHash < QCPAxis : : AxisType , QList < QCPAxis * > > mAxes ;
// reimplemented virtual methods:
virtual void applyDefaultAntialiasingHint ( QCPPainter * painter ) const ;
virtual void draw ( QCPPainter * painter ) ;
virtual int calculateAutoMargin ( QCP : : MarginSide side ) ;
// events:
virtual void mousePressEvent ( QMouseEvent * event ) ;
virtual void mouseMoveEvent ( QMouseEvent * event ) ;
virtual void mouseReleaseEvent ( QMouseEvent * event ) ;
virtual void wheelEvent ( QWheelEvent * event ) ;
// non-property methods:
void drawBackground ( QCPPainter * painter ) ;
void updateAxesOffset ( QCPAxis : : AxisType type ) ;
private :
Q_DISABLE_COPY ( QCPAxisRect )
friend class QCustomPlot ;
} ;
class QCP_LIB_DECL QCPAbstractLegendItem : public QCPLayoutElement
{
Q_OBJECT
/// \cond INCLUDE_QPROPERTIES
Q_PROPERTY ( QCPLegend * parentLegend READ parentLegend )
Q_PROPERTY ( QFont font READ font WRITE setFont )
Q_PROPERTY ( QColor textColor READ textColor WRITE setTextColor )
Q_PROPERTY ( QFont selectedFont READ selectedFont WRITE setSelectedFont )
Q_PROPERTY ( QColor selectedTextColor READ selectedTextColor WRITE setSelectedTextColor )
Q_PROPERTY ( bool selectable READ selectable WRITE setSelectable NOTIFY selectionChanged )
Q_PROPERTY ( bool selected READ selected WRITE setSelected NOTIFY selectableChanged )
/// \endcond
public :
explicit QCPAbstractLegendItem ( QCPLegend * parent ) ;
// getters:
QCPLegend * parentLegend ( ) const { return mParentLegend ; }
QFont font ( ) const { return mFont ; }
QColor textColor ( ) const { return mTextColor ; }
QFont selectedFont ( ) const { return mSelectedFont ; }
QColor selectedTextColor ( ) const { return mSelectedTextColor ; }
bool selectable ( ) const { return mSelectable ; }
bool selected ( ) const { return mSelected ; }
// setters:
void setFont ( const QFont & font ) ;
void setTextColor ( const QColor & color ) ;
void setSelectedFont ( const QFont & font ) ;
void setSelectedTextColor ( const QColor & color ) ;
Q_SLOT void setSelectable ( bool selectable ) ;
Q_SLOT void setSelected ( bool selected ) ;
// reimplemented virtual methods:
virtual double selectTest ( const QPointF & pos , bool onlySelectable , QVariant * details = 0 ) const ;
signals :
void selectionChanged ( bool selected ) ;
void selectableChanged ( bool selectable ) ;
protected :
// property members:
QCPLegend * mParentLegend ;
QFont mFont ;
QColor mTextColor ;
QFont mSelectedFont ;
QColor mSelectedTextColor ;
bool mSelectable , mSelected ;
// reimplemented virtual methods:
virtual QCP : : Interaction selectionCategory ( ) const ;
virtual void applyDefaultAntialiasingHint ( QCPPainter * painter ) const ;
virtual QRect clipRect ( ) const ;
virtual void draw ( QCPPainter * painter ) = 0 ;
// events:
virtual void selectEvent ( QMouseEvent * event , bool additive , const QVariant & details , bool * selectionStateChanged ) ;
virtual void deselectEvent ( bool * selectionStateChanged ) ;
private :
Q_DISABLE_COPY ( QCPAbstractLegendItem )
friend class QCPLegend ;
} ;
class QCP_LIB_DECL QCPPlottableLegendItem : public QCPAbstractLegendItem
{
Q_OBJECT
public :
QCPPlottableLegendItem ( QCPLegend * parent , QCPAbstractPlottable * plottable ) ;
// getters:
QCPAbstractPlottable * plottable ( ) { return mPlottable ; }
protected :
// property members:
QCPAbstractPlottable * mPlottable ;
// reimplemented virtual methods:
virtual void draw ( QCPPainter * painter ) ;
virtual QSize minimumSizeHint ( ) const ;
// non-virtual methods:
QPen getIconBorderPen ( ) const ;
QColor getTextColor ( ) const ;
QFont getFont ( ) const ;
} ;
class QCP_LIB_DECL QCPLegend : public QCPLayoutGrid
{
Q_OBJECT
/// \cond INCLUDE_QPROPERTIES
Q_PROPERTY ( QPen borderPen READ borderPen WRITE setBorderPen )
Q_PROPERTY ( QBrush brush READ brush WRITE setBrush )
Q_PROPERTY ( QFont font READ font WRITE setFont )
Q_PROPERTY ( QColor textColor READ textColor WRITE setTextColor )
Q_PROPERTY ( QSize iconSize READ iconSize WRITE setIconSize )
Q_PROPERTY ( int iconTextPadding READ iconTextPadding WRITE setIconTextPadding )
Q_PROPERTY ( QPen iconBorderPen READ iconBorderPen WRITE setIconBorderPen )
Q_PROPERTY ( SelectableParts selectableParts READ selectableParts WRITE setSelectableParts NOTIFY selectionChanged )
Q_PROPERTY ( SelectableParts selectedParts READ selectedParts WRITE setSelectedParts NOTIFY selectableChanged )
Q_PROPERTY ( QPen selectedBorderPen READ selectedBorderPen WRITE setSelectedBorderPen )
Q_PROPERTY ( QPen selectedIconBorderPen READ selectedIconBorderPen WRITE setSelectedIconBorderPen )
Q_PROPERTY ( QBrush selectedBrush READ selectedBrush WRITE setSelectedBrush )
Q_PROPERTY ( QFont selectedFont READ selectedFont WRITE setSelectedFont )
Q_PROPERTY ( QColor selectedTextColor READ selectedTextColor WRITE setSelectedTextColor )
/// \endcond
public :
/*!
Defines the selectable parts of a legend
\ see setSelectedParts , setSelectableParts
*/
enum SelectablePart { spNone = 0x000 ///< <tt>0x000</tt> None
, spLegendBox = 0x001 ///< <tt>0x001</tt> The legend box (frame)
, spItems = 0x002 ///< <tt>0x002</tt> Legend items individually (see \ref selectedItems)
} ;
Q_FLAGS ( SelectablePart SelectableParts )
Q_DECLARE_FLAGS ( SelectableParts , SelectablePart )
explicit QCPLegend ( ) ;
virtual ~ QCPLegend ( ) ;
// getters:
QPen borderPen ( ) const { return mBorderPen ; }
QBrush brush ( ) const { return mBrush ; }
QFont font ( ) const { return mFont ; }
QColor textColor ( ) const { return mTextColor ; }
QSize iconSize ( ) const { return mIconSize ; }
int iconTextPadding ( ) const { return mIconTextPadding ; }
QPen iconBorderPen ( ) const { return mIconBorderPen ; }
SelectableParts selectableParts ( ) const { return mSelectableParts ; }
SelectableParts selectedParts ( ) const ;
QPen selectedBorderPen ( ) const { return mSelectedBorderPen ; }
QPen selectedIconBorderPen ( ) const { return mSelectedIconBorderPen ; }
QBrush selectedBrush ( ) const { return mSelectedBrush ; }
QFont selectedFont ( ) const { return mSelectedFont ; }
QColor selectedTextColor ( ) const { return mSelectedTextColor ; }
// setters:
void setBorderPen ( const QPen & pen ) ;
void setBrush ( const QBrush & brush ) ;
void setFont ( const QFont & font ) ;
void setTextColor ( const QColor & color ) ;
void setIconSize ( const QSize & size ) ;
void setIconSize ( int width , int height ) ;
void setIconTextPadding ( int padding ) ;
void setIconBorderPen ( const QPen & pen ) ;
Q_SLOT void setSelectableParts ( const SelectableParts & selectableParts ) ;
Q_SLOT void setSelectedParts ( const SelectableParts & selectedParts ) ;
void setSelectedBorderPen ( const QPen & pen ) ;
void setSelectedIconBorderPen ( const QPen & pen ) ;
void setSelectedBrush ( const QBrush & brush ) ;
void setSelectedFont ( const QFont & font ) ;
void setSelectedTextColor ( const QColor & color ) ;
// reimplemented virtual methods:
virtual double selectTest ( const QPointF & pos , bool onlySelectable , QVariant * details = 0 ) const ;
// non-virtual methods:
QCPAbstractLegendItem * item ( int index ) const ;
QCPPlottableLegendItem * itemWithPlottable ( const QCPAbstractPlottable * plottable ) const ;
int itemCount ( ) const ;
bool hasItem ( QCPAbstractLegendItem * item ) const ;
bool hasItemWithPlottable ( const QCPAbstractPlottable * plottable ) const ;
bool addItem ( QCPAbstractLegendItem * item ) ;
bool removeItem ( int index ) ;
bool removeItem ( QCPAbstractLegendItem * item ) ;
void clearItems ( ) ;
QList < QCPAbstractLegendItem * > selectedItems ( ) const ;
signals :
void selectionChanged ( QCPLegend : : SelectableParts parts ) ;
void selectableChanged ( QCPLegend : : SelectableParts parts ) ;
protected :
// property members:
QPen mBorderPen , mIconBorderPen ;
QBrush mBrush ;
QFont mFont ;
QColor mTextColor ;
QSize mIconSize ;
int mIconTextPadding ;
SelectableParts mSelectedParts , mSelectableParts ;
QPen mSelectedBorderPen , mSelectedIconBorderPen ;
QBrush mSelectedBrush ;
QFont mSelectedFont ;
QColor mSelectedTextColor ;
// reimplemented virtual methods:
virtual void parentPlotInitialized ( QCustomPlot * parentPlot ) ;
virtual QCP : : Interaction selectionCategory ( ) const ;
virtual void applyDefaultAntialiasingHint ( QCPPainter * painter ) const ;
virtual void draw ( QCPPainter * painter ) ;
// events:
virtual void selectEvent ( QMouseEvent * event , bool additive , const QVariant & details , bool * selectionStateChanged ) ;
virtual void deselectEvent ( bool * selectionStateChanged ) ;
// non-virtual methods:
QPen getBorderPen ( ) const ;
QBrush getBrush ( ) const ;
private :
Q_DISABLE_COPY ( QCPLegend )
friend class QCustomPlot ;
friend class QCPAbstractLegendItem ;
} ;
Q_DECLARE_OPERATORS_FOR_FLAGS ( QCPLegend : : SelectableParts )
Q_DECLARE_METATYPE ( QCPLegend : : SelectablePart )
class QCP_LIB_DECL QCPPlotTitle : public QCPLayoutElement
{
Q_OBJECT
/// \cond INCLUDE_QPROPERTIES
Q_PROPERTY ( QString text READ text WRITE setText )
Q_PROPERTY ( QFont font READ font WRITE setFont )
Q_PROPERTY ( QColor textColor READ textColor WRITE setTextColor )
Q_PROPERTY ( QFont selectedFont READ selectedFont WRITE setSelectedFont )
Q_PROPERTY ( QColor selectedTextColor READ selectedTextColor WRITE setSelectedTextColor )
Q_PROPERTY ( bool selectable READ selectable WRITE setSelectable NOTIFY selectableChanged )
Q_PROPERTY ( bool selected READ selected WRITE setSelected NOTIFY selectionChanged )
/// \endcond
public :
explicit QCPPlotTitle ( QCustomPlot * parentPlot ) ;
explicit QCPPlotTitle ( QCustomPlot * parentPlot , const QString & text ) ;
// getters:
QString text ( ) const { return mText ; }
QFont font ( ) const { return mFont ; }
QColor textColor ( ) const { return mTextColor ; }
QFont selectedFont ( ) const { return mSelectedFont ; }
QColor selectedTextColor ( ) const { return mSelectedTextColor ; }
bool selectable ( ) const { return mSelectable ; }
bool selected ( ) const { return mSelected ; }
// setters:
void setText ( const QString & text ) ;
void setFont ( const QFont & font ) ;
void setTextColor ( const QColor & color ) ;
void setSelectedFont ( const QFont & font ) ;
void setSelectedTextColor ( const QColor & color ) ;
Q_SLOT void setSelectable ( bool selectable ) ;
Q_SLOT void setSelected ( bool selected ) ;
// reimplemented virtual methods:
virtual double selectTest ( const QPointF & pos , bool onlySelectable , QVariant * details = 0 ) const ;
signals :
void selectionChanged ( bool selected ) ;
void selectableChanged ( bool selectable ) ;
protected :
// property members:
QString mText ;
QFont mFont ;
QColor mTextColor ;
QFont mSelectedFont ;
QColor mSelectedTextColor ;
QRect mTextBoundingRect ;
bool mSelectable , mSelected ;
// reimplemented virtual methods:
virtual void applyDefaultAntialiasingHint ( QCPPainter * painter ) const ;
virtual void draw ( QCPPainter * painter ) ;
virtual QSize minimumSizeHint ( ) const ;
virtual QSize maximumSizeHint ( ) const ;
// events:
virtual void selectEvent ( QMouseEvent * event , bool additive , const QVariant & details , bool * selectionStateChanged ) ;
virtual void deselectEvent ( bool * selectionStateChanged ) ;
// non-virtual methods:
QFont mainFont ( ) const ;
QColor mainTextColor ( ) const ;
private :
Q_DISABLE_COPY ( QCPPlotTitle )
} ;
class QCPColorScaleAxisRectPrivate : public QCPAxisRect
{
Q_OBJECT
public :
explicit QCPColorScaleAxisRectPrivate ( QCPColorScale * parentColorScale ) ;
protected :
QCPColorScale * mParentColorScale ;
QImage mGradientImage ;
bool mGradientImageInvalidated ;
// re-using some methods of QCPAxisRect to make them available to friend class QCPColorScale
using QCPAxisRect : : calculateAutoMargin ;
using QCPAxisRect : : mousePressEvent ;
using QCPAxisRect : : mouseMoveEvent ;
using QCPAxisRect : : mouseReleaseEvent ;
using QCPAxisRect : : wheelEvent ;
using QCPAxisRect : : update ;
virtual void draw ( QCPPainter * painter ) ;
void updateGradientImage ( ) ;
Q_SLOT void axisSelectionChanged ( QCPAxis : : SelectableParts selectedParts ) ;
Q_SLOT void axisSelectableChanged ( QCPAxis : : SelectableParts selectableParts ) ;
friend class QCPColorScale ;
} ;
class QCP_LIB_DECL QCPColorScale : public QCPLayoutElement
{
Q_OBJECT
/// \cond INCLUDE_QPROPERTIES
Q_PROPERTY ( QCPAxis : : AxisType type READ type WRITE setType )
Q_PROPERTY ( QCPRange dataRange READ dataRange WRITE setDataRange NOTIFY dataRangeChanged )
Q_PROPERTY ( QCPAxis : : ScaleType dataScaleType READ dataScaleType WRITE setDataScaleType NOTIFY dataScaleTypeChanged )
Q_PROPERTY ( QCPColorGradient gradient READ gradient WRITE setGradient NOTIFY gradientChanged )
Q_PROPERTY ( QString label READ label WRITE setLabel )
Q_PROPERTY ( int barWidth READ barWidth WRITE setBarWidth )
Q_PROPERTY ( bool rangeDrag READ rangeDrag WRITE setRangeDrag )
Q_PROPERTY ( bool rangeZoom READ rangeZoom WRITE setRangeZoom )
/// \endcond
public :
explicit QCPColorScale ( QCustomPlot * parentPlot ) ;
virtual ~ QCPColorScale ( ) ;
// getters:
QCPAxis * axis ( ) const { return mColorAxis . data ( ) ; }
QCPAxis : : AxisType type ( ) const { return mType ; }
QCPRange dataRange ( ) const { return mDataRange ; }
QCPAxis : : ScaleType dataScaleType ( ) const { return mDataScaleType ; }
QCPColorGradient gradient ( ) const { return mGradient ; }
QString label ( ) const ;
int barWidth ( ) const { return mBarWidth ; }
bool rangeDrag ( ) const ;
bool rangeZoom ( ) const ;
// setters:
void setType ( QCPAxis : : AxisType type ) ;
Q_SLOT void setDataRange ( const QCPRange & dataRange ) ;
Q_SLOT void setDataScaleType ( QCPAxis : : ScaleType scaleType ) ;
Q_SLOT void setGradient ( const QCPColorGradient & gradient ) ;
void setLabel ( const QString & str ) ;
void setBarWidth ( int width ) ;
void setRangeDrag ( bool enabled ) ;
void setRangeZoom ( bool enabled ) ;
// non-property methods:
QList < QCPColorMap * > colorMaps ( ) const ;
void rescaleDataRange ( bool onlyVisibleMaps ) ;
// reimplemented virtual methods:
virtual void update ( UpdatePhase phase ) ;
signals :
void dataRangeChanged ( QCPRange newRange ) ;
void dataScaleTypeChanged ( QCPAxis : : ScaleType scaleType ) ;
void gradientChanged ( QCPColorGradient newGradient ) ;
protected :
// property members:
QCPAxis : : AxisType mType ;
QCPRange mDataRange ;
QCPAxis : : ScaleType mDataScaleType ;
QCPColorGradient mGradient ;
int mBarWidth ;
// non-property members:
QPointer < QCPColorScaleAxisRectPrivate > mAxisRect ;
QPointer < QCPAxis > mColorAxis ;
// reimplemented virtual methods:
virtual void applyDefaultAntialiasingHint ( QCPPainter * painter ) const ;
// events:
virtual void mousePressEvent ( QMouseEvent * event ) ;
virtual void mouseMoveEvent ( QMouseEvent * event ) ;
virtual void mouseReleaseEvent ( QMouseEvent * event ) ;
virtual void wheelEvent ( QWheelEvent * event ) ;
private :
Q_DISABLE_COPY ( QCPColorScale )
friend class QCPColorScaleAxisRectPrivate ;
} ;
/*! \file */
class QCP_LIB_DECL QCPData
{
public :
QCPData ( ) ;
QCPData ( double key , double value ) ;
double key , value ;
double keyErrorPlus , keyErrorMinus ;
double valueErrorPlus , valueErrorMinus ;
} ;
Q_DECLARE_TYPEINFO ( QCPData , Q_MOVABLE_TYPE ) ;
/*! \typedef QCPDataMap
Container for storing QCPData items in a sorted fashion . The key of the map
is the key member of the QCPData instance .
This is the container in which QCPGraph holds its data .
\ see QCPData , QCPGraph : : setData
*/
typedef QMap < double , QCPData > QCPDataMap ;
typedef QMapIterator < double , QCPData > QCPDataMapIterator ;
typedef QMutableMapIterator < double , QCPData > QCPDataMutableMapIterator ;
class QCP_LIB_DECL QCPGraph : public QCPAbstractPlottable
{
Q_OBJECT
/// \cond INCLUDE_QPROPERTIES
Q_PROPERTY ( LineStyle lineStyle READ lineStyle WRITE setLineStyle )
Q_PROPERTY ( QCPScatterStyle scatterStyle READ scatterStyle WRITE setScatterStyle )
Q_PROPERTY ( ErrorType errorType READ errorType WRITE setErrorType )
Q_PROPERTY ( QPen errorPen READ errorPen WRITE setErrorPen )
Q_PROPERTY ( double errorBarSize READ errorBarSize WRITE setErrorBarSize )
Q_PROPERTY ( bool errorBarSkipSymbol READ errorBarSkipSymbol WRITE setErrorBarSkipSymbol )
Q_PROPERTY ( QCPGraph * channelFillGraph READ channelFillGraph WRITE setChannelFillGraph )
Q_PROPERTY ( bool adaptiveSampling READ adaptiveSampling WRITE setAdaptiveSampling )
/// \endcond
public :
/*!
Defines how the graph ' s line is represented visually in the plot . The line is drawn with the
current pen of the graph ( \ ref setPen ) .
\ see setLineStyle
*/
enum LineStyle { lsNone ///< data points are not connected with any lines (e.g. data only represented
///< with symbols according to the scatter style, see \ref setScatterStyle)
, lsLine ///< data points are connected by a straight line
, lsStepLeft ///< line is drawn as steps where the step height is the value of the left data point
, lsStepRight ///< line is drawn as steps where the step height is the value of the right data point
, lsStepCenter ///< line is drawn as steps where the step is in between two data points
, lsImpulse ///< each data point is represented by a line parallel to the value axis, which reaches from the data point to the zero-value-line
} ;
Q_ENUMS ( LineStyle )
/*!
Defines what kind of error bars are drawn for each data point
*/
enum ErrorType { etNone ///< No error bars are shown
, etKey ///< Error bars for the key dimension of the data point are shown
, etValue ///< Error bars for the value dimension of the data point are shown
, etBoth ///< Error bars for both key and value dimensions of the data point are shown
} ;
Q_ENUMS ( ErrorType )
explicit QCPGraph ( QCPAxis * keyAxis , QCPAxis * valueAxis ) ;
virtual ~ QCPGraph ( ) ;
// getters:
QCPDataMap * data ( ) const { return mData ; }
LineStyle lineStyle ( ) const { return mLineStyle ; }
QCPScatterStyle scatterStyle ( ) const { return mScatterStyle ; }
ErrorType errorType ( ) const { return mErrorType ; }
QPen errorPen ( ) const { return mErrorPen ; }
double errorBarSize ( ) const { return mErrorBarSize ; }
bool errorBarSkipSymbol ( ) const { return mErrorBarSkipSymbol ; }
QCPGraph * channelFillGraph ( ) const { return mChannelFillGraph . data ( ) ; }
bool adaptiveSampling ( ) const { return mAdaptiveSampling ; }
// setters:
void setData ( QCPDataMap * data , bool copy = false ) ;
void setData ( const QVector < double > & key , const QVector < double > & value ) ;
void setDataKeyError ( const QVector < double > & key , const QVector < double > & value , const QVector < double > & keyError ) ;
void setDataKeyError ( const QVector < double > & key , const QVector < double > & value , const QVector < double > & keyErrorMinus , const QVector < double > & keyErrorPlus ) ;
void setDataValueError ( const QVector < double > & key , const QVector < double > & value , const QVector < double > & valueError ) ;
void setDataValueError ( const QVector < double > & key , const QVector < double > & value , const QVector < double > & valueErrorMinus , const QVector < double > & valueErrorPlus ) ;
void setDataBothError ( const QVector < double > & key , const QVector < double > & value , const QVector < double > & keyError , const QVector < double > & valueError ) ;
void setDataBothError ( const QVector < double > & key , const QVector < double > & value , const QVector < double > & keyErrorMinus , const QVector < double > & keyErrorPlus , const QVector < double > & valueErrorMinus , const QVector < double > & valueErrorPlus ) ;
void setLineStyle ( LineStyle ls ) ;
void setScatterStyle ( const QCPScatterStyle & style ) ;
void setErrorType ( ErrorType errorType ) ;
void setErrorPen ( const QPen & pen ) ;
void setErrorBarSize ( double size ) ;
void setErrorBarSkipSymbol ( bool enabled ) ;
void setChannelFillGraph ( QCPGraph * targetGraph ) ;
void setAdaptiveSampling ( bool enabled ) ;
// non-property methods:
void addData ( const QCPDataMap & dataMap ) ;
void addData ( const QCPData & data ) ;
void addData ( double key , double value ) ;
void addData ( const QVector < double > & keys , const QVector < double > & values ) ;
void removeDataBefore ( double key ) ;
void removeDataAfter ( double key ) ;
void removeData ( double fromKey , double toKey ) ;
void removeData ( double key ) ;
// reimplemented virtual methods:
virtual void clearData ( ) ;
virtual double selectTest ( const QPointF & pos , bool onlySelectable , QVariant * details = 0 ) const ;
using QCPAbstractPlottable : : rescaleAxes ;
using QCPAbstractPlottable : : rescaleKeyAxis ;
using QCPAbstractPlottable : : rescaleValueAxis ;
void rescaleAxes ( bool onlyEnlarge , bool includeErrorBars ) const ; // overloads base class interface
void rescaleKeyAxis ( bool onlyEnlarge , bool includeErrorBars ) const ; // overloads base class interface
void rescaleValueAxis ( bool onlyEnlarge , bool includeErrorBars ) const ; // overloads base class interface
protected :
// property members:
QCPDataMap * mData ;
QPen mErrorPen ;
LineStyle mLineStyle ;
QCPScatterStyle mScatterStyle ;
ErrorType mErrorType ;
double mErrorBarSize ;
bool mErrorBarSkipSymbol ;
QPointer < QCPGraph > mChannelFillGraph ;
bool mAdaptiveSampling ;
// reimplemented virtual methods:
virtual void draw ( QCPPainter * painter ) ;
virtual void drawLegendIcon ( QCPPainter * painter , const QRectF & rect ) const ;
virtual QCPRange getKeyRange ( bool & foundRange , SignDomain inSignDomain = sdBoth ) const ;
virtual QCPRange getValueRange ( bool & foundRange , SignDomain inSignDomain = sdBoth ) const ;
virtual QCPRange getKeyRange ( bool & foundRange , SignDomain inSignDomain , bool includeErrors ) const ; // overloads base class interface
virtual QCPRange getValueRange ( bool & foundRange , SignDomain inSignDomain , bool includeErrors ) const ; // overloads base class interface
// introduced virtual methods:
virtual void drawFill ( QCPPainter * painter , QVector < QPointF > * lineData ) const ;
virtual void drawScatterPlot ( QCPPainter * painter , QVector < QCPData > * scatterData ) const ;
virtual void drawLinePlot ( QCPPainter * painter , QVector < QPointF > * lineData ) const ;
virtual void drawImpulsePlot ( QCPPainter * painter , QVector < QPointF > * lineData ) const ;
// non-virtual methods:
void getPreparedData ( QVector < QCPData > * lineData , QVector < QCPData > * scatterData ) const ;
void getPlotData ( QVector < QPointF > * lineData , QVector < QCPData > * scatterData ) const ;
void getScatterPlotData ( QVector < QCPData > * scatterData ) const ;
void getLinePlotData ( QVector < QPointF > * linePixelData , QVector < QCPData > * scatterData ) const ;
void getStepLeftPlotData ( QVector < QPointF > * linePixelData , QVector < QCPData > * scatterData ) const ;
void getStepRightPlotData ( QVector < QPointF > * linePixelData , QVector < QCPData > * scatterData ) const ;
void getStepCenterPlotData ( QVector < QPointF > * linePixelData , QVector < QCPData > * scatterData ) const ;
void getImpulsePlotData ( QVector < QPointF > * linePixelData , QVector < QCPData > * scatterData ) const ;
void drawError ( QCPPainter * painter , double x , double y , const QCPData & data ) const ;
void getVisibleDataBounds ( QCPDataMap : : const_iterator & lower , QCPDataMap : : const_iterator & upper ) const ;
int countDataInBounds ( const QCPDataMap : : const_iterator & lower , const QCPDataMap : : const_iterator & upper , int maxCount ) const ;
void addFillBasePoints ( QVector < QPointF > * lineData ) const ;
void removeFillBasePoints ( QVector < QPointF > * lineData ) const ;
QPointF lowerFillBasePoint ( double lowerKey ) const ;
QPointF upperFillBasePoint ( double upperKey ) const ;
const QPolygonF getChannelFillPolygon ( const QVector < QPointF > * lineData ) const ;
int findIndexBelowX ( const QVector < QPointF > * data , double x ) const ;
int findIndexAboveX ( const QVector < QPointF > * data , double x ) const ;
int findIndexBelowY ( const QVector < QPointF > * data , double y ) const ;
int findIndexAboveY ( const QVector < QPointF > * data , double y ) const ;
double pointDistance ( const QPointF & pixelPoint ) const ;
friend class QCustomPlot ;
friend class QCPLegend ;
} ;
/*! \file */
class QCP_LIB_DECL QCPCurveData
{
public :
2013-08-27 18:13:20 +00:00
QCPCurveData ( ) ;
QCPCurveData ( double t , double key , double value ) ;
double t , key , value ;
} ;
Q_DECLARE_TYPEINFO ( QCPCurveData , Q_MOVABLE_TYPE ) ;
/*! \typedef QCPCurveDataMap
Container for storing QCPCurveData items in a sorted fashion . The key of the map
is the t member of the QCPCurveData instance .
This is the container in which QCPCurve holds its data .
\ see QCPCurveData , QCPCurve : : setData
*/
typedef QMap < double , QCPCurveData > QCPCurveDataMap ;
typedef QMapIterator < double , QCPCurveData > QCPCurveDataMapIterator ;
typedef QMutableMapIterator < double , QCPCurveData > QCPCurveDataMutableMapIterator ;
class QCP_LIB_DECL QCPCurve : public QCPAbstractPlottable
{
Q_OBJECT
/// \cond INCLUDE_QPROPERTIES
Q_PROPERTY ( QCPScatterStyle scatterStyle READ scatterStyle WRITE setScatterStyle )
Q_PROPERTY ( LineStyle lineStyle READ lineStyle WRITE setLineStyle )
/// \endcond
public :
/*!
Defines how the curve ' s line is represented visually in the plot . The line is drawn with the
current pen of the curve ( \ ref setPen ) .
\ see setLineStyle
*/
2014-03-22 14:31:20 +00:00
enum LineStyle { lsNone ///< No line is drawn between data points (e.g. only scatters)
, lsLine ///< Data points are connected with a straight line
2013-08-27 18:13:20 +00:00
} ;
explicit QCPCurve ( QCPAxis * keyAxis , QCPAxis * valueAxis ) ;
virtual ~ QCPCurve ( ) ;
// getters:
QCPCurveDataMap * data ( ) const { return mData ; }
QCPScatterStyle scatterStyle ( ) const { return mScatterStyle ; }
LineStyle lineStyle ( ) const { return mLineStyle ; }
// setters:
void setData ( QCPCurveDataMap * data , bool copy = false ) ;
void setData ( const QVector < double > & t , const QVector < double > & key , const QVector < double > & value ) ;
void setData ( const QVector < double > & key , const QVector < double > & value ) ;
void setScatterStyle ( const QCPScatterStyle & style ) ;
void setLineStyle ( LineStyle style ) ;
// non-property methods:
void addData ( const QCPCurveDataMap & dataMap ) ;
void addData ( const QCPCurveData & data ) ;
void addData ( double t , double key , double value ) ;
void addData ( double key , double value ) ;
void addData ( const QVector < double > & ts , const QVector < double > & keys , const QVector < double > & values ) ;
void removeDataBefore ( double t ) ;
void removeDataAfter ( double t ) ;
void removeData ( double fromt , double tot ) ;
void removeData ( double t ) ;
// reimplemented virtual methods:
virtual void clearData ( ) ;
virtual double selectTest ( const QPointF & pos , bool onlySelectable , QVariant * details = 0 ) const ;
protected :
// property members:
QCPCurveDataMap * mData ;
QCPScatterStyle mScatterStyle ;
LineStyle mLineStyle ;
// reimplemented virtual methods:
virtual void draw ( QCPPainter * painter ) ;
virtual void drawLegendIcon ( QCPPainter * painter , const QRectF & rect ) const ;
2014-03-22 14:31:20 +00:00
virtual QCPRange getKeyRange ( bool & foundRange , SignDomain inSignDomain = sdBoth ) const ;
virtual QCPRange getValueRange ( bool & foundRange , SignDomain inSignDomain = sdBoth ) const ;
2013-08-27 18:13:20 +00:00
// introduced virtual methods:
virtual void drawScatterPlot ( QCPPainter * painter , const QVector < QPointF > * pointData ) const ;
// non-virtual methods:
void getCurveData ( QVector < QPointF > * lineData ) const ;
double pointDistance ( const QPointF & pixelPoint ) const ;
QPointF outsideCoordsToPixels ( double key , double value , int region , QRect axisRect ) const ;
friend class QCustomPlot ;
friend class QCPLegend ;
} ;
/*! \file */
class QCP_LIB_DECL QCPBarData
{
public :
QCPBarData ( ) ;
QCPBarData ( double key , double value ) ;
double key , value ;
} ;
Q_DECLARE_TYPEINFO ( QCPBarData , Q_MOVABLE_TYPE ) ;
/*! \typedef QCPBarDataMap
Container for storing QCPBarData items in a sorted fashion . The key of the map
is the key member of the QCPBarData instance .
This is the container in which QCPBars holds its data .
\ see QCPBarData , QCPBars : : setData
*/
typedef QMap < double , QCPBarData > QCPBarDataMap ;
typedef QMapIterator < double , QCPBarData > QCPBarDataMapIterator ;
typedef QMutableMapIterator < double , QCPBarData > QCPBarDataMutableMapIterator ;
class QCP_LIB_DECL QCPBars : public QCPAbstractPlottable
{
Q_OBJECT
/// \cond INCLUDE_QPROPERTIES
Q_PROPERTY ( double width READ width WRITE setWidth )
Q_PROPERTY ( QCPBars * barBelow READ barBelow )
Q_PROPERTY ( QCPBars * barAbove READ barAbove )
/// \endcond
public :
explicit QCPBars ( QCPAxis * keyAxis , QCPAxis * valueAxis ) ;
virtual ~ QCPBars ( ) ;
// getters:
double width ( ) const { return mWidth ; }
QCPBars * barBelow ( ) const { return mBarBelow . data ( ) ; }
QCPBars * barAbove ( ) const { return mBarAbove . data ( ) ; }
QCPBarDataMap * data ( ) const { return mData ; }
// setters:
void setWidth ( double width ) ;
void setData ( QCPBarDataMap * data , bool copy = false ) ;
void setData ( const QVector < double > & key , const QVector < double > & value ) ;
// non-property methods:
void moveBelow ( QCPBars * bars ) ;
void moveAbove ( QCPBars * bars ) ;
void addData ( const QCPBarDataMap & dataMap ) ;
void addData ( const QCPBarData & data ) ;
void addData ( double key , double value ) ;
void addData ( const QVector < double > & keys , const QVector < double > & values ) ;
void removeDataBefore ( double key ) ;
void removeDataAfter ( double key ) ;
void removeData ( double fromKey , double toKey ) ;
void removeData ( double key ) ;
// reimplemented virtual methods:
virtual void clearData ( ) ;
virtual double selectTest ( const QPointF & pos , bool onlySelectable , QVariant * details = 0 ) const ;
protected :
// property members:
QCPBarDataMap * mData ;
double mWidth ;
2014-03-22 14:31:20 +00:00
QPointer < QCPBars > mBarBelow , mBarAbove ;
2013-08-27 18:13:20 +00:00
// reimplemented virtual methods:
virtual void draw ( QCPPainter * painter ) ;
virtual void drawLegendIcon ( QCPPainter * painter , const QRectF & rect ) const ;
2014-03-22 14:31:20 +00:00
virtual QCPRange getKeyRange ( bool & foundRange , SignDomain inSignDomain = sdBoth ) const ;
virtual QCPRange getValueRange ( bool & foundRange , SignDomain inSignDomain = sdBoth ) const ;
2013-08-27 18:13:20 +00:00
// non-virtual methods:
QPolygonF getBarPolygon ( double key , double value ) const ;
double getBaseValue ( double key , bool positive ) const ;
static void connectBars ( QCPBars * lower , QCPBars * upper ) ;
friend class QCustomPlot ;
friend class QCPLegend ;
} ;
/*! \file */
class QCP_LIB_DECL QCPStatisticalBox : public QCPAbstractPlottable
{
Q_OBJECT
/// \cond INCLUDE_QPROPERTIES
Q_PROPERTY ( double key READ key WRITE setKey )
Q_PROPERTY ( double minimum READ minimum WRITE setMinimum )
Q_PROPERTY ( double lowerQuartile READ lowerQuartile WRITE setLowerQuartile )
Q_PROPERTY ( double median READ median WRITE setMedian )
Q_PROPERTY ( double upperQuartile READ upperQuartile WRITE setUpperQuartile )
Q_PROPERTY ( double maximum READ maximum WRITE setMaximum )
Q_PROPERTY ( QVector < double > outliers READ outliers WRITE setOutliers )
Q_PROPERTY ( double width READ width WRITE setWidth )
Q_PROPERTY ( double whiskerWidth READ whiskerWidth WRITE setWhiskerWidth )
Q_PROPERTY ( QPen whiskerPen READ whiskerPen WRITE setWhiskerPen )
Q_PROPERTY ( QPen whiskerBarPen READ whiskerBarPen WRITE setWhiskerBarPen )
Q_PROPERTY ( QPen medianPen READ medianPen WRITE setMedianPen )
Q_PROPERTY ( QCPScatterStyle outlierStyle READ outlierStyle WRITE setOutlierStyle )
/// \endcond
public :
explicit QCPStatisticalBox ( QCPAxis * keyAxis , QCPAxis * valueAxis ) ;
// getters:
double key ( ) const { return mKey ; }
double minimum ( ) const { return mMinimum ; }
double lowerQuartile ( ) const { return mLowerQuartile ; }
double median ( ) const { return mMedian ; }
double upperQuartile ( ) const { return mUpperQuartile ; }
double maximum ( ) const { return mMaximum ; }
QVector < double > outliers ( ) const { return mOutliers ; }
double width ( ) const { return mWidth ; }
double whiskerWidth ( ) const { return mWhiskerWidth ; }
QPen whiskerPen ( ) const { return mWhiskerPen ; }
QPen whiskerBarPen ( ) const { return mWhiskerBarPen ; }
QPen medianPen ( ) const { return mMedianPen ; }
QCPScatterStyle outlierStyle ( ) const { return mOutlierStyle ; }
// setters:
void setKey ( double key ) ;
void setMinimum ( double value ) ;
void setLowerQuartile ( double value ) ;
void setMedian ( double value ) ;
void setUpperQuartile ( double value ) ;
void setMaximum ( double value ) ;
void setOutliers ( const QVector < double > & values ) ;
void setData ( double key , double minimum , double lowerQuartile , double median , double upperQuartile , double maximum ) ;
void setWidth ( double width ) ;
void setWhiskerWidth ( double width ) ;
void setWhiskerPen ( const QPen & pen ) ;
void setWhiskerBarPen ( const QPen & pen ) ;
void setMedianPen ( const QPen & pen ) ;
void setOutlierStyle ( const QCPScatterStyle & style ) ;
// non-property methods:
virtual void clearData ( ) ;
virtual double selectTest ( const QPointF & pos , bool onlySelectable , QVariant * details = 0 ) const ;
protected :
// property members:
QVector < double > mOutliers ;
double mKey , mMinimum , mLowerQuartile , mMedian , mUpperQuartile , mMaximum ;
double mWidth ;
double mWhiskerWidth ;
QPen mWhiskerPen , mWhiskerBarPen , mMedianPen ;
QCPScatterStyle mOutlierStyle ;
// reimplemented virtual methods:
virtual void draw ( QCPPainter * painter ) ;
virtual void drawLegendIcon ( QCPPainter * painter , const QRectF & rect ) const ;
2014-03-22 14:31:20 +00:00
virtual QCPRange getKeyRange ( bool & foundRange , SignDomain inSignDomain = sdBoth ) const ;
virtual QCPRange getValueRange ( bool & foundRange , SignDomain inSignDomain = sdBoth ) const ;
2013-08-27 18:13:20 +00:00
// 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 ;
} ;
2014-03-22 14:31:20 +00:00
class QCP_LIB_DECL QCPColorMapData
2013-08-27 18:13:20 +00:00
{
public :
2014-03-22 14:31:20 +00:00
QCPColorMapData ( int keySize , int valueSize , const QCPRange & keyRange , const QCPRange & valueRange ) ;
~ QCPColorMapData ( ) ;
QCPColorMapData ( const QCPColorMapData & other ) ;
QCPColorMapData & operator = ( const QCPColorMapData & other ) ;
2013-08-27 18:13:20 +00:00
// getters:
2014-03-22 14:31:20 +00:00
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 ) ;
2013-08-27 18:13:20 +00:00
2014-03-22 14:31:20 +00:00
// 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 ) ;
2013-08-27 18:13:20 +00:00
2014-03-22 14:31:20 +00:00
// 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 ;
2013-08-27 18:13:20 +00:00
protected :
// property members:
2014-03-22 14:31:20 +00:00
int mKeySize , mValueSize ;
QCPRange mKeyRange , mValueRange ;
bool mIsEmpty ;
// non-property members:
double * mData ;
QCPRange mDataBounds ;
bool mDataModified ;
2013-08-27 18:13:20 +00:00
2014-03-22 14:31:20 +00:00
friend class QCPColorMap ;
2013-08-27 18:13:20 +00:00
} ;
2014-03-22 14:31:20 +00:00
class QCP_LIB_DECL QCPColorMap : public QCPAbstractPlottable
2013-08-27 18:13:20 +00:00
{
Q_OBJECT
/// \cond INCLUDE_QPROPERTIES
2014-03-22 14:31:20 +00:00
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 )
2013-08-27 18:13:20 +00:00
/// \endcond
public :
2014-03-22 14:31:20 +00:00
explicit QCPColorMap ( QCPAxis * keyAxis , QCPAxis * valueAxis ) ;
virtual ~ QCPColorMap ( ) ;
2013-08-27 18:13:20 +00:00
// getters:
2014-03-22 14:31:20 +00:00
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 ( ) ; }
2013-08-27 18:13:20 +00:00
2014-03-22 14:31:20 +00:00
// 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 ) ) ;
2013-08-27 18:13:20 +00:00
// reimplemented virtual methods:
2014-03-22 14:31:20 +00:00
virtual void clearData ( ) ;
2013-08-27 18:13:20 +00:00
virtual double selectTest ( const QPointF & pos , bool onlySelectable , QVariant * details = 0 ) const ;
2014-03-22 14:31:20 +00:00
signals :
void dataRangeChanged ( QCPRange newRange ) ;
void dataScaleTypeChanged ( QCPAxis : : ScaleType scaleType ) ;
void gradientChanged ( QCPColorGradient newGradient ) ;
2013-08-27 18:13:20 +00:00
protected :
// property members:
2014-03-22 14:31:20 +00:00
QCPRange mDataRange ;
QCPAxis : : ScaleType mDataScaleType ;
QCPColorMapData * mMapData ;
QCPColorGradient mGradient ;
bool mInterpolate ;
bool mTightBoundary ;
QPointer < QCPColorScale > mColorScale ;
// non-property members:
QImage mMapImage ;
QPixmap mLegendIcon ;
bool mMapImageInvalidated ;
// introduced virtual methods:
virtual void updateMapImage ( ) ;
2013-08-27 18:13:20 +00:00
// reimplemented virtual methods:
virtual void draw ( QCPPainter * painter ) ;
2014-03-22 14:31:20 +00:00
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 ;
2013-08-27 18:13:20 +00:00
2014-03-22 14:31:20 +00:00
friend class QCustomPlot ;
friend class QCPLegend ;
2013-08-27 18:13:20 +00:00
} ;
2014-03-22 14:31:20 +00:00
class QCP_LIB_DECL QCPItemStraightLine : public QCPAbstractItem
2013-08-27 18:13:20 +00:00
{
Q_OBJECT
/// \cond INCLUDE_QPROPERTIES
Q_PROPERTY ( QPen pen READ pen WRITE setPen )
Q_PROPERTY ( QPen selectedPen READ selectedPen WRITE setSelectedPen )
/// \endcond
public :
2014-03-22 14:31:20 +00:00
QCPItemStraightLine ( QCustomPlot * parentPlot ) ;
virtual ~ QCPItemStraightLine ( ) ;
2013-08-27 18:13:20 +00:00
// 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 ;
2014-03-22 14:31:20 +00:00
QCPItemPosition * const point1 ;
QCPItemPosition * const point2 ;
2013-08-27 18:13:20 +00:00
protected :
// property members:
QPen mPen , mSelectedPen ;
// reimplemented virtual methods:
virtual void draw ( QCPPainter * painter ) ;
// non-virtual methods:
2014-03-22 14:31:20 +00:00
double distToStraightLine ( const QVector2D & point1 , const QVector2D & vec , const QVector2D & point ) const ;
QLineF getRectClippedStraightLine ( const QVector2D & point1 , const QVector2D & vec , const QRect & rect ) const ;
2013-08-27 18:13:20 +00:00
QPen mainPen ( ) const ;
} ;
2014-03-22 14:31:20 +00:00
class QCP_LIB_DECL QCPItemLine : public QCPAbstractItem
2013-08-27 18:13:20 +00:00
{
Q_OBJECT
/// \cond INCLUDE_QPROPERTIES
Q_PROPERTY ( QPen pen READ pen WRITE setPen )
Q_PROPERTY ( QPen selectedPen READ selectedPen WRITE setSelectedPen )
2014-03-22 14:31:20 +00:00
Q_PROPERTY ( QCPLineEnding head READ head WRITE setHead )
Q_PROPERTY ( QCPLineEnding tail READ tail WRITE setTail )
2013-08-27 18:13:20 +00:00
/// \endcond
public :
2014-03-22 14:31:20 +00:00
QCPItemLine ( QCustomPlot * parentPlot ) ;
virtual ~ QCPItemLine ( ) ;
2013-08-27 18:13:20 +00:00
// getters:
QPen pen ( ) const { return mPen ; }
QPen selectedPen ( ) const { return mSelectedPen ; }
2014-03-22 14:31:20 +00:00
QCPLineEnding head ( ) const { return mHead ; }
QCPLineEnding tail ( ) const { return mTail ; }
2013-08-27 18:13:20 +00:00
// setters;
void setPen ( const QPen & pen ) ;
void setSelectedPen ( const QPen & pen ) ;
2014-03-22 14:31:20 +00:00
void setHead ( const QCPLineEnding & head ) ;
void setTail ( const QCPLineEnding & tail ) ;
2013-08-27 18:13:20 +00:00
// reimplemented virtual methods:
virtual double selectTest ( const QPointF & pos , bool onlySelectable , QVariant * details = 0 ) const ;
2014-03-22 14:31:20 +00:00
QCPItemPosition * const start ;
QCPItemPosition * const end ;
2013-08-27 18:13:20 +00:00
protected :
// property members:
QPen mPen , mSelectedPen ;
2014-03-22 14:31:20 +00:00
QCPLineEnding mHead , mTail ;
2013-08-27 18:13:20 +00:00
// reimplemented virtual methods:
virtual void draw ( QCPPainter * painter ) ;
// non-virtual methods:
2014-03-22 14:31:20 +00:00
QLineF getRectClippedLine ( const QVector2D & start , const QVector2D & end , const QRect & rect ) const ;
2013-08-27 18:13:20 +00:00
QPen mainPen ( ) const ;
} ;
2014-03-22 14:31:20 +00:00
class QCP_LIB_DECL QCPItemCurve : public QCPAbstractItem
2013-08-27 18:13:20 +00:00
{
Q_OBJECT
/// \cond INCLUDE_QPROPERTIES
Q_PROPERTY ( QPen pen READ pen WRITE setPen )
Q_PROPERTY ( QPen selectedPen READ selectedPen WRITE setSelectedPen )
2014-03-22 14:31:20 +00:00
Q_PROPERTY ( QCPLineEnding head READ head WRITE setHead )
Q_PROPERTY ( QCPLineEnding tail READ tail WRITE setTail )
2013-08-27 18:13:20 +00:00
/// \endcond
public :
2014-03-22 14:31:20 +00:00
QCPItemCurve ( QCustomPlot * parentPlot ) ;
virtual ~ QCPItemCurve ( ) ;
2013-08-27 18:13:20 +00:00
// getters:
QPen pen ( ) const { return mPen ; }
QPen selectedPen ( ) const { return mSelectedPen ; }
2014-03-22 14:31:20 +00:00
QCPLineEnding head ( ) const { return mHead ; }
QCPLineEnding tail ( ) const { return mTail ; }
2013-08-27 18:13:20 +00:00
// setters;
void setPen ( const QPen & pen ) ;
void setSelectedPen ( const QPen & pen ) ;
2014-03-22 14:31:20 +00:00
void setHead ( const QCPLineEnding & head ) ;
void setTail ( const QCPLineEnding & tail ) ;
2013-08-27 18:13:20 +00:00
// reimplemented virtual methods:
virtual double selectTest ( const QPointF & pos , bool onlySelectable , QVariant * details = 0 ) const ;
2014-03-22 14:31:20 +00:00
QCPItemPosition * const start ;
QCPItemPosition * const startDir ;
QCPItemPosition * const endDir ;
QCPItemPosition * const end ;
2013-08-27 18:13:20 +00:00
protected :
// property members:
QPen mPen , mSelectedPen ;
2014-03-22 14:31:20 +00:00
QCPLineEnding mHead , mTail ;
2013-08-27 18:13:20 +00:00
// reimplemented virtual methods:
virtual void draw ( QCPPainter * painter ) ;
// non-virtual methods:
QPen mainPen ( ) const ;
} ;
2014-03-22 14:31:20 +00:00
class QCP_LIB_DECL QCPItemRect : public QCPAbstractItem
2013-08-27 18:13:20 +00:00
{
Q_OBJECT
/// \cond INCLUDE_QPROPERTIES
Q_PROPERTY ( QPen pen READ pen WRITE setPen )
Q_PROPERTY ( QPen selectedPen READ selectedPen WRITE setSelectedPen )
2014-03-22 14:31:20 +00:00
Q_PROPERTY ( QBrush brush READ brush WRITE setBrush )
Q_PROPERTY ( QBrush selectedBrush READ selectedBrush WRITE setSelectedBrush )
2013-08-27 18:13:20 +00:00
/// \endcond
2014-03-22 14:31:20 +00:00
public :
QCPItemRect ( QCustomPlot * parentPlot ) ;
virtual ~ QCPItemRect ( ) ;
2013-08-27 18:13:20 +00:00
// getters:
QPen pen ( ) const { return mPen ; }
QPen selectedPen ( ) const { return mSelectedPen ; }
2014-03-22 14:31:20 +00:00
QBrush brush ( ) const { return mBrush ; }
QBrush selectedBrush ( ) const { return mSelectedBrush ; }
2013-08-27 18:13:20 +00:00
// setters;
void setPen ( const QPen & pen ) ;
void setSelectedPen ( const QPen & pen ) ;
2014-03-22 14:31:20 +00:00
void setBrush ( const QBrush & brush ) ;
void setSelectedBrush ( const QBrush & brush ) ;
2013-08-27 18:13:20 +00:00
// reimplemented virtual methods:
virtual double selectTest ( const QPointF & pos , bool onlySelectable , QVariant * details = 0 ) const ;
2014-03-22 14:31:20 +00:00
QCPItemPosition * const topLeft ;
QCPItemPosition * const bottomRight ;
QCPItemAnchor * const top ;
QCPItemAnchor * const topRight ;
QCPItemAnchor * const right ;
QCPItemAnchor * const bottom ;
QCPItemAnchor * const bottomLeft ;
QCPItemAnchor * const left ;
2013-08-27 18:13:20 +00:00
protected :
2014-03-22 14:31:20 +00:00
enum AnchorIndex { aiTop , aiTopRight , aiRight , aiBottom , aiBottomLeft , aiLeft } ;
2013-08-27 18:13:20 +00:00
// property members:
QPen mPen , mSelectedPen ;
2014-03-22 14:31:20 +00:00
QBrush mBrush , mSelectedBrush ;
2013-08-27 18:13:20 +00:00
// reimplemented virtual methods:
virtual void draw ( QCPPainter * painter ) ;
virtual QPointF anchorPixelPoint ( int anchorId ) const ;
// non-virtual methods:
QPen mainPen ( ) const ;
2014-03-22 14:31:20 +00:00
QBrush mainBrush ( ) const ;
2013-08-27 18:13:20 +00:00
} ;
2014-03-22 14:31:20 +00:00
class QCP_LIB_DECL QCPItemText : public QCPAbstractItem
2013-08-27 18:13:20 +00:00
{
Q_OBJECT
/// \cond INCLUDE_QPROPERTIES
2014-03-22 14:31:20 +00:00
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 )
2013-08-27 18:13:20 +00:00
/// \endcond
public :
2014-03-22 14:31:20 +00:00
QCPItemText ( QCustomPlot * parentPlot ) ;
virtual ~ QCPItemText ( ) ;
2013-08-27 18:13:20 +00:00
// getters:
2014-03-22 14:31:20 +00:00
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 ; }
2013-08-27 18:13:20 +00:00
2014-03-22 14:31:20 +00:00
// 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 ) ;
2013-08-27 18:13:20 +00:00
// reimplemented virtual methods:
2014-03-22 14:31:20 +00:00
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 ;
2013-08-27 18:13:20 +00:00
protected :
2014-03-22 14:31:20 +00:00
enum AnchorIndex { aiTopLeft , aiTop , aiTopRight , aiRight , aiBottomRight , aiBottom , aiBottomLeft , aiLeft } ;
2013-08-27 18:13:20 +00:00
// property members:
2014-03-22 14:31:20 +00:00
QColor mColor , mSelectedColor ;
QPen mPen , mSelectedPen ;
QBrush mBrush , mSelectedBrush ;
QFont mFont , mSelectedFont ;
QString mText ;
Qt : : Alignment mPositionAlignment ;
Qt : : Alignment mTextAlignment ;
double mRotation ;
QMargins mPadding ;
2013-08-27 18:13:20 +00:00
// reimplemented virtual methods:
virtual void draw ( QCPPainter * painter ) ;
2014-03-22 14:31:20 +00:00
virtual QPointF anchorPixelPoint ( int anchorId ) const ;
2013-08-27 18:13:20 +00:00
2014-03-22 14:31:20 +00:00
// 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 ;
2013-08-27 18:13:20 +00:00
} ;
2014-03-22 14:31:20 +00:00
class QCP_LIB_DECL QCPItemEllipse : public QCPAbstractItem
2013-08-27 18:13:20 +00:00
{
Q_OBJECT
/// \cond INCLUDE_QPROPERTIES
2014-03-22 14:31:20 +00:00
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 )
2013-08-27 18:13:20 +00:00
/// \endcond
public :
2014-03-22 14:31:20 +00:00
QCPItemEllipse ( QCustomPlot * parentPlot ) ;
virtual ~ QCPItemEllipse ( ) ;
2013-08-27 18:13:20 +00:00
// getters:
2014-03-22 14:31:20 +00:00
QPen pen ( ) const { return mPen ; }
QPen selectedPen ( ) const { return mSelectedPen ; }
QBrush brush ( ) const { return mBrush ; }
QBrush selectedBrush ( ) const { return mSelectedBrush ; }
2013-08-27 18:13:20 +00:00
2014-03-22 14:31:20 +00:00
// setters;
void setPen ( const QPen & pen ) ;
void setSelectedPen ( const QPen & pen ) ;
void setBrush ( const QBrush & brush ) ;
void setSelectedBrush ( const QBrush & brush ) ;
2013-08-27 18:13:20 +00:00
// reimplemented virtual methods:
virtual double selectTest ( const QPointF & pos , bool onlySelectable , QVariant * details = 0 ) const ;
2014-03-22 14:31:20 +00:00
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 ;
2013-08-27 18:13:20 +00:00
protected :
2014-03-22 14:31:20 +00:00
enum AnchorIndex { aiTopLeftRim , aiTop , aiTopRightRim , aiRight , aiBottomRightRim , aiBottom , aiBottomLeftRim , aiLeft , aiCenter } ;
2013-08-27 18:13:20 +00:00
// property members:
2014-03-22 14:31:20 +00:00
QPen mPen , mSelectedPen ;
QBrush mBrush , mSelectedBrush ;
2013-08-27 18:13:20 +00:00
// reimplemented virtual methods:
2014-03-22 14:31:20 +00:00
virtual void draw ( QCPPainter * painter ) ;
virtual QPointF anchorPixelPoint ( int anchorId ) const ;
2013-08-27 18:13:20 +00:00
2014-03-22 14:31:20 +00:00
// non-virtual methods:
QPen mainPen ( ) const ;
QBrush mainBrush ( ) const ;
2013-08-27 18:13:20 +00:00
} ;
2014-03-22 14:31:20 +00:00
class QCP_LIB_DECL QCPItemPixmap : public QCPAbstractItem
2013-08-27 18:13:20 +00:00
{
Q_OBJECT
2014-03-22 14:31:20 +00:00
/// \cond INCLUDE_QPROPERTIES
Q_PROPERTY ( QPixmap pixmap READ pixmap WRITE setPixmap )
Q_PROPERTY ( bool scaled READ scaled WRITE setScaled )
Q_PROPERTY ( Qt : : AspectRatioMode aspectRatioMode READ aspectRatioMode )
Q_PROPERTY ( QPen pen READ pen WRITE setPen )
Q_PROPERTY ( QPen selectedPen READ selectedPen WRITE setSelectedPen )
/// \endcond
2013-08-27 18:13:20 +00:00
public :
2014-03-22 14:31:20 +00:00
QCPItemPixmap ( QCustomPlot * parentPlot ) ;
virtual ~ QCPItemPixmap ( ) ;
2013-08-27 18:13:20 +00:00
// getters:
2014-03-22 14:31:20 +00:00
QPixmap pixmap ( ) const { return mPixmap ; }
bool scaled ( ) const { return mScaled ; }
Qt : : AspectRatioMode aspectRatioMode ( ) const { return mAspectRatioMode ; }
QPen pen ( ) const { return mPen ; }
QPen selectedPen ( ) const { return mSelectedPen ; }
// setters;
void setPixmap ( const QPixmap & pixmap ) ;
void setScaled ( bool scaled , Qt : : AspectRatioMode aspectRatioMode = Qt : : KeepAspectRatio ) ;
void setPen ( const QPen & pen ) ;
void setSelectedPen ( const QPen & pen ) ;
// reimplemented virtual methods:
virtual double selectTest ( const QPointF & pos , bool onlySelectable , QVariant * details = 0 ) const ;
QCPItemPosition * const topLeft ;
QCPItemPosition * const bottomRight ;
QCPItemAnchor * const top ;
QCPItemAnchor * const topRight ;
QCPItemAnchor * const right ;
QCPItemAnchor * const bottom ;
QCPItemAnchor * const bottomLeft ;
QCPItemAnchor * const left ;
2013-08-27 18:13:20 +00:00
protected :
2014-03-22 14:31:20 +00:00
enum AnchorIndex { aiTop , aiTopRight , aiRight , aiBottom , aiBottomLeft , aiLeft } ;
2013-08-27 18:13:20 +00:00
// property members:
2014-03-22 14:31:20 +00:00
QPixmap mPixmap ;
QPixmap mScaledPixmap ;
bool mScaled ;
Qt : : AspectRatioMode mAspectRatioMode ;
QPen mPen , mSelectedPen ;
2013-08-27 18:13:20 +00:00
// reimplemented virtual methods:
virtual void draw ( QCPPainter * painter ) ;
2014-03-22 14:31:20 +00:00
virtual QPointF anchorPixelPoint ( int anchorId ) const ;
2013-08-27 18:13:20 +00:00
// non-virtual methods:
2014-03-22 14:31:20 +00:00
void updateScaledPixmap ( QRect finalRect = QRect ( ) , bool flipHorz = false , bool flipVert = false ) ;
QRect getFinalRect ( bool * flippedHorz = 0 , bool * flippedVert = 0 ) const ;
QPen mainPen ( ) const ;
2013-08-27 18:13:20 +00:00
} ;
2014-03-22 14:31:20 +00:00
class QCP_LIB_DECL QCPItemTracer : public QCPAbstractItem
2013-08-27 18:13:20 +00:00
{
Q_OBJECT
/// \cond INCLUDE_QPROPERTIES
2014-03-22 14:31:20 +00:00
Q_PROPERTY ( QPen pen READ pen WRITE setPen )
Q_PROPERTY ( QPen selectedPen READ selectedPen WRITE setSelectedPen )
2013-08-27 18:13:20 +00:00
Q_PROPERTY ( QBrush brush READ brush WRITE setBrush )
Q_PROPERTY ( QBrush selectedBrush READ selectedBrush WRITE setSelectedBrush )
2014-03-22 14:31:20 +00:00
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 )
2013-08-27 18:13:20 +00:00
/// \endcond
public :
/*!
2014-03-22 14:31:20 +00:00
The different visual appearances a tracer item can have . Some styles size may be controlled with \ ref setSize .
2013-08-27 18:13:20 +00:00
2014-03-22 14:31:20 +00:00
\ see setStyle
2013-08-27 18:13:20 +00:00
*/
2014-03-22 14:31:20 +00:00
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 )
2013-08-27 18:13:20 +00:00
2014-03-22 14:31:20 +00:00
QCPItemTracer ( QCustomPlot * parentPlot ) ;
virtual ~ QCPItemTracer ( ) ;
2013-08-27 18:13:20 +00:00
// getters:
2014-03-22 14:31:20 +00:00
QPen pen ( ) const { return mPen ; }
QPen selectedPen ( ) const { return mSelectedPen ; }
2013-08-27 18:13:20 +00:00
QBrush brush ( ) const { return mBrush ; }
QBrush selectedBrush ( ) const { return mSelectedBrush ; }
2014-03-22 14:31:20 +00:00
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 ; }
2013-08-27 18:13:20 +00:00
2014-03-22 14:31:20 +00:00
// setters;
void setPen ( const QPen & pen ) ;
void setSelectedPen ( const QPen & pen ) ;
2013-08-27 18:13:20 +00:00
void setBrush ( const QBrush & brush ) ;
void setSelectedBrush ( const QBrush & brush ) ;
2014-03-22 14:31:20 +00:00
void setSize ( double size ) ;
void setStyle ( TracerStyle style ) ;
void setGraph ( QCPGraph * graph ) ;
void setGraphKey ( double key ) ;
void setInterpolating ( bool enabled ) ;
2013-08-27 18:13:20 +00:00
// reimplemented virtual methods:
virtual double selectTest ( const QPointF & pos , bool onlySelectable , QVariant * details = 0 ) const ;
// non-virtual methods:
2014-03-22 14:31:20 +00:00
void updatePosition ( ) ;
2013-08-27 18:13:20 +00:00
2014-03-22 14:31:20 +00:00
QCPItemPosition * const position ;
2013-08-27 18:13:20 +00:00
protected :
// property members:
2014-03-22 14:31:20 +00:00
QPen mPen , mSelectedPen ;
QBrush mBrush , mSelectedBrush ;
double mSize ;
TracerStyle mStyle ;
QCPGraph * mGraph ;
double mGraphKey ;
bool mInterpolating ;
2013-08-27 18:13:20 +00:00
// reimplemented virtual methods:
virtual void draw ( QCPPainter * painter ) ;
// non-virtual methods:
2014-03-22 14:31:20 +00:00
QPen mainPen ( ) const ;
QBrush mainBrush ( ) const ;
2013-08-27 18:13:20 +00:00
} ;
2014-03-22 14:31:20 +00:00
class QCP_LIB_DECL QCPItemBracket : public QCPAbstractItem
2013-08-27 18:13:20 +00:00
{
Q_OBJECT
/// \cond INCLUDE_QPROPERTIES
2014-03-22 14:31:20 +00:00
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 )
2013-08-27 18:13:20 +00:00
/// \endcond
public :
2014-03-22 14:31:20 +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 ( ) ;
2013-08-27 18:13:20 +00:00
// getters:
2014-03-22 14:31:20 +00:00
QPen pen ( ) const { return mPen ; }
QPen selectedPen ( ) const { return mSelectedPen ; }
double length ( ) const { return mLength ; }
BracketStyle style ( ) const { return mStyle ; }
2013-08-27 18:13:20 +00:00
2014-03-22 14:31:20 +00:00
// setters;
void setPen ( const QPen & pen ) ;
void setSelectedPen ( const QPen & pen ) ;
void setLength ( double length ) ;
void setStyle ( BracketStyle style ) ;
2013-08-27 18:13:20 +00:00
// reimplemented virtual methods:
virtual double selectTest ( const QPointF & pos , bool onlySelectable , QVariant * details = 0 ) const ;
2014-03-22 14:31:20 +00:00
QCPItemPosition * const left ;
QCPItemPosition * const right ;
QCPItemAnchor * const center ;
2013-08-27 18:13:20 +00:00
protected :
// property members:
2014-03-22 14:31:20 +00:00
enum AnchorIndex { aiCenter } ;
QPen mPen , mSelectedPen ;
double mLength ;
BracketStyle mStyle ;
2013-08-27 18:13:20 +00:00
// reimplemented virtual methods:
virtual void draw ( QCPPainter * painter ) ;
2014-03-22 14:31:20 +00:00
virtual QPointF anchorPixelPoint ( int anchorId ) const ;
2013-08-27 18:13:20 +00:00
// non-virtual methods:
2014-03-22 14:31:20 +00:00
QPen mainPen ( ) const ;
2013-08-27 18:13:20 +00:00
} ;
# endif // QCUSTOMPLOT_H