qcustomplot.h

Go to the documentation of this file.

/***************************************************************************
**                                                                        **
**  QCustomPlot, an easy to use, modern plotting widget for Qt            **
**  Copyright (C) 2011-2015 Emanuel Eichhammer                            **
**                                                                        **
**  This program is free software: you can redistribute it and/or modify  **
**  it under the terms of the GNU General Public License as published by  **
**  the Free Software Foundation, either version 3 of the License, or     **
**  (at your option) any later version.                                   **
**                                                                        **
**  This program is distributed in the hope that it will be useful,       **
**  but WITHOUT ANY WARRANTY; without even the implied warranty of        **
**  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         **
**  GNU General Public License for more details.                          **
**                                                                        **
**  You should have received a copy of the GNU General Public License     **
**  along with this program.  If not, see http://www.gnu.org/licenses/.   **
**                                                                        **
****************************************************************************
**           Author: Emanuel Eichhammer                                   **
**  Website/Contact: http://www.qcustomplot.com/                          **
**             Date: 22.12.15                                             **
**          Version: 1.3.2                                                **
****************************************************************************/
 
#ifndef QCUSTOMPLOT_H
#define QCUSTOMPLOT_H
 
#include <qmath.h>
 
#include <QCache>
#include <QDateTime>
#include <QDebug>
#include <QFlags>
#include <QMargins>
#include <QMouseEvent>
#include <QMultiMap>
#include <QObject>
#include <QPaintEvent>
#include <QPainter>
#include <QPixmap>
#include <QPointer>
#include <QStack>
#include <QString>
#include <QVector2D>
#include <QVector>
#include <QWidget>
#include <limits>
#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
#include <qnumeric.h>
 
#include <QPrintEngine>
#include <QPrinter>
#else
#include <QtNumeric>
#include <QtPrintSupport/QtPrintSupport>
#endif
 
class QCPPainter;
class QCustomPlot;
class QCPLayerable;
class QCPLayoutElement;
class QCPLayout;
class QCPAxis;
class QCPAxisRect;
class QCPAxisPainterPrivate;
class QCPAbstractPlottable;
class QCPGraph;
class QCPAbstractItem;
class QCPItemPosition;
class QCPLayer;
class QCPPlotTitle;
class QCPLegend;
class QCPAbstractLegendItem;
class QCPColorMap;
class QCPColorScale;
class QCPBars;
 
// 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
 
namespace QCP {
enum MarginSide {
  msLeft = 0x01  
  ,
  msRight = 0x02  
  ,
  msTop = 0x04  
  ,
  msBottom = 0x08  
  ,
  msAll = 0xFF  
  ,
  msNone = 0x00  
};
Q_DECLARE_FLAGS(MarginSides, MarginSide)
 
 
enum AntialiasedElement {
  aeAxes = 0x0001  
  ,
  aeGrid = 0x0002  
  ,
  aeSubGrid = 0x0004  
  ,
  aeLegend = 0x0008  
  ,
  aeLegendItems = 0x0010  
  ,
  aePlottables =
      0x0020  
  ,
  aeItems = 0x0040  
  ,
  aeScatters = 0x0080  
  ,
  aeErrorBars = 0x0100  
  ,
  aeFills = 0x0200  
  ,
  aeZeroLine =
      0x0400  
  ,
  aeAll = 0xFFFF  
  ,
  aeNone = 0x0000  
};
Q_DECLARE_FLAGS(AntialiasedElements, AntialiasedElement)
 
 
enum PlottingHint {
  phNone = 0x000  
  ,
  phFastPolylines =
      0x001  
  ,
  phForceRepaint =
      0x002  
  ,
  phCacheLabels = 0x004  
};
Q_DECLARE_FLAGS(PlottingHints, PlottingHint)
 
 
enum Interaction {
  iRangeDrag =
      0x001  
  ,
  iRangeZoom = 0x002  
  ,
  iMultiSelect = 0x004  
  ,
  iSelectPlottables =
      0x008  
  ,
  iSelectAxes = 0x010  
  ,
  iSelectLegend = 0x020  
  ,
  iSelectItems = 0x040  
  ,
  iSelectOther =
      0x080  
};
Q_DECLARE_FLAGS(Interactions, Interaction)
 
 
inline bool isInvalidData(double value) {
  return qIsNaN(value) || qIsInf(value);
}
 
inline bool isInvalidData(double value1, double value2) {
  return isInvalidData(value1) || isInvalidData(value2);
}
 
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;
  }
}
 
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:
  Q_ENUMS(ScatterShape)
  enum ScatterShape {
    ssNone  
    ,
    ssDot  
    ,
    ssCross  
    ,
    ssPlus  
    ,
    ssCircle  
    ,
    ssDisc  
    ,
    ssSquare  
    ,
    ssDiamond  
    ,
    ssStar  
    ,
    ssTriangle  
    ,
    ssTriangleInverted  
    ,
    ssCrossSquare  
    ,
    ssPlusSquare  
    ,
    ssCrossCircle  
    ,
    ssPlusCircle  
    ,
    ssPeace  
    ,
    ssPixmap  
    ,
    ssCustom  
  };
 
  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:
  enum PainterMode {
    pmDefault =
        0x00  
    ,
    pmVectorized =
        0x01  
    ,
    pmNoCaching = 0x02  
    ,
    pmNonCosmetic =
        0x04  
  };
  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
  Q_PROPERTY(QCustomPlot *parentPlot READ parentPlot)
  Q_PROPERTY(QString name READ name)
  Q_PROPERTY(int index READ index)
  Q_PROPERTY(QList<QCPLayerable *> children READ children)
  Q_PROPERTY(bool visible READ visible WRITE setVisible)
 public:
  QCPLayer(QCustomPlot *parentPlot, const QString &layerName);
  ~QCPLayer();
 
  // getters:
  QCustomPlot *parentPlot() const { return mParentPlot; }
  QString name() const { return mName; }
  int index() const { return mIndex; }
  QList<QCPLayerable *> children() const { return mChildren; }
  bool visible() const { return mVisible; }
 
  // setters:
  void setVisible(bool visible);
 
 protected:
  // property members:
  QCustomPlot *mParentPlot;
  QString mName;
  int mIndex;
  QList<QCPLayerable *> mChildren;
  bool mVisible;
 
  // non-virtual methods:
  void addChild(QCPLayerable *layerable, bool prepend);
  void removeChild(QCPLayerable *layerable);
 
 private:
  Q_DISABLE_COPY(QCPLayer)
 
  friend class QCustomPlot;
  friend class QCPLayerable;
};
 
class QCP_LIB_DECL QCPLayerable : public QObject {
  Q_OBJECT
  Q_PROPERTY(bool visible READ visible WRITE setVisible)
  Q_PROPERTY(QCustomPlot *parentPlot READ parentPlot)
  Q_PROPERTY(QCPLayerable *parentLayerable READ parentLayerable)
  Q_PROPERTY(QCPLayer *layer READ layer WRITE setLayer NOTIFY layerChanged)
  Q_PROPERTY(bool antialiased READ antialiased WRITE setAntialiased)
 public:
  QCPLayerable(QCustomPlot *plot, QString targetLayer = QString(),
               QCPLayerable *parentLayerable = 0);
  ~QCPLayerable();
 
  // getters:
  bool visible() const { return mVisible; }
  QCustomPlot *parentPlot() const { return mParentPlot; }
  QCPLayerable *parentLayerable() const { return mParentLayerable.data(); }
  QCPLayer *layer() const { return mLayer; }
  bool antialiased() const { return mAntialiased; }
 
  // setters:
  void setVisible(bool on);
  Q_SLOT bool setLayer(QCPLayer *layer);
  bool setLayer(const QString &layerName);
  void setAntialiased(bool enabled);
 
  // introduced virtual methods:
  virtual double selectTest(const QPointF &pos, bool onlySelectable,
                            QVariant *details = 0) const;
 
  // non-property methods:
  bool realVisibility() const;
 
 signals:
  void layerChanged(QCPLayer *newLayer);
 
 protected:
  // property members:
  bool mVisible;
  QCustomPlot *mParentPlot;
  QPointer<QCPLayerable> mParentLayerable;
  QCPLayer *mLayer;
  bool mAntialiased;
 
  // introduced virtual methods:
  virtual void parentPlotInitialized(QCustomPlot *parentPlot);
  virtual QCP::Interaction selectionCategory() const;
  virtual QRect clipRect() const;
  virtual void applyDefaultAntialiasingHint(QCPPainter *painter) const = 0;
  virtual void draw(QCPPainter *painter) = 0;
  // events:
  virtual void selectEvent(QMouseEvent *event, bool additive,
                           const QVariant &details,
                           bool *selectionStateChanged);
  virtual void deselectEvent(bool *selectionStateChanged);
 
  // non-property methods:
  void initializeParentPlot(QCustomPlot *parentPlot);
  void setParentLayerable(QCPLayerable *parentLayerable);
  bool moveToLayer(QCPLayer *layer, bool prepend);
  void applyAntialiasingHint(QCPPainter *painter, bool localAntialiased,
                             QCP::AntialiasedElement overrideElement) const;
 
 private:
  Q_DISABLE_COPY(QCPLayerable)
 
  friend class QCustomPlot;
  friend class QCPAxisRect;
};
 
class QCP_LIB_DECL QCPRange {
 public:
  double lower, upper;
 
  QCPRange();
  QCPRange(double lower, double upper);
 
  bool operator==(const QCPRange &other) const {
    return lower == other.lower && upper == other.upper;
  }
  bool operator!=(const QCPRange &other) const { return !(*this == other); }
 
  QCPRange &operator+=(const double &value) {
    lower += value;
    upper += value;
    return *this;
  }
  QCPRange &operator-=(const double &value) {
    lower -= value;
    upper -= value;
    return *this;
  }
  QCPRange &operator*=(const double &value) {
    lower *= value;
    upper *= value;
    return *this;
  }
  QCPRange &operator/=(const double &value) {
    lower /= value;
    upper /= value;
    return *this;
  }
  friend inline const QCPRange operator+(const QCPRange &, double);
  friend inline const QCPRange operator+(double, const QCPRange &);
  friend inline const QCPRange operator-(const QCPRange &range, double value);
  friend inline const QCPRange operator*(const QCPRange &range, double value);
  friend inline const QCPRange operator*(double value, const QCPRange &range);
  friend inline const QCPRange operator/(const QCPRange &range, double value);
 
  double size() const;
  double center() const;
  void normalize();
  void expand(const QCPRange &otherRange);
  QCPRange expanded(const QCPRange &otherRange) const;
  QCPRange sanitizedForLogScale() const;
  QCPRange sanitizedForLinScale() const;
  bool contains(double value) const;
 
  static bool validRange(double lower, double upper);
  static bool validRange(const QCPRange &range);
  static const double minRange;  // 1e-280;
  static const double maxRange;  // 1e280;
};
Q_DECLARE_TYPEINFO(QCPRange, Q_MOVABLE_TYPE);
 
/* documentation of inline functions */
 
/* end documentation of inline functions */
 
inline const QCPRange operator+(const QCPRange &range, double value) {
  QCPRange result(range);
  result += value;
  return result;
}
 
inline const QCPRange operator+(double value, const QCPRange &range) {
  QCPRange result(range);
  result += value;
  return result;
}
 
inline const QCPRange operator-(const QCPRange &range, double value) {
  QCPRange result(range);
  result -= value;
  return result;
}
 
inline const QCPRange operator*(const QCPRange &range, double value) {
  QCPRange result(range);
  result *= value;
  return result;
}
 
inline const QCPRange operator*(double value, const QCPRange &range) {
  QCPRange result(range);
  result *= value;
  return result;
}
 
inline const QCPRange operator/(const QCPRange &range, double value) {
  QCPRange result(range);
  result /= value;
  return result;
}
 
class QCP_LIB_DECL QCPMarginGroup : public QObject {
  Q_OBJECT
 public:
  QCPMarginGroup(QCustomPlot *parentPlot);
  ~QCPMarginGroup();
 
  // non-virtual methods:
  QList<QCPLayoutElement *> elements(QCP::MarginSide side) const {
    return mChildren.value(side);
  }
  bool isEmpty() const;
  void clear();
 
 protected:
  // non-property members:
  QCustomPlot *mParentPlot;
  QHash<QCP::MarginSide, QList<QCPLayoutElement *> > mChildren;
 
  // non-virtual methods:
  int commonMargin(QCP::MarginSide side) const;
  void addChild(QCP::MarginSide side, QCPLayoutElement *element);
  void removeChild(QCP::MarginSide side, QCPLayoutElement *element);
 
 private:
  Q_DISABLE_COPY(QCPMarginGroup)
 
  friend class QCPLayoutElement;
};
 
class QCP_LIB_DECL QCPLayoutElement : public QCPLayerable {
  Q_OBJECT
  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)
 public:
  enum UpdatePhase {
    upPreparation  
    ,
    upMargins  
    ,
    upLayout  
  };
  Q_ENUMS(UpdatePhase)
 
  explicit QCPLayoutElement(QCustomPlot *parentPlot = 0);
  virtual ~QCPLayoutElement();
 
  // getters:
  QCPLayout *layout() const { return mParentLayout; }
  QRect rect() const { return mRect; }
  QRect outerRect() const { return mOuterRect; }
  QMargins margins() const { return mMargins; }
  QMargins minimumMargins() const { return mMinimumMargins; }
  QCP::MarginSides autoMargins() const { return mAutoMargins; }
  QSize minimumSize() const { return mMinimumSize; }
  QSize maximumSize() const { return mMaximumSize; }
  QCPMarginGroup *marginGroup(QCP::MarginSide side) const {
    return mMarginGroups.value(side, (QCPMarginGroup *)0);
  }
  QHash<QCP::MarginSide, QCPMarginGroup *> marginGroups() const {
    return mMarginGroups;
  }
 
  // setters:
  void setOuterRect(const QRect &rect);
  void setMargins(const QMargins &margins);
  void setMinimumMargins(const QMargins &margins);
  void setAutoMargins(QCP::MarginSides sides);
  void setMinimumSize(const QSize &size);
  void setMinimumSize(int width, int height);
  void setMaximumSize(const QSize &size);
  void setMaximumSize(int width, int height);
  void setMarginGroup(QCP::MarginSides sides, QCPMarginGroup *group);
 
  // introduced virtual methods:
  virtual void update(UpdatePhase phase);
  virtual QSize minimumSizeHint() const;
  virtual QSize maximumSizeHint() const;
  virtual QList<QCPLayoutElement *> elements(bool recursive) const;
 
  // reimplemented virtual methods:
  virtual double selectTest(const QPointF &pos, bool onlySelectable,
                            QVariant *details = 0) const;
 
 protected:
  // property members:
  QCPLayout *mParentLayout;
  QSize mMinimumSize, mMaximumSize;
  QRect mRect, mOuterRect;
  QMargins mMargins, mMinimumMargins;
  QCP::MarginSides mAutoMargins;
  QHash<QCP::MarginSide, QCPMarginGroup *> mMarginGroups;
 
  // introduced virtual methods:
  virtual int calculateAutoMargin(QCP::MarginSide side);
  // events:
  virtual void mousePressEvent(QMouseEvent *event) { Q_UNUSED(event) }
  virtual void mouseMoveEvent(QMouseEvent *event) { Q_UNUSED(event) }
  virtual void mouseReleaseEvent(QMouseEvent *event) { Q_UNUSED(event) }
  virtual void mouseDoubleClickEvent(QMouseEvent *event) { Q_UNUSED(event) }
  virtual void wheelEvent(QWheelEvent *event) { Q_UNUSED(event) }
 
  // reimplemented virtual methods:
  virtual void applyDefaultAntialiasingHint(QCPPainter *painter) const {
    Q_UNUSED(painter)
  }
  virtual void draw(QCPPainter *painter) { Q_UNUSED(painter) }
  virtual void parentPlotInitialized(QCustomPlot *parentPlot);
 
 private:
  Q_DISABLE_COPY(QCPLayoutElement)
 
  friend class QCustomPlot;
  friend class QCPLayout;
  friend class QCPMarginGroup;
};
 
class QCP_LIB_DECL QCPLayout : public QCPLayoutElement {
  Q_OBJECT
 public:
  explicit QCPLayout();
 
  // reimplemented virtual methods:
  virtual void update(UpdatePhase phase);
  virtual QList<QCPLayoutElement *> elements(bool recursive) const;
 
  // introduced virtual methods:
  virtual int elementCount() const = 0;
  virtual QCPLayoutElement *elementAt(int index) const = 0;
  virtual QCPLayoutElement *takeAt(int index) = 0;
  virtual bool take(QCPLayoutElement *element) = 0;
  virtual void simplify();
 
  // non-virtual methods:
  bool removeAt(int index);
  bool remove(QCPLayoutElement *element);
  void clear();
 
 protected:
  // introduced virtual methods:
  virtual void updateLayout();
 
  // non-virtual methods:
  void sizeConstraintsChanged() const;
  void adoptElement(QCPLayoutElement *el);
  void releaseElement(QCPLayoutElement *el);
  QVector<int> getSectionSizes(QVector<int> maxSizes, QVector<int> minSizes,
                               QVector<double> stretchFactors,
                               int totalSize) const;
 
 private:
  Q_DISABLE_COPY(QCPLayout)
  friend class QCPLayoutElement;
};
 
class QCP_LIB_DECL QCPLayoutGrid : public QCPLayout {
  Q_OBJECT
  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)
 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:
  enum InsetPlacement {
    ipFree  
    ,
    ipBorderAligned  
  };
 
  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:
  Q_ENUMS(EndingStyle)
  enum EndingStyle {
    esNone  
    ,
    esFlatArrow  
    ,
    esSpikeArrow  
    ,
    esLineArrow  
    ,
    esDisc  
    ,
    esSquare  
    ,
    esDiamond  
    ,
    esBar  
    ,
    esHalfBar  
    ,
    esSkewedBar  
  };
 
  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
  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)
 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
  Q_PROPERTY(AxisType axisType READ axisType)
  Q_PROPERTY(QCPAxisRect *axisRect READ axisRect)
  Q_PROPERTY(ScaleType scaleType READ scaleType WRITE setScaleType NOTIFY
                 scaleTypeChanged)
  Q_PROPERTY(double scaleLogBase READ scaleLogBase WRITE setScaleLogBase)
  Q_PROPERTY(QCPRange range READ range WRITE setRange NOTIFY rangeChanged)
  Q_PROPERTY(bool rangeReversed READ rangeReversed WRITE setRangeReversed)
  Q_PROPERTY(bool autoTicks READ autoTicks WRITE setAutoTicks)
  Q_PROPERTY(int autoTickCount READ autoTickCount WRITE setAutoTickCount)
  Q_PROPERTY(bool autoTickLabels READ autoTickLabels WRITE setAutoTickLabels)
  Q_PROPERTY(bool autoTickStep READ autoTickStep WRITE setAutoTickStep)
  Q_PROPERTY(bool autoSubTicks READ autoSubTicks WRITE setAutoSubTicks)
  Q_PROPERTY(bool ticks READ ticks WRITE setTicks)
  Q_PROPERTY(bool tickLabels READ tickLabels WRITE setTickLabels)
  Q_PROPERTY(
      int tickLabelPadding READ tickLabelPadding WRITE setTickLabelPadding)
  Q_PROPERTY(LabelType tickLabelType READ tickLabelType WRITE setTickLabelType)
  Q_PROPERTY(QFont tickLabelFont READ tickLabelFont WRITE setTickLabelFont)
  Q_PROPERTY(QColor tickLabelColor READ tickLabelColor WRITE setTickLabelColor)
  Q_PROPERTY(double tickLabelRotation READ tickLabelRotation WRITE
                 setTickLabelRotation)
  Q_PROPERTY(LabelSide tickLabelSide READ tickLabelSide WRITE setTickLabelSide)
  Q_PROPERTY(QString dateTimeFormat READ dateTimeFormat WRITE setDateTimeFormat)
  Q_PROPERTY(Qt::TimeSpec dateTimeSpec READ dateTimeSpec WRITE setDateTimeSpec)
  Q_PROPERTY(QString numberFormat READ numberFormat WRITE setNumberFormat)
  Q_PROPERTY(int numberPrecision READ numberPrecision WRITE setNumberPrecision)
  Q_PROPERTY(double tickStep READ tickStep WRITE setTickStep)
  Q_PROPERTY(QVector<double> tickVector READ tickVector WRITE setTickVector)
  Q_PROPERTY(QVector<QString> tickVectorLabels READ tickVectorLabels WRITE
                 setTickVectorLabels)
  Q_PROPERTY(int tickLengthIn READ tickLengthIn WRITE setTickLengthIn)
  Q_PROPERTY(int tickLengthOut READ tickLengthOut WRITE setTickLengthOut)
  Q_PROPERTY(int subTickCount READ subTickCount WRITE setSubTickCount)
  Q_PROPERTY(int subTickLengthIn READ subTickLengthIn WRITE setSubTickLengthIn)
  Q_PROPERTY(
      int subTickLengthOut READ subTickLengthOut WRITE setSubTickLengthOut)
  Q_PROPERTY(QPen basePen READ basePen WRITE setBasePen)
  Q_PROPERTY(QPen tickPen READ tickPen WRITE setTickPen)
  Q_PROPERTY(QPen subTickPen READ subTickPen WRITE setSubTickPen)
  Q_PROPERTY(QFont labelFont READ labelFont WRITE setLabelFont)
  Q_PROPERTY(QColor labelColor READ labelColor WRITE setLabelColor)
  Q_PROPERTY(QString label READ label WRITE setLabel)
  Q_PROPERTY(int labelPadding READ labelPadding WRITE setLabelPadding)
  Q_PROPERTY(int padding READ padding WRITE setPadding)
  Q_PROPERTY(int offset READ offset WRITE setOffset)
  Q_PROPERTY(SelectableParts selectedParts READ selectedParts WRITE
                 setSelectedParts NOTIFY selectionChanged)
  Q_PROPERTY(SelectableParts selectableParts READ selectableParts WRITE
                 setSelectableParts NOTIFY selectableChanged)
  Q_PROPERTY(QFont selectedTickLabelFont READ selectedTickLabelFont WRITE
                 setSelectedTickLabelFont)
  Q_PROPERTY(
      QFont selectedLabelFont READ selectedLabelFont WRITE setSelectedLabelFont)
  Q_PROPERTY(QColor selectedTickLabelColor READ selectedTickLabelColor WRITE
                 setSelectedTickLabelColor)
  Q_PROPERTY(QColor selectedLabelColor READ selectedLabelColor WRITE
                 setSelectedLabelColor)
  Q_PROPERTY(QPen selectedBasePen READ selectedBasePen WRITE setSelectedBasePen)
  Q_PROPERTY(QPen selectedTickPen READ selectedTickPen WRITE setSelectedTickPen)
  Q_PROPERTY(QPen selectedSubTickPen READ selectedSubTickPen WRITE
                 setSelectedSubTickPen)
  Q_PROPERTY(QCPLineEnding lowerEnding READ lowerEnding WRITE setLowerEnding)
  Q_PROPERTY(QCPLineEnding upperEnding READ upperEnding WRITE setUpperEnding)
  Q_PROPERTY(QCPGrid *grid READ grid)
 public:
  enum AxisType {
    atLeft = 0x01  
    ,
    atRight = 0x02  
    ,
    atTop = 0x04  
    ,
    atBottom = 0x08  
  };
  Q_FLAGS(AxisType AxisTypes)
  Q_DECLARE_FLAGS(AxisTypes, AxisType)
  enum LabelType {
    ltNumber  
    ,
    ltDateTime  
  };
  Q_ENUMS(LabelType)
  enum LabelSide {
    lsInside  
    ,
    lsOutside  
  };
  Q_ENUMS(LabelSide)
  enum ScaleType {
    stLinear  
    ,
    stLogarithmic  
  };
  Q_ENUMS(ScaleType)
  enum SelectablePart {
    spNone = 0  
    ,
    spAxis = 0x001  
    ,
    spTickLabels = 0x002  
    ,
    spAxisLabel = 0x004  
  };
  Q_FLAGS(SelectablePart SelectableParts)
  Q_DECLARE_FLAGS(SelectableParts, SelectablePart)
 
  explicit QCPAxis(QCPAxisRect *parent, AxisType type);
  virtual ~QCPAxis();
 
  // getters:
  AxisType axisType() const { return mAxisType; }
  QCPAxisRect *axisRect() const { return mAxisRect; }
  ScaleType scaleType() const { return mScaleType; }
  double scaleLogBase() const { return mScaleLogBase; }
  const QCPRange range() const { return mRange; }
  bool rangeReversed() const { return mRangeReversed; }
  bool autoTicks() const { return mAutoTicks; }
  int autoTickCount() const { return mAutoTickCount; }
  bool autoTickLabels() const { return mAutoTickLabels; }
  bool autoTickStep() const { return mAutoTickStep; }
  bool autoSubTicks() const { return mAutoSubTicks; }
  bool ticks() const { return mTicks; }
  bool tickLabels() const { return mTickLabels; }
  int tickLabelPadding() const;
  LabelType tickLabelType() const { return mTickLabelType; }
  QFont tickLabelFont() const { return mTickLabelFont; }
  QColor tickLabelColor() const { return mTickLabelColor; }
  double tickLabelRotation() const;
  LabelSide tickLabelSide() const;
  QString dateTimeFormat() const { return mDateTimeFormat; }
  Qt::TimeSpec dateTimeSpec() const { return mDateTimeSpec; }
  QString numberFormat() const;
  int numberPrecision() const { return mNumberPrecision; }
  double tickStep() const { return mTickStep; }
  QVector<double> tickVector() const { return mTickVector; }
  QVector<QString> tickVectorLabels() const { return mTickVectorLabels; }
  int tickLengthIn() const;
  int tickLengthOut() const;
  int subTickCount() const { return mSubTickCount; }
  int subTickLengthIn() const;
  int subTickLengthOut() const;
  QPen basePen() const { return mBasePen; }
  QPen tickPen() const { return mTickPen; }
  QPen subTickPen() const { return mSubTickPen; }
  QFont labelFont() const { return mLabelFont; }
  QColor labelColor() const { return mLabelColor; }
  QString label() const { return mLabel; }
  int labelPadding() const;
  int padding() const { return mPadding; }
  int offset() const;
  SelectableParts selectedParts() const { return mSelectedParts; }
  SelectableParts selectableParts() const { return mSelectableParts; }
  QFont selectedTickLabelFont() const { return mSelectedTickLabelFont; }
  QFont selectedLabelFont() const { return mSelectedLabelFont; }
  QColor selectedTickLabelColor() const { return mSelectedTickLabelColor; }
  QColor selectedLabelColor() const { return mSelectedLabelColor; }
  QPen selectedBasePen() const { return mSelectedBasePen; }
  QPen selectedTickPen() const { return mSelectedTickPen; }
  QPen selectedSubTickPen() const { return mSelectedSubTickPen; }
  QCPLineEnding lowerEnding() const;
  QCPLineEnding upperEnding() const;
  QCPGrid *grid() const { return mGrid; }
 
  // setters:
  Q_SLOT void setScaleType(QCPAxis::ScaleType type);
  void setScaleLogBase(double base);
  Q_SLOT void setRange(const QCPRange &range);
  void setRange(double lower, double upper);
  void setRange(double position, double size, Qt::AlignmentFlag alignment);
  void setRangeLower(double lower);
  void setRangeUpper(double upper);
  void setRangeReversed(bool reversed);
  void setAutoTicks(bool on);
  void setAutoTickCount(int approximateCount);
  void setAutoTickLabels(bool on);
  void setAutoTickStep(bool on);
  void setAutoSubTicks(bool on);
  void setTicks(bool show);
  void setTickLabels(bool show);
  void setTickLabelPadding(int padding);
  void setTickLabelType(LabelType type);
  void setTickLabelFont(const QFont &font);
  void setTickLabelColor(const QColor &color);
  void setTickLabelRotation(double degrees);
  void setTickLabelSide(LabelSide side);
  void setDateTimeFormat(const QString &format);
  void setDateTimeSpec(const Qt::TimeSpec &timeSpec);
  void setNumberFormat(const QString &formatCode);
  void setNumberPrecision(int precision);
  void setTickStep(double step);
  void setTickVector(const QVector<double> &vec);
  void setTickVectorLabels(const QVector<QString> &vec);
  void setTickLength(int inside, int outside = 0);
  void setTickLengthIn(int inside);
  void setTickLengthOut(int outside);
  void setSubTickCount(int count);
  void setSubTickLength(int inside, int outside = 0);
  void setSubTickLengthIn(int inside);
  void setSubTickLengthOut(int outside);
  void setBasePen(const QPen &pen);
  void setTickPen(const QPen &pen);
  void setSubTickPen(const QPen &pen);
  void setLabelFont(const QFont &font);
  void setLabelColor(const QColor &color);
  void setLabel(const QString &str);
  void setLabelPadding(int padding);
  void setPadding(int padding);
  void setOffset(int offset);
  void setSelectedTickLabelFont(const QFont &font);
  void setSelectedLabelFont(const QFont &font);
  void setSelectedTickLabelColor(const QColor &color);
  void setSelectedLabelColor(const QColor &color);
  void setSelectedBasePen(const QPen &pen);
  void setSelectedTickPen(const QPen &pen);
  void setSelectedSubTickPen(const QPen &pen);
  Q_SLOT void setSelectableParts(
      const QCPAxis::SelectableParts &selectableParts);
  Q_SLOT void setSelectedParts(const QCPAxis::SelectableParts &selectedParts);
  void setLowerEnding(const QCPLineEnding &ending);
  void setUpperEnding(const QCPLineEnding &ending);
 
  // reimplemented virtual methods:
  virtual double selectTest(const QPointF &pos, bool onlySelectable,
                            QVariant *details = 0) const;
 
  // non-property methods:
  Qt::Orientation orientation() const { return mOrientation; }
  void moveRange(double diff);
  void scaleRange(double factor, double center);
  void setScaleRatio(const QCPAxis *otherAxis, double ratio = 1.0);
  void rescale(bool onlyVisiblePlottables = false);
  double pixelToCoord(double value) const;
  double coordToPixel(double value) const;
  SelectablePart getPartAt(const QPointF &pos) const;
  QList<QCPAbstractPlottable *> plottables() const;
  QList<QCPGraph *> graphs() const;
  QList<QCPAbstractItem *> items() const;
 
  static AxisType marginSideToAxisType(QCP::MarginSide side);
  static Qt::Orientation orientation(AxisType type) {
    return type == atBottom || type == atTop ? Qt::Horizontal : Qt::Vertical;
  }
  static AxisType opposite(AxisType type);
 
 signals:
  void ticksRequest();
  void rangeChanged(const QCPRange &newRange);
  void rangeChanged(const QCPRange &newRange, const QCPRange &oldRange);
  void scaleTypeChanged(QCPAxis::ScaleType scaleType);
  void selectionChanged(const QCPAxis::SelectableParts &parts);
  void selectableChanged(const QCPAxis::SelectableParts &parts);
 
 protected:
  // property members:
  // axis base:
  AxisType mAxisType;
  QCPAxisRect *mAxisRect;
  // int mOffset; // in QCPAxisPainter
  int mPadding;
  Qt::Orientation mOrientation;
  SelectableParts mSelectableParts, mSelectedParts;
  QPen mBasePen, mSelectedBasePen;
  // QCPLineEnding mLowerEnding, mUpperEnding; // in QCPAxisPainter
  //  axis label:
  // int mLabelPadding; // in QCPAxisPainter
  QString mLabel;
  QFont mLabelFont, mSelectedLabelFont;
  QColor mLabelColor, mSelectedLabelColor;
  // tick labels:
  // int mTickLabelPadding; // in QCPAxisPainter
  bool mTickLabels, mAutoTickLabels;
  // double mTickLabelRotation; // in QCPAxisPainter
  LabelType mTickLabelType;
  QFont mTickLabelFont, mSelectedTickLabelFont;
  QColor mTickLabelColor, mSelectedTickLabelColor;
  QString mDateTimeFormat;
  Qt::TimeSpec mDateTimeSpec;
  int mNumberPrecision;
  QLatin1Char mNumberFormatChar;
  bool mNumberBeautifulPowers;
  // bool mNumberMultiplyCross; // QCPAxisPainter
  //  ticks and subticks:
  bool mTicks;
  double mTickStep;
  int mSubTickCount, mAutoTickCount;
  bool mAutoTicks, mAutoTickStep, mAutoSubTicks;
  // int mTickLengthIn, mTickLengthOut, mSubTickLengthIn, mSubTickLengthOut; //
  // QCPAxisPainter
  QPen mTickPen, mSelectedTickPen;
  QPen mSubTickPen, mSelectedSubTickPen;
  // scale and range:
  QCPRange mRange;
  bool mRangeReversed;
  ScaleType mScaleType;
  double mScaleLogBase, mScaleLogBaseLogInv;
 
  // non-property members:
  QCPGrid *mGrid;
  QCPAxisPainterPrivate *mAxisPainter;
  int mLowestVisibleTick, mHighestVisibleTick;
  QVector<double> mTickVector;
  QVector<QString> mTickVectorLabels;
  QVector<double> mSubTickVector;
  bool mCachedMarginValid;
  int mCachedMargin;
 
  // introduced virtual methods:
  virtual void setupTickVectors();
  virtual void generateAutoTicks();
  virtual int calculateAutoSubTickCount(double tickStep) const;
  virtual int calculateMargin();
 
  // reimplemented virtual methods:
  virtual void applyDefaultAntialiasingHint(QCPPainter *painter) const;
  virtual void draw(QCPPainter *painter);
  virtual QCP::Interaction selectionCategory() const;
  // events:
  virtual void selectEvent(QMouseEvent *event, bool additive,
                           const QVariant &details,
                           bool *selectionStateChanged);
  virtual void deselectEvent(bool *selectionStateChanged);
 
  // non-virtual methods:
  void visibleTickBounds(int &lowIndex, int &highIndex) const;
  double baseLog(double value) const;
  double basePow(double value) const;
  QPen getBasePen() const;
  QPen getTickPen() const;
  QPen getSubTickPen() const;
  QFont getTickLabelFont() const;
  QFont getLabelFont() const;
  QColor getTickLabelColor() const;
  QColor getLabelColor() const;
 
 private:
  Q_DISABLE_COPY(QCPAxis)
 
  friend class QCustomPlot;
  friend class QCPGrid;
  friend class QCPAxisRect;
};
Q_DECLARE_OPERATORS_FOR_FLAGS(QCPAxis::SelectableParts)
Q_DECLARE_OPERATORS_FOR_FLAGS(QCPAxis::AxisTypes)
Q_DECLARE_METATYPE(QCPAxis::SelectablePart)
 
class QCPAxisPainterPrivate {
 public:
  explicit QCPAxisPainterPrivate(QCustomPlot *parentPlot);
  virtual ~QCPAxisPainterPrivate();
 
  virtual void draw(QCPPainter *painter);
  virtual int size() const;
  void clearCache();
 
  QRect axisSelectionBox() const { return mAxisSelectionBox; }
  QRect tickLabelsSelectionBox() const { return mTickLabelsSelectionBox; }
  QRect labelSelectionBox() const { return mLabelSelectionBox; }
 
  // public property members:
  QCPAxis::AxisType type;
  QPen basePen;
  QCPLineEnding lowerEnding,
      upperEnding;   // directly accessed by QCPAxis setters/getters
  int labelPadding;  // directly accessed by QCPAxis setters/getters
  QFont labelFont;
  QColor labelColor;
  QString label;
  int tickLabelPadding;      // directly accessed by QCPAxis setters/getters
  double tickLabelRotation;  // directly accessed by QCPAxis setters/getters
  QCPAxis::LabelSide
      tickLabelSide;  // directly accessed by QCPAxis setters/getters
  bool substituteExponent;
  bool numberMultiplyCross;  // directly accessed by QCPAxis setters/getters
  int tickLengthIn, tickLengthOut, subTickLengthIn,
      subTickLengthOut;  // directly accessed by QCPAxis setters/getters
  QPen tickPen, subTickPen;
  QFont tickLabelFont;
  QColor tickLabelColor;
  QRect axisRect, viewportRect;
  double offset;  // directly accessed by QCPAxis setters/getters
  bool abbreviateDecimalPowers;
  bool reversedEndings;
 
  QVector<double> subTickPositions;
  QVector<double> tickPositions;
  QVector<QString> tickLabels;
 
 protected:
  struct CachedLabel {
    QPointF offset;
    QPixmap pixmap;
  };
  struct TickLabelData {
    QString basePart, expPart;
    QRect baseBounds, expBounds, totalBounds, rotatedTotalBounds;
    QFont baseFont, expFont;
  };
  QCustomPlot *mParentPlot;
  QByteArray mLabelParameterHash;  // to determine whether mLabelCache needs to
                                   // be cleared due to changed parameters
  QCache<QString, CachedLabel> mLabelCache;
  QRect mAxisSelectionBox, mTickLabelsSelectionBox, mLabelSelectionBox;
 
  virtual QByteArray generateLabelParameterHash() const;
 
  virtual void placeTickLabel(QCPPainter *painter, double position,
                              int distanceToAxis, const QString &text,
                              QSize *tickLabelsSize);
  virtual void drawTickLabel(QCPPainter *painter, double x, double y,
                             const TickLabelData &labelData) const;
  virtual TickLabelData getTickLabelData(const QFont &font,
                                         const QString &text) const;
  virtual QPointF getTickLabelDrawOffset(const TickLabelData &labelData) const;
  virtual void getMaxTickLabelSize(const QFont &font, const QString &text,
                                   QSize *tickLabelsSize) const;
};
 
class QCP_LIB_DECL QCPAbstractPlottable : public QCPLayerable {
  Q_OBJECT
  Q_PROPERTY(QString name READ name WRITE setName)
  Q_PROPERTY(bool antialiasedFill READ antialiasedFill WRITE setAntialiasedFill)
  Q_PROPERTY(bool antialiasedScatters READ antialiasedScatters WRITE
                 setAntialiasedScatters)
  Q_PROPERTY(bool antialiasedErrorBars READ antialiasedErrorBars WRITE
                 setAntialiasedErrorBars)
  Q_PROPERTY(QPen pen READ pen WRITE setPen)
  Q_PROPERTY(QPen selectedPen READ selectedPen WRITE setSelectedPen)
  Q_PROPERTY(QBrush brush READ brush WRITE setBrush)
  Q_PROPERTY(QBrush selectedBrush READ selectedBrush WRITE setSelectedBrush)
  Q_PROPERTY(QCPAxis *keyAxis READ keyAxis WRITE setKeyAxis)
  Q_PROPERTY(QCPAxis *valueAxis READ valueAxis WRITE setValueAxis)
  Q_PROPERTY(bool selectable READ selectable WRITE setSelectable NOTIFY
                 selectableChanged)
  Q_PROPERTY(
      bool selected READ selected WRITE setSelected NOTIFY selectionChanged)
 public:
  QCPAbstractPlottable(QCPAxis *keyAxis, QCPAxis *valueAxis);
 
  // getters:
  QString name() const { return mName; }
  bool antialiasedFill() const { return mAntialiasedFill; }
  bool antialiasedScatters() const { return mAntialiasedScatters; }
  bool antialiasedErrorBars() const { return mAntialiasedErrorBars; }
  QPen pen() const { return mPen; }
  QPen selectedPen() const { return mSelectedPen; }
  QBrush brush() const { return mBrush; }
  QBrush selectedBrush() const { return mSelectedBrush; }
  QCPAxis *keyAxis() const { return mKeyAxis.data(); }
  QCPAxis *valueAxis() const { return mValueAxis.data(); }
  bool selectable() const { return mSelectable; }
  bool selected() const { return mSelected; }
 
  // setters:
  void setName(const QString &name);
  void setAntialiasedFill(bool enabled);
  void setAntialiasedScatters(bool enabled);
  void setAntialiasedErrorBars(bool enabled);
  void setPen(const QPen &pen);
  void setSelectedPen(const QPen &pen);
  void setBrush(const QBrush &brush);
  void setSelectedBrush(const QBrush &brush);
  void setKeyAxis(QCPAxis *axis);
  void setValueAxis(QCPAxis *axis);
  Q_SLOT void setSelectable(bool selectable);
  Q_SLOT void setSelected(bool selected);
 
  // introduced virtual methods:
  virtual void clearData() = 0;
  virtual double selectTest(const QPointF &pos, bool onlySelectable,
                            QVariant *details = 0) const = 0;
  virtual bool addToLegend();
  virtual bool removeFromLegend() const;
 
  // non-property methods:
  void rescaleAxes(bool onlyEnlarge = false) const;
  void rescaleKeyAxis(bool onlyEnlarge = false) const;
  void rescaleValueAxis(bool onlyEnlarge = false) const;
 
 signals:
  void selectionChanged(bool selected);
  void selectableChanged(bool selectable);
 
 protected:
  enum SignDomain {
    sdNegative  
    ,
    sdBoth  
    ,
    sdPositive  
  };
 
  // property members:
  QString mName;
  bool mAntialiasedFill, mAntialiasedScatters, mAntialiasedErrorBars;
  QPen mPen, mSelectedPen;
  QBrush mBrush, mSelectedBrush;
  QPointer<QCPAxis> mKeyAxis, mValueAxis;
  bool mSelectable, mSelected;
 
  // reimplemented virtual methods:
  virtual QRect clipRect() const;
  virtual void draw(QCPPainter *painter) = 0;
  virtual QCP::Interaction selectionCategory() const;
  void applyDefaultAntialiasingHint(QCPPainter *painter) const;
  // events:
  virtual void selectEvent(QMouseEvent *event, bool additive,
                           const QVariant &details,
                           bool *selectionStateChanged);
  virtual void deselectEvent(bool *selectionStateChanged);
 
  // introduced virtual methods:
  virtual void drawLegendIcon(QCPPainter *painter,
                              const QRectF &rect) const = 0;
  virtual QCPRange getKeyRange(bool &foundRange,
                               SignDomain inSignDomain = sdBoth) const = 0;
  virtual QCPRange getValueRange(bool &foundRange,
                                 SignDomain inSignDomain = sdBoth) const = 0;
 
  // non-virtual methods:
  void coordsToPixels(double key, double value, double &x, double &y) const;
  const QPointF coordsToPixels(double key, double value) const;
  void pixelsToCoords(double x, double y, double &key, double &value) const;
  void pixelsToCoords(const QPointF &pixelPos, double &key,
                      double &value) const;
  QPen mainPen() const;
  QBrush mainBrush() const;
  void applyFillAntialiasingHint(QCPPainter *painter) const;
  void applyScattersAntialiasingHint(QCPPainter *painter) const;
  void applyErrorBarsAntialiasingHint(QCPPainter *painter) const;
  double distSqrToLine(const QPointF &start, const QPointF &end,
                       const QPointF &point) const;
 
 private:
  Q_DISABLE_COPY(QCPAbstractPlottable)
 
  friend class QCustomPlot;
  friend class QCPAxis;
  friend class QCPPlottableLegendItem;
};
 
class QCP_LIB_DECL QCPItemAnchor {
 public:
  QCPItemAnchor(QCustomPlot *parentPlot, QCPAbstractItem *parentItem,
                const QString name, int anchorId = -1);
  virtual ~QCPItemAnchor();
 
  // getters:
  QString name() const { return mName; }
  virtual QPointF pixelPoint() const;
 
 protected:
  // property members:
  QString mName;
 
  // non-property members:
  QCustomPlot *mParentPlot;
  QCPAbstractItem *mParentItem;
  int mAnchorId;
  QSet<QCPItemPosition *> mChildrenX, mChildrenY;
 
  // introduced virtual methods:
  virtual QCPItemPosition *toQCPItemPosition() { return 0; }
 
  // non-virtual methods:
  void addChildX(QCPItemPosition *
                     pos);  // called from pos when this anchor is set as parent
  void removeChildX(QCPItemPosition *pos);  // called from pos when its parent
                                            // anchor is reset or pos deleted
  void addChildY(QCPItemPosition *
                     pos);  // called from pos when this anchor is set as parent
  void removeChildY(QCPItemPosition *pos);  // called from pos when its parent
                                            // anchor is reset or pos deleted
 
 private:
  Q_DISABLE_COPY(QCPItemAnchor)
 
  friend class QCPItemPosition;
};
 
class QCP_LIB_DECL QCPItemPosition : public QCPItemAnchor {
 public:
  enum PositionType {
    ptAbsolute  
    ,
    ptViewportRatio  
    ,
    ptAxisRectRatio  
    ,
    ptPlotCoords  
  };
 
  QCPItemPosition(QCustomPlot *parentPlot, QCPAbstractItem *parentItem,
                  const QString name);
  virtual ~QCPItemPosition();
 
  // getters:
  PositionType type() const { return typeX(); }
  PositionType typeX() const { return mPositionTypeX; }
  PositionType typeY() const { return mPositionTypeY; }
  QCPItemAnchor *parentAnchor() const { return parentAnchorX(); }
  QCPItemAnchor *parentAnchorX() const { return mParentAnchorX; }
  QCPItemAnchor *parentAnchorY() const { return mParentAnchorY; }
  double key() const { return mKey; }
  double value() const { return mValue; }
  QPointF coords() const { return QPointF(mKey, mValue); }
  QCPAxis *keyAxis() const { return mKeyAxis.data(); }
  QCPAxis *valueAxis() const { return mValueAxis.data(); }
  QCPAxisRect *axisRect() const;
  virtual QPointF pixelPoint() const;
 
  // setters:
  void setType(PositionType type);
  void setTypeX(PositionType type);
  void setTypeY(PositionType type);
  bool setParentAnchor(QCPItemAnchor *parentAnchor,
                       bool keepPixelPosition = false);
  bool setParentAnchorX(QCPItemAnchor *parentAnchor,
                        bool keepPixelPosition = false);
  bool setParentAnchorY(QCPItemAnchor *parentAnchor,
                        bool keepPixelPosition = false);
  void setCoords(double key, double value);
  void setCoords(const QPointF &coords);
  void setAxes(QCPAxis *keyAxis, QCPAxis *valueAxis);
  void setAxisRect(QCPAxisRect *axisRect);
  void setPixelPoint(const QPointF &pixelPoint);
 
 protected:
  // property members:
  PositionType mPositionTypeX, mPositionTypeY;
  QPointer<QCPAxis> mKeyAxis, mValueAxis;
  QPointer<QCPAxisRect> mAxisRect;
  double mKey, mValue;
  QCPItemAnchor *mParentAnchorX, *mParentAnchorY;
 
  // reimplemented virtual methods:
  virtual QCPItemPosition *toQCPItemPosition() { return this; }
 
 private:
  Q_DISABLE_COPY(QCPItemPosition)
};
 
class QCP_LIB_DECL QCPAbstractItem : public QCPLayerable {
  Q_OBJECT
  Q_PROPERTY(bool clipToAxisRect READ clipToAxisRect WRITE setClipToAxisRect)
  Q_PROPERTY(QCPAxisRect *clipAxisRect READ clipAxisRect WRITE setClipAxisRect)
  Q_PROPERTY(bool selectable READ selectable WRITE setSelectable NOTIFY
                 selectableChanged)
  Q_PROPERTY(
      bool selected READ selected WRITE setSelected NOTIFY selectionChanged)
 public:
  QCPAbstractItem(QCustomPlot *parentPlot);
  virtual ~QCPAbstractItem();
 
  // getters:
  bool clipToAxisRect() const { return mClipToAxisRect; }
  QCPAxisRect *clipAxisRect() const;
  bool selectable() const { return mSelectable; }
  bool selected() const { return mSelected; }
 
  // setters:
  void setClipToAxisRect(bool clip);
  void setClipAxisRect(QCPAxisRect *rect);
  Q_SLOT void setSelectable(bool selectable);
  Q_SLOT void setSelected(bool selected);
 
  // reimplemented virtual methods:
  virtual double selectTest(const QPointF &pos, bool onlySelectable,
                            QVariant *details = 0) const = 0;
 
  // non-virtual methods:
  QList<QCPItemPosition *> positions() const { return mPositions; }
  QList<QCPItemAnchor *> anchors() const { return mAnchors; }
  QCPItemPosition *position(const QString &name) const;
  QCPItemAnchor *anchor(const QString &name) const;
  bool hasAnchor(const QString &name) const;
 
 signals:
  void selectionChanged(bool selected);
  void selectableChanged(bool selectable);
 
 protected:
  // property members:
  bool mClipToAxisRect;
  QPointer<QCPAxisRect> mClipAxisRect;
  QList<QCPItemPosition *> mPositions;
  QList<QCPItemAnchor *> mAnchors;
  bool mSelectable, mSelected;
 
  // reimplemented virtual methods:
  virtual QCP::Interaction selectionCategory() const;
  virtual QRect clipRect() const;
  virtual void applyDefaultAntialiasingHint(QCPPainter *painter) const;
  virtual void draw(QCPPainter *painter) = 0;
  // events:
  virtual void selectEvent(QMouseEvent *event, bool additive,
                           const QVariant &details,
                           bool *selectionStateChanged);
  virtual void deselectEvent(bool *selectionStateChanged);
 
  // introduced virtual methods:
  virtual QPointF anchorPixelPoint(int anchorId) const;
 
  // non-virtual methods:
  double distSqrToLine(const QPointF &start, const QPointF &end,
                       const QPointF &point) const;
  double rectSelectTest(const QRectF &rect, const QPointF &pos,
                        bool filledRect) const;
  QCPItemPosition *createPosition(const QString &name);
  QCPItemAnchor *createAnchor(const QString &name, int anchorId);
 
 private:
  Q_DISABLE_COPY(QCPAbstractItem)
 
  friend class QCustomPlot;
  friend class QCPItemAnchor;
};
 
class QCP_LIB_DECL QCustomPlot : public QWidget {
  Q_OBJECT
  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)
 public:
  enum LayerInsertMode {
    limBelow  
    ,
    limAbove  
  };
  Q_ENUMS(LayerInsertMode)
 
  
  enum RefreshPriority {
    rpImmediate  
    ,
    rpQueued  
    ,
    rpHint  
  };
 
  explicit QCustomPlot(QWidget *parent = 0);
  virtual ~QCustomPlot();
 
  // getters:
  QRect viewport() const { return mViewport; }
  QPixmap background() const { return mBackgroundPixmap; }
  bool backgroundScaled() const { return mBackgroundScaled; }
  Qt::AspectRatioMode backgroundScaledMode() const {
    return mBackgroundScaledMode;
  }
  QCPLayoutGrid *plotLayout() const { return mPlotLayout; }
  QCP::AntialiasedElements antialiasedElements() const {
    return mAntialiasedElements;
  }
  QCP::AntialiasedElements notAntialiasedElements() const {
    return mNotAntialiasedElements;
  }
  bool autoAddPlottableToLegend() const { return mAutoAddPlottableToLegend; }
  const QCP::Interactions interactions() const { return mInteractions; }
  int selectionTolerance() const { return mSelectionTolerance; }
  bool noAntialiasingOnDrag() const { return mNoAntialiasingOnDrag; }
  QCP::PlottingHints plottingHints() const { return mPlottingHints; }
  Qt::KeyboardModifier multiSelectModifier() const {
    return mMultiSelectModifier;
  }
 
  // setters:
  void setViewport(const QRect &rect);
  void setBackground(const QPixmap &pm);
  void setBackground(const QPixmap &pm, bool scaled,
                     Qt::AspectRatioMode mode = Qt::KeepAspectRatioByExpanding);
  void setBackground(const QBrush &brush);
  void setBackgroundScaled(bool scaled);
  void setBackgroundScaledMode(Qt::AspectRatioMode mode);
  void setAntialiasedElements(
      const QCP::AntialiasedElements &antialiasedElements);
  void setAntialiasedElement(QCP::AntialiasedElement antialiasedElement,
                             bool enabled = true);
  void setNotAntialiasedElements(
      const QCP::AntialiasedElements &notAntialiasedElements);
  void setNotAntialiasedElement(QCP::AntialiasedElement notAntialiasedElement,
                                bool enabled = true);
  void setAutoAddPlottableToLegend(bool on);
  void setInteractions(const QCP::Interactions &interactions);
  void setInteraction(const QCP::Interaction &interaction, bool enabled = true);
  void setSelectionTolerance(int pixels);
  void setNoAntialiasingOnDrag(bool enabled);
  void setPlottingHints(const QCP::PlottingHints &hints);
  void setPlottingHint(QCP::PlottingHint hint, bool enabled = true);
  void setMultiSelectModifier(Qt::KeyboardModifier modifier);
 
  // non-property methods:
  // plottable interface:
  QCPAbstractPlottable *plottable(int index);
  QCPAbstractPlottable *plottable();
  bool addPlottable(QCPAbstractPlottable *plottable);
  bool removePlottable(QCPAbstractPlottable *plottable);
  bool removePlottable(int index);
  int clearPlottables();
  int plottableCount() const;
  QList<QCPAbstractPlottable *> selectedPlottables() const;
  QCPAbstractPlottable *plottableAt(const QPointF &pos,
                                    bool onlySelectable = false) const;
  bool hasPlottable(QCPAbstractPlottable *plottable) const;
 
  // specialized interface for QCPGraph:
  QCPGraph *graph(int index) const;
  QCPGraph *graph() const;
  QCPGraph *addGraph(QCPAxis *keyAxis = 0, QCPAxis *valueAxis = 0);
  bool removeGraph(QCPGraph *graph);
  bool removeGraph(int index);
  int clearGraphs();
  int graphCount() const;
  QList<QCPGraph *> selectedGraphs() const;
 
  // item interface:
  QCPAbstractItem *item(int index) const;
  QCPAbstractItem *item() const;
  bool addItem(QCPAbstractItem *item);
  bool removeItem(QCPAbstractItem *item);
  bool removeItem(int index);
  int clearItems();
  int itemCount() const;
  QList<QCPAbstractItem *> selectedItems() const;
  QCPAbstractItem *itemAt(const QPointF &pos,
                          bool onlySelectable = false) const;
  bool hasItem(QCPAbstractItem *item) const;
 
  // layer interface:
  QCPLayer *layer(const QString &name) const;
  QCPLayer *layer(int index) const;
  QCPLayer *currentLayer() const;
  bool setCurrentLayer(const QString &name);
  bool setCurrentLayer(QCPLayer *layer);
  int layerCount() const;
  bool addLayer(const QString &name, QCPLayer *otherLayer = 0,
                LayerInsertMode insertMode = limAbove);
  bool removeLayer(QCPLayer *layer);
  bool moveLayer(QCPLayer *layer, QCPLayer *otherLayer,
                 LayerInsertMode insertMode = limAbove);
 
  // axis rect/layout interface:
  int axisRectCount() const;
  QCPAxisRect *axisRect(int index = 0) const;
  QList<QCPAxisRect *> axisRects() const;
  QCPLayoutElement *layoutElementAt(const QPointF &pos) const;
  Q_SLOT void rescaleAxes(bool onlyVisiblePlottables = false);
 
  QList<QCPAxis *> selectedAxes() const;
  QList<QCPLegend *> selectedLegends() const;
  Q_SLOT void deselectAll();
 
  bool savePdf(const QString &fileName, bool noCosmeticPen = false,
               int width = 0, int height = 0,
               const QString &pdfCreator = QString(),
               const QString &pdfTitle = QString());
  bool savePng(const QString &fileName, int width = 0, int height = 0,
               double scale = 1.0, int quality = -1);
  bool saveJpg(const QString &fileName, int width = 0, int height = 0,
               double scale = 1.0, int quality = -1);
  bool saveBmp(const QString &fileName, int width = 0, int height = 0,
               double scale = 1.0);
  bool saveRastered(const QString &fileName, int width, int height,
                    double scale, const char *format, int quality = -1);
  QPixmap toPixmap(int width = 0, int height = 0, double scale = 1.0);
  void toPainter(QCPPainter *painter, int width = 0, int height = 0);
  Q_SLOT void replot(
      QCustomPlot::RefreshPriority refreshPriority = QCustomPlot::rpHint);
 
  QCPAxis *xAxis, *yAxis, *xAxis2, *yAxis2;
  QCPLegend *legend;
 
 signals:
  void mouseDoubleClick(QMouseEvent *event);
  void mousePress(QMouseEvent *event);
  void mouseMove(QMouseEvent *event);
  void mouseRelease(QMouseEvent *event);
  void mouseWheel(QWheelEvent *event);
 
  void plottableClick(QCPAbstractPlottable *plottable, QMouseEvent *event);
  void plottableDoubleClick(QCPAbstractPlottable *plottable,
                            QMouseEvent *event);
  void itemClick(QCPAbstractItem *item, QMouseEvent *event);
  void itemDoubleClick(QCPAbstractItem *item, QMouseEvent *event);
  void axisClick(QCPAxis *axis, QCPAxis::SelectablePart part,
                 QMouseEvent *event);
  void axisDoubleClick(QCPAxis *axis, QCPAxis::SelectablePart part,
                       QMouseEvent *event);
  void legendClick(QCPLegend *legend, QCPAbstractLegendItem *item,
                   QMouseEvent *event);
  void legendDoubleClick(QCPLegend *legend, QCPAbstractLegendItem *item,
                         QMouseEvent *event);
  void titleClick(QMouseEvent *event, QCPPlotTitle *title);
  void titleDoubleClick(QMouseEvent *event, QCPPlotTitle *title);
 
  void selectionChangedByUser();
  void beforeReplot();
  void afterReplot();
 
 protected:
  // property members:
  QRect mViewport;
  QCPLayoutGrid *mPlotLayout;
  bool mAutoAddPlottableToLegend;
  QList<QCPAbstractPlottable *> mPlottables;
  QList<QCPGraph *> mGraphs;  // extra list of plottables also in mPlottables
                              // that are of type QCPGraph
  QList<QCPAbstractItem *> mItems;
  QList<QCPLayer *> mLayers;
  QCP::AntialiasedElements mAntialiasedElements, mNotAntialiasedElements;
  QCP::Interactions mInteractions;
  int mSelectionTolerance;
  bool mNoAntialiasingOnDrag;
  QBrush mBackgroundBrush;
  QPixmap mBackgroundPixmap;
  QPixmap mScaledBackgroundPixmap;
  bool mBackgroundScaled;
  Qt::AspectRatioMode mBackgroundScaledMode;
  QCPLayer *mCurrentLayer;
  QCP::PlottingHints mPlottingHints;
  Qt::KeyboardModifier mMultiSelectModifier;
 
  // non-property members:
  QPixmap mPaintBuffer;
  QPoint mMousePressPos;
  QPointer<QCPLayoutElement> mMouseEventElement;
  bool mReplotting;
 
  // reimplemented virtual methods:
  virtual QSize minimumSizeHint() const;
  virtual QSize sizeHint() const;
  virtual void paintEvent(QPaintEvent *event);
  virtual void resizeEvent(QResizeEvent *event);
  virtual void mouseDoubleClickEvent(QMouseEvent *event);
  virtual void mousePressEvent(QMouseEvent *event);
  virtual void mouseMoveEvent(QMouseEvent *event);
  virtual void mouseReleaseEvent(QMouseEvent *event);
  virtual void wheelEvent(QWheelEvent *event);
 
  // introduced virtual methods:
  virtual void draw(QCPPainter *painter);
  virtual void axisRemoved(QCPAxis *axis);
  virtual void legendRemoved(QCPLegend *legend);
 
  // non-virtual methods:
  void updateLayerIndices() const;
  QCPLayerable *layerableAt(const QPointF &pos, bool onlySelectable,
                            QVariant *selectionDetails = 0) const;
  void drawBackground(QCPPainter *painter);
 
  friend class QCPLegend;
  friend class QCPAxis;
  friend class QCPLayer;
  friend class QCPAxisRect;
};
 
class QCP_LIB_DECL QCPColorGradient {
  Q_GADGET
 public:
  enum ColorInterpolation {
    ciRGB  
    ,
    ciHSV  
  };
  Q_ENUMS(ColorInterpolation)
 
  
  enum GradientPreset {
    gpGrayscale  
    ,
    gpHot  
    ,
    gpCold  
    ,
    gpNight  
    ,
    gpCandy  
    ,
    gpGeography  
    ,
    gpIon  
    ,
    gpThermal  
    ,
    gpPolar  
    ,
    gpSpectrum  
    ,
    gpJet  
    ,
    gpHues  
  };
  Q_ENUMS(GradientPreset)
 
  QCPColorGradient(GradientPreset preset = gpCold);
  bool operator==(const QCPColorGradient &other) const;
  bool operator!=(const QCPColorGradient &other) const {
    return !(*this == other);
  }
 
  // getters:
  int levelCount() const { return mLevelCount; }
  QMap<double, QColor> colorStops() const { return mColorStops; }
  ColorInterpolation colorInterpolation() const { return mColorInterpolation; }
  bool periodic() const { return mPeriodic; }
 
  // setters:
  void setLevelCount(int n);
  void setColorStops(const QMap<double, QColor> &colorStops);
  void setColorStopAt(double position, const QColor &color);
  void setColorInterpolation(ColorInterpolation interpolation);
  void setPeriodic(bool enabled);
 
  // non-property methods:
  void colorize(const double *data, const QCPRange &range, QRgb *scanLine,
                int n, int dataIndexFactor = 1, bool logarithmic = false);
  QRgb color(double position, const QCPRange &range, bool logarithmic = false);
  void loadPreset(GradientPreset preset);
  void clearColorStops();
  QCPColorGradient inverted() const;
 
 protected:
  void updateColorBuffer();
 
  // property members:
  int mLevelCount;
  QMap<double, QColor> mColorStops;
  ColorInterpolation mColorInterpolation;
  bool mPeriodic;
 
  // non-property members:
  QVector<QRgb> mColorBuffer;
  bool mColorBufferInvalidated;
};
 
class QCP_LIB_DECL QCPAxisRect : public QCPLayoutElement {
  Q_OBJECT
  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)
 public:
  explicit QCPAxisRect(QCustomPlot *parentPlot, bool setupDefaultAxes = true);
  virtual ~QCPAxisRect();
 
  // getters:
  QPixmap background() const { return mBackgroundPixmap; }
  bool backgroundScaled() const { return mBackgroundScaled; }
  Qt::AspectRatioMode backgroundScaledMode() const {
    return mBackgroundScaledMode;
  }
  Qt::Orientations rangeDrag() const { return mRangeDrag; }
  Qt::Orientations rangeZoom() const { return mRangeZoom; }
  QCPAxis *rangeDragAxis(Qt::Orientation orientation);
  QCPAxis *rangeZoomAxis(Qt::Orientation orientation);
  double rangeZoomFactor(Qt::Orientation orientation);
 
  // setters:
  void setBackground(const QPixmap &pm);
  void setBackground(const QPixmap &pm, bool scaled,
                     Qt::AspectRatioMode mode = Qt::KeepAspectRatioByExpanding);
  void setBackground(const QBrush &brush);
  void setBackgroundScaled(bool scaled);
  void setBackgroundScaledMode(Qt::AspectRatioMode mode);
  void setRangeDrag(Qt::Orientations orientations);
  void setRangeZoom(Qt::Orientations orientations);
  void setRangeDragAxes(QCPAxis *horizontal, QCPAxis *vertical);
  void setRangeZoomAxes(QCPAxis *horizontal, QCPAxis *vertical);
  void setRangeZoomFactor(double horizontalFactor, double verticalFactor);
  void setRangeZoomFactor(double factor);
 
  // non-property methods:
  int axisCount(QCPAxis::AxisType type) const;
  QCPAxis *axis(QCPAxis::AxisType type, int index = 0) const;
  QList<QCPAxis *> axes(QCPAxis::AxisTypes types) const;
  QList<QCPAxis *> axes() const;
  QCPAxis *addAxis(QCPAxis::AxisType type, QCPAxis *axis = 0);
  QList<QCPAxis *> addAxes(QCPAxis::AxisTypes types);
  bool removeAxis(QCPAxis *axis);
  QCPLayoutInset *insetLayout() const { return mInsetLayout; }
 
  void setupFullAxesBox(bool connectRanges = false);
  QList<QCPAbstractPlottable *> plottables() const;
  QList<QCPGraph *> graphs() const;
  QList<QCPAbstractItem *> items() const;
 
  // read-only interface imitating a QRect:
  int left() const { return mRect.left(); }
  int right() const { return mRect.right(); }
  int top() const { return mRect.top(); }
  int bottom() const { return mRect.bottom(); }
  int width() const { return mRect.width(); }
  int height() const { return mRect.height(); }
  QSize size() const { return mRect.size(); }
  QPoint topLeft() const { return mRect.topLeft(); }
  QPoint topRight() const { return mRect.topRight(); }
  QPoint bottomLeft() const { return mRect.bottomLeft(); }
  QPoint bottomRight() const { return mRect.bottomRight(); }
  QPoint center() const { return mRect.center(); }
 
  // reimplemented virtual methods:
  virtual void update(UpdatePhase phase);
  virtual QList<QCPLayoutElement *> elements(bool recursive) const;
 
 protected:
  // property members:
  QBrush mBackgroundBrush;
  QPixmap mBackgroundPixmap;
  QPixmap mScaledBackgroundPixmap;
  bool mBackgroundScaled;
  Qt::AspectRatioMode mBackgroundScaledMode;
  QCPLayoutInset *mInsetLayout;
  Qt::Orientations mRangeDrag, mRangeZoom;
  QPointer<QCPAxis> mRangeDragHorzAxis, mRangeDragVertAxis, mRangeZoomHorzAxis,
      mRangeZoomVertAxis;
  double mRangeZoomFactorHorz, mRangeZoomFactorVert;
  // non-property members:
  QCPRange mDragStartHorzRange, mDragStartVertRange;
  QCP::AntialiasedElements mAADragBackup, mNotAADragBackup;
  QPoint mDragStart;
  bool mDragging;
  QHash<QCPAxis::AxisType, QList<QCPAxis *> > mAxes;
 
  // reimplemented virtual methods:
  virtual void applyDefaultAntialiasingHint(QCPPainter *painter) const;
  virtual void draw(QCPPainter *painter);
  virtual int calculateAutoMargin(QCP::MarginSide side);
  // events:
  virtual void mousePressEvent(QMouseEvent *event);
  virtual void mouseMoveEvent(QMouseEvent *event);
  virtual void mouseReleaseEvent(QMouseEvent *event);
  virtual void wheelEvent(QWheelEvent *event);
 
  // non-property methods:
  void drawBackground(QCPPainter *painter);
  void updateAxesOffset(QCPAxis::AxisType type);
 
 private:
  Q_DISABLE_COPY(QCPAxisRect)
 
  friend class QCustomPlot;
};
 
class QCP_LIB_DECL QCPAbstractLegendItem : public QCPLayoutElement {
  Q_OBJECT
  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)
 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
  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)
 public:
  enum SelectablePart {
    spNone = 0x000  
    ,
    spLegendBox = 0x001  
    ,
    spItems = 0x002  
  };
  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
  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)
 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::mouseMoveEvent;
  using QCPAxisRect::mousePressEvent;
  using QCPAxisRect::mouseReleaseEvent;
  using QCPAxisRect::update;
  using QCPAxisRect::wheelEvent;
  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
  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)
 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;
};
 
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 QMap<double, QCPData> QCPDataMap;
typedef QMapIterator<double, QCPData> QCPDataMapIterator;
typedef QMutableMapIterator<double, QCPData> QCPDataMutableMapIterator;
 
class QCP_LIB_DECL QCPGraph : public QCPAbstractPlottable {
  Q_OBJECT
  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)
 public:
  enum LineStyle {
    lsNone  
    ,
    lsLine  
    ,
    lsStepLeft  
    ,
    lsStepRight  
    ,
    lsStepCenter  
    ,
    lsImpulse  
  };
  Q_ENUMS(LineStyle)
  enum ErrorType {
    etNone  
    ,
    etKey  
    ,
    etValue  
    ,
    etBoth  
  };
  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;
};
 
class QCP_LIB_DECL QCPCurveData {
 public:
  QCPCurveData();
  QCPCurveData(double t, double key, double value);
  double t, key, value;
};
Q_DECLARE_TYPEINFO(QCPCurveData, Q_MOVABLE_TYPE);
 
typedef QMap<double, QCPCurveData> QCPCurveDataMap;
typedef QMapIterator<double, QCPCurveData> QCPCurveDataMapIterator;
typedef QMutableMapIterator<double, QCPCurveData>
    QCPCurveDataMutableMapIterator;
 
class QCP_LIB_DECL QCPCurve : public QCPAbstractPlottable {
  Q_OBJECT
  Q_PROPERTY(
      QCPScatterStyle scatterStyle READ scatterStyle WRITE setScatterStyle)
  Q_PROPERTY(LineStyle lineStyle READ lineStyle WRITE setLineStyle)
 public:
  enum LineStyle {
    lsNone  
    ,
    lsLine  
  };
  explicit QCPCurve(QCPAxis *keyAxis, QCPAxis *valueAxis);
  virtual ~QCPCurve();
 
  // getters:
  QCPCurveDataMap *data() const { return mData; }
  QCPScatterStyle scatterStyle() const { return mScatterStyle; }
  LineStyle lineStyle() const { return mLineStyle; }
 
  // setters:
  void setData(QCPCurveDataMap *data, bool copy = false);
  void setData(const QVector<double> &t, const QVector<double> &key,
               const QVector<double> &value);
  void setData(const QVector<double> &key, const QVector<double> &value);
  void setScatterStyle(const QCPScatterStyle &style);
  void setLineStyle(LineStyle style);
 
  // non-property methods:
  void addData(const QCPCurveDataMap &dataMap);
  void addData(const QCPCurveData &data);
  void addData(double t, double key, double value);
  void addData(double key, double value);
  void addData(const QVector<double> &ts, const QVector<double> &keys,
               const QVector<double> &values);
  void removeDataBefore(double t);
  void removeDataAfter(double t);
  void removeData(double fromt, double tot);
  void removeData(double t);
 
  // reimplemented virtual methods:
  virtual void clearData();
  virtual double selectTest(const QPointF &pos, bool onlySelectable,
                            QVariant *details = 0) const;
 
 protected:
  // property members:
  QCPCurveDataMap *mData;
  QCPScatterStyle mScatterStyle;
  LineStyle mLineStyle;
 
  // reimplemented virtual methods:
  virtual void draw(QCPPainter *painter);
  virtual void drawLegendIcon(QCPPainter *painter, const QRectF &rect) const;
  virtual QCPRange getKeyRange(bool &foundRange,
                               SignDomain inSignDomain = sdBoth) const;
  virtual QCPRange getValueRange(bool &foundRange,
                                 SignDomain inSignDomain = sdBoth) const;
 
  // introduced virtual methods:
  virtual void drawScatterPlot(QCPPainter *painter,
                               const QVector<QPointF> *pointData) const;
 
  // non-virtual methods:
  void getCurveData(QVector<QPointF> *lineData) const;
  int getRegion(double x, double y, double rectLeft, double rectTop,
                double rectRight, double rectBottom) const;
  QPointF getOptimizedPoint(int prevRegion, double prevKey, double prevValue,
                            double key, double value, double rectLeft,
                            double rectTop, double rectRight,
                            double rectBottom) const;
  QVector<QPointF> getOptimizedCornerPoints(int prevRegion, int currentRegion,
                                            double prevKey, double prevValue,
                                            double key, double value,
                                            double rectLeft, double rectTop,
                                            double rectRight,
                                            double rectBottom) const;
  bool mayTraverse(int prevRegion, int currentRegion) const;
  bool getTraverse(double prevKey, double prevValue, double key, double value,
                   double rectLeft, double rectTop, double rectRight,
                   double rectBottom, QPointF &crossA, QPointF &crossB) const;
  void getTraverseCornerPoints(int prevRegion, int currentRegion,
                               double rectLeft, double rectTop,
                               double rectRight, double rectBottom,
                               QVector<QPointF> &beforeTraverse,
                               QVector<QPointF> &afterTraverse) const;
  double pointDistance(const QPointF &pixelPoint) const;
 
  friend class QCustomPlot;
  friend class QCPLegend;
};
 
class QCP_LIB_DECL QCPBarsGroup : public QObject {
  Q_OBJECT
  Q_PROPERTY(SpacingType spacingType READ spacingType WRITE setSpacingType)
  Q_PROPERTY(double spacing READ spacing WRITE setSpacing)
 public:
  enum SpacingType {
    stAbsolute  
    ,
    stAxisRectRatio  
    ,
    stPlotCoords  
  };
  QCPBarsGroup(QCustomPlot *parentPlot);
  ~QCPBarsGroup();
 
  // getters:
  SpacingType spacingType() const { return mSpacingType; }
  double spacing() const { return mSpacing; }
 
  // setters:
  void setSpacingType(SpacingType spacingType);
  void setSpacing(double spacing);
 
  // non-virtual methods:
  QList<QCPBars *> bars() const { return mBars; }
  QCPBars *bars(int index) const;
  int size() const { return mBars.size(); }
  bool isEmpty() const { return mBars.isEmpty(); }
  void clear();
  bool contains(QCPBars *bars) const { return mBars.contains(bars); }
  void append(QCPBars *bars);
  void insert(int i, QCPBars *bars);
  void remove(QCPBars *bars);
 
 protected:
  // non-property members:
  QCustomPlot *mParentPlot;
  SpacingType mSpacingType;
  double mSpacing;
  QList<QCPBars *> mBars;
 
  // non-virtual methods:
  void registerBars(QCPBars *bars);
  void unregisterBars(QCPBars *bars);
 
  // virtual methods:
  double keyPixelOffset(const QCPBars *bars, double keyCoord);
  double getPixelSpacing(const QCPBars *bars, double keyCoord);
 
 private:
  Q_DISABLE_COPY(QCPBarsGroup)
 
  friend class QCPBars;
};
 
class QCP_LIB_DECL QCPBarData {
 public:
  QCPBarData();
  QCPBarData(double key, double value);
  double key, value;
};
Q_DECLARE_TYPEINFO(QCPBarData, Q_MOVABLE_TYPE);
 
typedef QMap<double, QCPBarData> QCPBarDataMap;
typedef QMapIterator<double, QCPBarData> QCPBarDataMapIterator;
typedef QMutableMapIterator<double, QCPBarData> QCPBarDataMutableMapIterator;
 
class QCP_LIB_DECL QCPBars : public QCPAbstractPlottable {
  Q_OBJECT
  Q_PROPERTY(double width READ width WRITE setWidth)
  Q_PROPERTY(WidthType widthType READ widthType WRITE setWidthType)
  Q_PROPERTY(QCPBarsGroup *barsGroup READ barsGroup WRITE setBarsGroup)
  Q_PROPERTY(double baseValue READ baseValue WRITE setBaseValue)
  Q_PROPERTY(QCPBars *barBelow READ barBelow)
  Q_PROPERTY(QCPBars *barAbove READ barAbove)
 public:
  enum WidthType {
    wtAbsolute  
    ,
    wtAxisRectRatio  
    ,
    wtPlotCoords  
  };
  Q_ENUMS(WidthType)
 
  explicit QCPBars(QCPAxis *keyAxis, QCPAxis *valueAxis);
  virtual ~QCPBars();
 
  // getters:
  double width() const { return mWidth; }
  WidthType widthType() const { return mWidthType; }
  QCPBarsGroup *barsGroup() const { return mBarsGroup; }
  double baseValue() const { return mBaseValue; }
  QCPBars *barBelow() const { return mBarBelow.data(); }
  QCPBars *barAbove() const { return mBarAbove.data(); }
  QCPBarDataMap *data() const { return mData; }
 
  // setters:
  void setWidth(double width);
  void setWidthType(WidthType widthType);
  void setBarsGroup(QCPBarsGroup *barsGroup);
  void setBaseValue(double baseValue);
  void setData(QCPBarDataMap *data, bool copy = false);
  void setData(const QVector<double> &key, const QVector<double> &value);
 
  // non-property methods:
  void moveBelow(QCPBars *bars);
  void moveAbove(QCPBars *bars);
  void addData(const QCPBarDataMap &dataMap);
  void addData(const QCPBarData &data);
  void addData(double key, double value);
  void addData(const QVector<double> &keys, const QVector<double> &values);
  void removeDataBefore(double key);
  void removeDataAfter(double key);
  void removeData(double fromKey, double toKey);
  void removeData(double key);
 
  // reimplemented virtual methods:
  virtual void clearData();
  virtual double selectTest(const QPointF &pos, bool onlySelectable,
                            QVariant *details = 0) const;
 
 protected:
  // property members:
  QCPBarDataMap *mData;
  double mWidth;
  WidthType mWidthType;
  QCPBarsGroup *mBarsGroup;
  double mBaseValue;
  QPointer<QCPBars> mBarBelow, mBarAbove;
 
  // reimplemented virtual methods:
  virtual void draw(QCPPainter *painter);
  virtual void drawLegendIcon(QCPPainter *painter, const QRectF &rect) const;
  virtual QCPRange getKeyRange(bool &foundRange,
                               SignDomain inSignDomain = sdBoth) const;
  virtual QCPRange getValueRange(bool &foundRange,
                                 SignDomain inSignDomain = sdBoth) const;
 
  // non-virtual methods:
  void getVisibleDataBounds(QCPBarDataMap::const_iterator &lower,
                            QCPBarDataMap::const_iterator &upperEnd) const;
  QPolygonF getBarPolygon(double key, double value) const;
  void getPixelWidth(double key, double &lower, double &upper) const;
  double getStackedBaseValue(double key, bool positive) const;
  static void connectBars(QCPBars *lower, QCPBars *upper);
 
  friend class QCustomPlot;
  friend class QCPLegend;
  friend class QCPBarsGroup;
};
 
class QCP_LIB_DECL QCPStatisticalBox : public QCPAbstractPlottable {
  Q_OBJECT
  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)
 public:
  explicit QCPStatisticalBox(QCPAxis *keyAxis, QCPAxis *valueAxis);
 
  // getters:
  double key() const { return mKey; }
  double minimum() const { return mMinimum; }
  double lowerQuartile() const { return mLowerQuartile; }
  double median() const { return mMedian; }
  double upperQuartile() const { return mUpperQuartile; }
  double maximum() const { return mMaximum; }
  QVector<double> outliers() const { return mOutliers; }
  double width() const { return mWidth; }
  double whiskerWidth() const { return mWhiskerWidth; }
  QPen whiskerPen() const { return mWhiskerPen; }
  QPen whiskerBarPen() const { return mWhiskerBarPen; }
  QPen medianPen() const { return mMedianPen; }
  QCPScatterStyle outlierStyle() const { return mOutlierStyle; }
 
  // setters:
  void setKey(double key);
  void setMinimum(double value);
  void setLowerQuartile(double value);
  void setMedian(double value);
  void setUpperQuartile(double value);
  void setMaximum(double value);
  void setOutliers(const QVector<double> &values);
  void setData(double key, double minimum, double lowerQuartile, double median,
               double upperQuartile, double maximum);
  void setWidth(double width);
  void setWhiskerWidth(double width);
  void setWhiskerPen(const QPen &pen);
  void setWhiskerBarPen(const QPen &pen);
  void setMedianPen(const QPen &pen);
  void setOutlierStyle(const QCPScatterStyle &style);
 
  // non-property methods:
  virtual void clearData();
  virtual double selectTest(const QPointF &pos, bool onlySelectable,
                            QVariant *details = 0) const;
 
 protected:
  // property members:
  QVector<double> mOutliers;
  double mKey, mMinimum, mLowerQuartile, mMedian, mUpperQuartile, mMaximum;
  double mWidth;
  double mWhiskerWidth;
  QPen mWhiskerPen, mWhiskerBarPen, mMedianPen;
  QCPScatterStyle mOutlierStyle;
 
  // reimplemented virtual methods:
  virtual void draw(QCPPainter *painter);
  virtual void drawLegendIcon(QCPPainter *painter, const QRectF &rect) const;
  virtual QCPRange getKeyRange(bool &foundRange,
                               SignDomain inSignDomain = sdBoth) const;
  virtual QCPRange getValueRange(bool &foundRange,
                                 SignDomain inSignDomain = sdBoth) const;
 
  // introduced virtual methods:
  virtual void drawQuartileBox(QCPPainter *painter,
                               QRectF *quartileBox = 0) const;
  virtual void drawMedian(QCPPainter *painter) const;
  virtual void drawWhiskers(QCPPainter *painter) const;
  virtual void drawOutliers(QCPPainter *painter) const;
 
  friend class QCustomPlot;
  friend class QCPLegend;
};
 
class QCP_LIB_DECL QCPColorMapData {
 public:
  QCPColorMapData(int keySize, int valueSize, const QCPRange &keyRange,
                  const QCPRange &valueRange);
  ~QCPColorMapData();
  QCPColorMapData(const QCPColorMapData &other);
  QCPColorMapData &operator=(const QCPColorMapData &other);
 
  // getters:
  int keySize() const { return mKeySize; }
  int valueSize() const { return mValueSize; }
  QCPRange keyRange() const { return mKeyRange; }
  QCPRange valueRange() const { return mValueRange; }
  QCPRange dataBounds() const { return mDataBounds; }
  double data(double key, double value);
  double cell(int keyIndex, int valueIndex);
 
  // setters:
  void setSize(int keySize, int valueSize);
  void setKeySize(int keySize);
  void setValueSize(int valueSize);
  void setRange(const QCPRange &keyRange, const QCPRange &valueRange);
  void setKeyRange(const QCPRange &keyRange);
  void setValueRange(const QCPRange &valueRange);
  void setData(double key, double value, double z);
  void setCell(int keyIndex, int valueIndex, double z);
 
  // non-property methods:
  void recalculateDataBounds();
  void clear();
  void fill(double z);
  bool isEmpty() const { return mIsEmpty; }
  void coordToCell(double key, double value, int *keyIndex,
                   int *valueIndex) const;
  void cellToCoord(int keyIndex, int valueIndex, double *key,
                   double *value) const;
 
 protected:
  // property members:
  int mKeySize, mValueSize;
  QCPRange mKeyRange, mValueRange;
  bool mIsEmpty;
  // non-property members:
  double *mData;
  QCPRange mDataBounds;
  bool mDataModified;
 
  friend class QCPColorMap;
};
 
class QCP_LIB_DECL QCPColorMap : public QCPAbstractPlottable {
  Q_OBJECT
  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)
 public:
  explicit QCPColorMap(QCPAxis *keyAxis, QCPAxis *valueAxis);
  virtual ~QCPColorMap();
 
  // getters:
  QCPColorMapData *data() const { return mMapData; }
  QCPRange dataRange() const { return mDataRange; }
  QCPAxis::ScaleType dataScaleType() const { return mDataScaleType; }
  bool interpolate() const { return mInterpolate; }
  bool tightBoundary() const { return mTightBoundary; }
  QCPColorGradient gradient() const { return mGradient; }
  QCPColorScale *colorScale() const { return mColorScale.data(); }
 
  // setters:
  void setData(QCPColorMapData *data, bool copy = false);
  Q_SLOT void setDataRange(const QCPRange &dataRange);
  Q_SLOT void setDataScaleType(QCPAxis::ScaleType scaleType);
  Q_SLOT void setGradient(const QCPColorGradient &gradient);
  void setInterpolate(bool enabled);
  void setTightBoundary(bool enabled);
  void setColorScale(QCPColorScale *colorScale);
 
  // non-property methods:
  void rescaleDataRange(bool recalculateDataBounds = false);
  Q_SLOT void updateLegendIcon(
      Qt::TransformationMode transformMode = Qt::SmoothTransformation,
      const QSize &thumbSize = QSize(32, 18));
 
  // reimplemented virtual methods:
  virtual void clearData();
  virtual double selectTest(const QPointF &pos, bool onlySelectable,
                            QVariant *details = 0) const;
 
 signals:
  void dataRangeChanged(QCPRange newRange);
  void dataScaleTypeChanged(QCPAxis::ScaleType scaleType);
  void gradientChanged(QCPColorGradient newGradient);
 
 protected:
  // property members:
  QCPRange mDataRange;
  QCPAxis::ScaleType mDataScaleType;
  QCPColorMapData *mMapData;
  QCPColorGradient mGradient;
  bool mInterpolate;
  bool mTightBoundary;
  QPointer<QCPColorScale> mColorScale;
  // non-property members:
  QImage mMapImage, mUndersampledMapImage;
  QPixmap mLegendIcon;
  bool mMapImageInvalidated;
 
  // introduced virtual methods:
  virtual void updateMapImage();
 
  // reimplemented virtual methods:
  virtual void draw(QCPPainter *painter);
  virtual void drawLegendIcon(QCPPainter *painter, const QRectF &rect) const;
  virtual QCPRange getKeyRange(bool &foundRange,
                               SignDomain inSignDomain = sdBoth) const;
  virtual QCPRange getValueRange(bool &foundRange,
                                 SignDomain inSignDomain = sdBoth) const;
 
  friend class QCustomPlot;
  friend class QCPLegend;
};
 
class QCP_LIB_DECL QCPFinancialData {
 public:
  QCPFinancialData();
  QCPFinancialData(double key, double open, double high, double low,
                   double close);
  double key, open, high, low, close;
};
Q_DECLARE_TYPEINFO(QCPFinancialData, Q_MOVABLE_TYPE);
 
typedef QMap<double, QCPFinancialData> QCPFinancialDataMap;
typedef QMapIterator<double, QCPFinancialData> QCPFinancialDataMapIterator;
typedef QMutableMapIterator<double, QCPFinancialData>
    QCPFinancialDataMutableMapIterator;
 
class QCP_LIB_DECL QCPFinancial : public QCPAbstractPlottable {
  Q_OBJECT
  Q_PROPERTY(ChartStyle chartStyle READ chartStyle WRITE setChartStyle)
  Q_PROPERTY(double width READ width WRITE setWidth)
  Q_PROPERTY(bool twoColored READ twoColored WRITE setTwoColored)
  Q_PROPERTY(QBrush brushPositive READ brushPositive WRITE setBrushPositive)
  Q_PROPERTY(QBrush brushNegative READ brushNegative WRITE setBrushNegative)
  Q_PROPERTY(QPen penPositive READ penPositive WRITE setPenPositive)
  Q_PROPERTY(QPen penNegative READ penNegative WRITE setPenNegative)
 public:
  enum ChartStyle {
    csOhlc  
    ,
    csCandlestick  
  };
  Q_ENUMS(ChartStyle)
 
  explicit QCPFinancial(QCPAxis *keyAxis, QCPAxis *valueAxis);
  virtual ~QCPFinancial();
 
  // getters:
  QCPFinancialDataMap *data() const { return mData; }
  ChartStyle chartStyle() const { return mChartStyle; }
  double width() const { return mWidth; }
  bool twoColored() const { return mTwoColored; }
  QBrush brushPositive() const { return mBrushPositive; }
  QBrush brushNegative() const { return mBrushNegative; }
  QPen penPositive() const { return mPenPositive; }
  QPen penNegative() const { return mPenNegative; }
 
  // setters:
  void setData(QCPFinancialDataMap *data, bool copy = false);
  void setData(const QVector<double> &key, const QVector<double> &open,
               const QVector<double> &high, const QVector<double> &low,
               const QVector<double> &close);
  void setChartStyle(ChartStyle style);
  void setWidth(double width);
  void setTwoColored(bool twoColored);
  void setBrushPositive(const QBrush &brush);
  void setBrushNegative(const QBrush &brush);
  void setPenPositive(const QPen &pen);
  void setPenNegative(const QPen &pen);
 
  // non-property methods:
  void addData(const QCPFinancialDataMap &dataMap);
  void addData(const QCPFinancialData &data);
  void addData(double key, double open, double high, double low, double close);
  void addData(const QVector<double> &key, const QVector<double> &open,
               const QVector<double> &high, const QVector<double> &low,
               const QVector<double> &close);
  void removeDataBefore(double key);
  void removeDataAfter(double key);
  void removeData(double fromKey, double toKey);
  void removeData(double key);
 
  // reimplemented virtual methods:
  virtual void clearData();
  virtual double selectTest(const QPointF &pos, bool onlySelectable,
                            QVariant *details = 0) const;
 
  // static methods:
  static QCPFinancialDataMap timeSeriesToOhlc(const QVector<double> &time,
                                              const QVector<double> &value,
                                              double timeBinSize,
                                              double timeBinOffset = 0);
 
 protected:
  // property members:
  QCPFinancialDataMap *mData;
  ChartStyle mChartStyle;
  double mWidth;
  bool mTwoColored;
  QBrush mBrushPositive, mBrushNegative;
  QPen mPenPositive, mPenNegative;
 
  // reimplemented virtual methods:
  virtual void draw(QCPPainter *painter);
  virtual void drawLegendIcon(QCPPainter *painter, const QRectF &rect) const;
  virtual QCPRange getKeyRange(bool &foundRange,
                               SignDomain inSignDomain = sdBoth) const;
  virtual QCPRange getValueRange(bool &foundRange,
                                 SignDomain inSignDomain = sdBoth) const;
 
  // non-virtual methods:
  void drawOhlcPlot(QCPPainter *painter,
                    const QCPFinancialDataMap::const_iterator &begin,
                    const QCPFinancialDataMap::const_iterator &end);
  void drawCandlestickPlot(QCPPainter *painter,
                           const QCPFinancialDataMap::const_iterator &begin,
                           const QCPFinancialDataMap::const_iterator &end);
  double ohlcSelectTest(const QPointF &pos,
                        const QCPFinancialDataMap::const_iterator &begin,
                        const QCPFinancialDataMap::const_iterator &end) const;
  double candlestickSelectTest(
      const QPointF &pos, const QCPFinancialDataMap::const_iterator &begin,
      const QCPFinancialDataMap::const_iterator &end) const;
  void getVisibleDataBounds(QCPFinancialDataMap::const_iterator &lower,
                            QCPFinancialDataMap::const_iterator &upper) const;
 
  friend class QCustomPlot;
  friend class QCPLegend;
};
 
class QCP_LIB_DECL QCPItemStraightLine : public QCPAbstractItem {
  Q_OBJECT
  Q_PROPERTY(QPen pen READ pen WRITE setPen)
  Q_PROPERTY(QPen selectedPen READ selectedPen WRITE setSelectedPen)
 public:
  QCPItemStraightLine(QCustomPlot *parentPlot);
  virtual ~QCPItemStraightLine();
 
  // getters:
  QPen pen() const { return mPen; }
  QPen selectedPen() const { return mSelectedPen; }
 
  // setters;
  void setPen(const QPen &pen);
  void setSelectedPen(const QPen &pen);
 
  // reimplemented virtual methods:
  virtual double selectTest(const QPointF &pos, bool onlySelectable,
                            QVariant *details = 0) const;
 
  QCPItemPosition *const point1;
  QCPItemPosition *const point2;
 
 protected:
  // property members:
  QPen mPen, mSelectedPen;
 
  // reimplemented virtual methods:
  virtual void draw(QCPPainter *painter);
 
  // non-virtual methods:
  double distToStraightLine(const QVector2D &point1, const QVector2D &vec,
                            const QVector2D &point) const;
  QLineF getRectClippedStraightLine(const QVector2D &point1,
                                    const QVector2D &vec,
                                    const QRect &rect) const;
  QPen mainPen() const;
};
 
class QCP_LIB_DECL QCPItemLine : public QCPAbstractItem {
  Q_OBJECT
  Q_PROPERTY(QPen pen READ pen WRITE setPen)
  Q_PROPERTY(QPen selectedPen READ selectedPen WRITE setSelectedPen)
  Q_PROPERTY(QCPLineEnding head READ head WRITE setHead)
  Q_PROPERTY(QCPLineEnding tail READ tail WRITE setTail)
 public:
  QCPItemLine(QCustomPlot *parentPlot);
  virtual ~QCPItemLine();
 
  // getters:
  QPen pen() const { return mPen; }
  QPen selectedPen() const { return mSelectedPen; }
  QCPLineEnding head() const { return mHead; }
  QCPLineEnding tail() const { return mTail; }
 
  // setters;
  void setPen(const QPen &pen);
  void setSelectedPen(const QPen &pen);
  void setHead(const QCPLineEnding &head);
  void setTail(const QCPLineEnding &tail);
 
  // reimplemented virtual methods:
  virtual double selectTest(const QPointF &pos, bool onlySelectable,
                            QVariant *details = 0) const;
 
  QCPItemPosition *const start;
  QCPItemPosition *const end;
 
 protected:
  // property members:
  QPen mPen, mSelectedPen;
  QCPLineEnding mHead, mTail;
 
  // reimplemented virtual methods:
  virtual void draw(QCPPainter *painter);
 
  // non-virtual methods:
  QLineF getRectClippedLine(const QVector2D &start, const QVector2D &end,
                            const QRect &rect) const;
  QPen mainPen() const;
};
 
class QCP_LIB_DECL QCPItemCurve : public QCPAbstractItem {
  Q_OBJECT
  Q_PROPERTY(QPen pen READ pen WRITE setPen)
  Q_PROPERTY(QPen selectedPen READ selectedPen WRITE setSelectedPen)
  Q_PROPERTY(QCPLineEnding head READ head WRITE setHead)
  Q_PROPERTY(QCPLineEnding tail READ tail WRITE setTail)
 public:
  QCPItemCurve(QCustomPlot *parentPlot);
  virtual ~QCPItemCurve();
 
  // getters:
  QPen pen() const { return mPen; }
  QPen selectedPen() const { return mSelectedPen; }
  QCPLineEnding head() const { return mHead; }
  QCPLineEnding tail() const { return mTail; }
 
  // setters;
  void setPen(const QPen &pen);
  void setSelectedPen(const QPen &pen);
  void setHead(const QCPLineEnding &head);
  void setTail(const QCPLineEnding &tail);
 
  // reimplemented virtual methods:
  virtual double selectTest(const QPointF &pos, bool onlySelectable,
                            QVariant *details = 0) const;
 
  QCPItemPosition *const start;
  QCPItemPosition *const startDir;
  QCPItemPosition *const endDir;
  QCPItemPosition *const end;
 
 protected:
  // property members:
  QPen mPen, mSelectedPen;
  QCPLineEnding mHead, mTail;
 
  // reimplemented virtual methods:
  virtual void draw(QCPPainter *painter);
 
  // non-virtual methods:
  QPen mainPen() const;
};
 
class QCP_LIB_DECL QCPItemRect : public QCPAbstractItem {
  Q_OBJECT
  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)
 public:
  QCPItemRect(QCustomPlot *parentPlot);
  virtual ~QCPItemRect();
 
  // getters:
  QPen pen() const { return mPen; }
  QPen selectedPen() const { return mSelectedPen; }
  QBrush brush() const { return mBrush; }
  QBrush selectedBrush() const { return mSelectedBrush; }
 
  // setters;
  void setPen(const QPen &pen);
  void setSelectedPen(const QPen &pen);
  void setBrush(const QBrush &brush);
  void setSelectedBrush(const QBrush &brush);
 
  // reimplemented virtual methods:
  virtual double selectTest(const QPointF &pos, bool onlySelectable,
                            QVariant *details = 0) const;
 
  QCPItemPosition *const topLeft;
  QCPItemPosition *const bottomRight;
  QCPItemAnchor *const top;
  QCPItemAnchor *const topRight;
  QCPItemAnchor *const right;
  QCPItemAnchor *const bottom;
  QCPItemAnchor *const bottomLeft;
  QCPItemAnchor *const left;
 
 protected:
  enum AnchorIndex {
    aiTop,
    aiTopRight,
    aiRight,
    aiBottom,
    aiBottomLeft,
    aiLeft
  };
 
  // property members:
  QPen mPen, mSelectedPen;
  QBrush mBrush, mSelectedBrush;
 
  // reimplemented virtual methods:
  virtual void draw(QCPPainter *painter);
  virtual QPointF anchorPixelPoint(int anchorId) const;
 
  // non-virtual methods:
  QPen mainPen() const;
  QBrush mainBrush() const;
};
 
class QCP_LIB_DECL QCPItemText : public QCPAbstractItem {
  Q_OBJECT
  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)
 public:
  QCPItemText(QCustomPlot *parentPlot);
  virtual ~QCPItemText();
 
  // getters:
  QColor color() const { return mColor; }
  QColor selectedColor() const { return mSelectedColor; }
  QPen pen() const { return mPen; }
  QPen selectedPen() const { return mSelectedPen; }
  QBrush brush() const { return mBrush; }
  QBrush selectedBrush() const { return mSelectedBrush; }
  QFont font() const { return mFont; }
  QFont selectedFont() const { return mSelectedFont; }
  QString text() const { return mText; }
  Qt::Alignment positionAlignment() const { return mPositionAlignment; }
  Qt::Alignment textAlignment() const { return mTextAlignment; }
  double rotation() const { return mRotation; }
  QMargins padding() const { return mPadding; }
 
  // setters;
  void setColor(const QColor &color);
  void setSelectedColor(const QColor &color);
  void setPen(const QPen &pen);
  void setSelectedPen(const QPen &pen);
  void setBrush(const QBrush &brush);
  void setSelectedBrush(const QBrush &brush);
  void setFont(const QFont &font);
  void setSelectedFont(const QFont &font);
  void setText(const QString &text);
  void setPositionAlignment(Qt::Alignment alignment);
  void setTextAlignment(Qt::Alignment alignment);
  void setRotation(double degrees);
  void setPadding(const QMargins &padding);
 
  // reimplemented virtual methods:
  virtual double selectTest(const QPointF &pos, bool onlySelectable,
                            QVariant *details = 0) const;
 
  QCPItemPosition *const position;
  QCPItemAnchor *const topLeft;
  QCPItemAnchor *const top;
  QCPItemAnchor *const topRight;
  QCPItemAnchor *const right;
  QCPItemAnchor *const bottomRight;
  QCPItemAnchor *const bottom;
  QCPItemAnchor *const bottomLeft;
  QCPItemAnchor *const left;
 
 protected:
  enum AnchorIndex {
    aiTopLeft,
    aiTop,
    aiTopRight,
    aiRight,
    aiBottomRight,
    aiBottom,
    aiBottomLeft,
    aiLeft
  };
 
  // property members:
  QColor mColor, mSelectedColor;
  QPen mPen, mSelectedPen;
  QBrush mBrush, mSelectedBrush;
  QFont mFont, mSelectedFont;
  QString mText;
  Qt::Alignment mPositionAlignment;
  Qt::Alignment mTextAlignment;
  double mRotation;
  QMargins mPadding;
 
  // reimplemented virtual methods:
  virtual void draw(QCPPainter *painter);
  virtual QPointF anchorPixelPoint(int anchorId) const;
 
  // non-virtual methods:
  QPointF getTextDrawPoint(const QPointF &pos, const QRectF &rect,
                           Qt::Alignment positionAlignment) const;
  QFont mainFont() const;
  QColor mainColor() const;
  QPen mainPen() const;
  QBrush mainBrush() const;
};
 
class QCP_LIB_DECL QCPItemEllipse : public QCPAbstractItem {
  Q_OBJECT
  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)
 public:
  QCPItemEllipse(QCustomPlot *parentPlot);
  virtual ~QCPItemEllipse();
 
  // getters:
  QPen pen() const { return mPen; }
  QPen selectedPen() const { return mSelectedPen; }
  QBrush brush() const { return mBrush; }
  QBrush selectedBrush() const { return mSelectedBrush; }
 
  // setters;
  void setPen(const QPen &pen);
  void setSelectedPen(const QPen &pen);
  void setBrush(const QBrush &brush);
  void setSelectedBrush(const QBrush &brush);
 
  // reimplemented virtual methods:
  virtual double selectTest(const QPointF &pos, bool onlySelectable,
                            QVariant *details = 0) const;
 
  QCPItemPosition *const topLeft;
  QCPItemPosition *const bottomRight;
  QCPItemAnchor *const topLeftRim;
  QCPItemAnchor *const top;
  QCPItemAnchor *const topRightRim;
  QCPItemAnchor *const right;
  QCPItemAnchor *const bottomRightRim;
  QCPItemAnchor *const bottom;
  QCPItemAnchor *const bottomLeftRim;
  QCPItemAnchor *const left;
  QCPItemAnchor *const center;
 
 protected:
  enum AnchorIndex {
    aiTopLeftRim,
    aiTop,
    aiTopRightRim,
    aiRight,
    aiBottomRightRim,
    aiBottom,
    aiBottomLeftRim,
    aiLeft,
    aiCenter
  };
 
  // property members:
  QPen mPen, mSelectedPen;
  QBrush mBrush, mSelectedBrush;
 
  // reimplemented virtual methods:
  virtual void draw(QCPPainter *painter);
  virtual QPointF anchorPixelPoint(int anchorId) const;
 
  // non-virtual methods:
  QPen mainPen() const;
  QBrush mainBrush() const;
};
 
class QCP_LIB_DECL QCPItemPixmap : public QCPAbstractItem {
  Q_OBJECT
  Q_PROPERTY(QPixmap pixmap READ pixmap WRITE setPixmap)
  Q_PROPERTY(bool scaled READ scaled WRITE setScaled)
  Q_PROPERTY(Qt::AspectRatioMode aspectRatioMode READ aspectRatioMode)
  Q_PROPERTY(Qt::TransformationMode transformationMode READ transformationMode)
  Q_PROPERTY(QPen pen READ pen WRITE setPen)
  Q_PROPERTY(QPen selectedPen READ selectedPen WRITE setSelectedPen)
 public:
  QCPItemPixmap(QCustomPlot *parentPlot);
  virtual ~QCPItemPixmap();
 
  // getters:
  QPixmap pixmap() const { return mPixmap; }
  bool scaled() const { return mScaled; }
  Qt::AspectRatioMode aspectRatioMode() const { return mAspectRatioMode; }
  Qt::TransformationMode transformationMode() const {
    return mTransformationMode;
  }
  QPen pen() const { return mPen; }
  QPen selectedPen() const { return mSelectedPen; }
 
  // setters;
  void setPixmap(const QPixmap &pixmap);
  void setScaled(
      bool scaled, Qt::AspectRatioMode aspectRatioMode = Qt::KeepAspectRatio,
      Qt::TransformationMode transformationMode = Qt::SmoothTransformation);
  void setPen(const QPen &pen);
  void setSelectedPen(const QPen &pen);
 
  // reimplemented virtual methods:
  virtual double selectTest(const QPointF &pos, bool onlySelectable,
                            QVariant *details = 0) const;
 
  QCPItemPosition *const topLeft;
  QCPItemPosition *const bottomRight;
  QCPItemAnchor *const top;
  QCPItemAnchor *const topRight;
  QCPItemAnchor *const right;
  QCPItemAnchor *const bottom;
  QCPItemAnchor *const bottomLeft;
  QCPItemAnchor *const left;
 
 protected:
  enum AnchorIndex {
    aiTop,
    aiTopRight,
    aiRight,
    aiBottom,
    aiBottomLeft,
    aiLeft
  };
 
  // property members:
  QPixmap mPixmap;
  QPixmap mScaledPixmap;
  bool mScaled;
  bool mScaledPixmapInvalidated;
  Qt::AspectRatioMode mAspectRatioMode;
  Qt::TransformationMode mTransformationMode;
  QPen mPen, mSelectedPen;
 
  // reimplemented virtual methods:
  virtual void draw(QCPPainter *painter);
  virtual QPointF anchorPixelPoint(int anchorId) const;
 
  // non-virtual methods:
  void updateScaledPixmap(QRect finalRect = QRect(), bool flipHorz = false,
                          bool flipVert = false);
  QRect getFinalRect(bool *flippedHorz = 0, bool *flippedVert = 0) const;
  QPen mainPen() const;
};
 
class QCP_LIB_DECL QCPItemTracer : public QCPAbstractItem {
  Q_OBJECT
  Q_PROPERTY(QPen pen READ pen WRITE setPen)
  Q_PROPERTY(QPen selectedPen READ selectedPen WRITE setSelectedPen)
  Q_PROPERTY(QBrush brush READ brush WRITE setBrush)
  Q_PROPERTY(QBrush selectedBrush READ selectedBrush WRITE setSelectedBrush)
  Q_PROPERTY(double size READ size WRITE setSize)
  Q_PROPERTY(TracerStyle style READ style WRITE setStyle)
  Q_PROPERTY(QCPGraph *graph READ graph WRITE setGraph)
  Q_PROPERTY(double graphKey READ graphKey WRITE setGraphKey)
  Q_PROPERTY(bool interpolating READ interpolating WRITE setInterpolating)
 public:
  enum TracerStyle {
    tsNone  
    ,
    tsPlus  
    ,
    tsCrosshair  
    ,
    tsCircle  
    ,
    tsSquare  
  };
  Q_ENUMS(TracerStyle)
 
  QCPItemTracer(QCustomPlot *parentPlot);
  virtual ~QCPItemTracer();
 
  // getters:
  QPen pen() const { return mPen; }
  QPen selectedPen() const { return mSelectedPen; }
  QBrush brush() const { return mBrush; }
  QBrush selectedBrush() const { return mSelectedBrush; }
  double size() const { return mSize; }
  TracerStyle style() const { return mStyle; }
  QCPGraph *graph() const { return mGraph; }
  double graphKey() const { return mGraphKey; }
  bool interpolating() const { return mInterpolating; }
 
  // setters;
  void setPen(const QPen &pen);
  void setSelectedPen(const QPen &pen);
  void setBrush(const QBrush &brush);
  void setSelectedBrush(const QBrush &brush);
  void setSize(double size);
  void setStyle(TracerStyle style);
  void setGraph(QCPGraph *graph);
  void setGraphKey(double key);
  void setInterpolating(bool enabled);
 
  // reimplemented virtual methods:
  virtual double selectTest(const QPointF &pos, bool onlySelectable,
                            QVariant *details = 0) const;
 
  // non-virtual methods:
  void updatePosition();
 
  QCPItemPosition *const position;
 
 protected:
  // property members:
  QPen mPen, mSelectedPen;
  QBrush mBrush, mSelectedBrush;
  double mSize;
  TracerStyle mStyle;
  QCPGraph *mGraph;
  double mGraphKey;
  bool mInterpolating;
 
  // reimplemented virtual methods:
  virtual void draw(QCPPainter *painter);
 
  // non-virtual methods:
  QPen mainPen() const;
  QBrush mainBrush() const;
};
 
class QCP_LIB_DECL QCPItemBracket : public QCPAbstractItem {
  Q_OBJECT
  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)
 public:
  enum BracketStyle {
    bsSquare  
    ,
    bsRound  
    ,
    bsCurly  
    ,
    bsCalligraphic  
  };
 
  QCPItemBracket(QCustomPlot *parentPlot);
  virtual ~QCPItemBracket();
 
  // getters:
  QPen pen() const { return mPen; }
  QPen selectedPen() const { return mSelectedPen; }
  double length() const { return mLength; }
  BracketStyle style() const { return mStyle; }
 
  // setters;
  void setPen(const QPen &pen);
  void setSelectedPen(const QPen &pen);
  void setLength(double length);
  void setStyle(BracketStyle style);
 
  // reimplemented virtual methods:
  virtual double selectTest(const QPointF &pos, bool onlySelectable,
                            QVariant *details = 0) const;
 
  QCPItemPosition *const left;
  QCPItemPosition *const right;
  QCPItemAnchor *const center;
 
 protected:
  // property members:
  enum AnchorIndex { aiCenter };
  QPen mPen, mSelectedPen;
  double mLength;
  BracketStyle mStyle;
 
  // reimplemented virtual methods:
  virtual void draw(QCPPainter *painter);
  virtual QPointF anchorPixelPoint(int anchorId) const;
 
  // non-virtual methods:
  QPen mainPen() const;
};
 
#endif  // QCUSTOMPLOT_H