Head

GCC Code Coverage Report
Directory:	./		Exec	Total	Coverage
File:	plugins/pyqcustomplot/qcustomplot.cpp	Lines:	0	9132	0.0 %
Date:	2023-03-14 11:04:37	Branches:	0	14589	0.0 %

/***************************************************************************
**                                                                        **
**  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                                                **
****************************************************************************/

#include "qcustomplot.h"

////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////// QCPPainter
////////////////////////////////////////////////////////////////////////////////////////////////////

/*! \class QCPPainter
  \brief QPainter subclass used internally

  This QPainter subclass is used to provide some extended functionality e.g. for
  tweaking position consistency between antialiased and non-antialiased
  painting. Further it provides workarounds for QPainter quirks.

  \warning This class intentionally hides non-virtual functions of QPainter,
  e.g. setPen, save and restore. So while it is possible to pass a QCPPainter
  instance to a function that expects a QPainter pointer, some of the
  workarounds and tweaks will be unavailable to the function (because it will
  call the base class implementations of the functions actually hidden by
  QCPPainter).
*/

/*!
  Creates a new QCPPainter instance and sets default values
*/
QCPPainter::QCPPainter()
    : QPainter(), mModes(pmDefault), mIsAntialiasing(false) {
  // don't setRenderHint(QPainter::NonCosmeticDefautPen) here, because painter
  // isn't active yet and a call to begin() will follow
}

/*!
  Creates a new QCPPainter instance on the specified paint \a device and sets
  default values. Just like the analogous QPainter constructor, begins painting
  on \a device immediately.

  Like \ref begin, this method sets QPainter::NonCosmeticDefaultPen in Qt
  versions before Qt5.
*/
QCPPainter::QCPPainter(QPaintDevice *device)
    : QPainter(device), mModes(pmDefault), mIsAntialiasing(false) {
#if QT_VERSION <           \
    QT_VERSION_CHECK(5, 0, \
                     0)  // before Qt5, default pens used to be cosmetic if
                         // NonCosmeticDefaultPen flag isn't set. So we set it
                         // to get consistency across Qt versions.
  if (isActive()) setRenderHint(QPainter::NonCosmeticDefaultPen);
#endif
}

QCPPainter::~QCPPainter() {}

/*!
  Sets the pen of the painter and applies certain fixes to it, depending on the
  mode of this QCPPainter.

  \note this function hides the non-virtual base class implementation.
*/
void QCPPainter::setPen(const QPen &pen) {
  QPainter::setPen(pen);
  if (mModes.testFlag(pmNonCosmetic)) makeNonCosmetic();
}

/*! \overload

  Sets the pen (by color) of the painter and applies certain fixes to it,
  depending on the mode of this QCPPainter.

  \note this function hides the non-virtual base class implementation.
*/
void QCPPainter::setPen(const QColor &color) {
  QPainter::setPen(color);
  if (mModes.testFlag(pmNonCosmetic)) makeNonCosmetic();
}

/*! \overload

  Sets the pen (by style) of the painter and applies certain fixes to it,
  depending on the mode of this QCPPainter.

  \note this function hides the non-virtual base class implementation.
*/
void QCPPainter::setPen(Qt::PenStyle penStyle) {
  QPainter::setPen(penStyle);
  if (mModes.testFlag(pmNonCosmetic)) makeNonCosmetic();
}

/*! \overload

  Works around a Qt bug introduced with Qt 4.8 which makes drawing QLineF
  unpredictable when antialiasing is disabled. Thus when antialiasing is
  disabled, it rounds the \a line to integer coordinates and then passes it to
  the original drawLine.

  \note this function hides the non-virtual base class implementation.
*/
void QCPPainter::drawLine(const QLineF &line) {
  if (mIsAntialiasing || mModes.testFlag(pmVectorized))
    QPainter::drawLine(line);
  else
    QPainter::drawLine(line.toLine());
}

/*!
  Sets whether painting uses antialiasing or not. Use this method instead of
  using setRenderHint with QPainter::Antialiasing directly, as it allows
  QCPPainter to regain pixel exactness between antialiased and non-antialiased
  painting (Since Qt < 5.0 uses slightly different coordinate systems for
  AA/Non-AA painting).
*/
void QCPPainter::setAntialiasing(bool enabled) {
  setRenderHint(QPainter::Antialiasing, enabled);
  if (mIsAntialiasing != enabled) {
    mIsAntialiasing = enabled;
    if (!mModes.testFlag(pmVectorized))  // antialiasing half-pixel shift only
                                         // needed for rasterized outputs
    {
      if (mIsAntialiasing)
        translate(0.5, 0.5);
      else
        translate(-0.5, -0.5);
    }
  }
}

/*!
  Sets the mode of the painter. This controls whether the painter shall adjust
  its fixes/workarounds optimized for certain output devices.
*/
void QCPPainter::setModes(QCPPainter::PainterModes modes) { mModes = modes; }

/*!
  Sets the QPainter::NonCosmeticDefaultPen in Qt versions before Qt5 after
  beginning painting on \a device. This is necessary to get cosmetic pen
  consistency across Qt versions, because since Qt5, all pens are non-cosmetic
  by default, and in Qt4 this render hint must be set to get that behaviour.

  The Constructor \ref QCPPainter(QPaintDevice *device) which directly starts
  painting also sets the render hint as appropriate.

  \note this function hides the non-virtual base class implementation.
*/
bool QCPPainter::begin(QPaintDevice *device) {
  bool result = QPainter::begin(device);
#if QT_VERSION <           \
    QT_VERSION_CHECK(5, 0, \
                     0)  // before Qt5, default pens used to be cosmetic if
                         // NonCosmeticDefaultPen flag isn't set. So we set it
                         // to get consistency across Qt versions.
  if (result) setRenderHint(QPainter::NonCosmeticDefaultPen);
#endif
  return result;
}

/*! \overload

  Sets the mode of the painter. This controls whether the painter shall adjust
  its fixes/workarounds optimized for certain output devices.
*/
void QCPPainter::setMode(QCPPainter::PainterMode mode, bool enabled) {
  if (!enabled && mModes.testFlag(mode))
    mModes &= ~mode;
  else if (enabled && !mModes.testFlag(mode))
    mModes |= mode;
}

/*!
  Saves the painter (see QPainter::save). Since QCPPainter adds some new
  internal state to QPainter, the save/restore functions are reimplemented to
  also save/restore those members.

  \note this function hides the non-virtual base class implementation.

  \see restore
*/
void QCPPainter::save() {
  mAntialiasingStack.push(mIsAntialiasing);
  QPainter::save();
}

/*!
  Restores the painter (see QPainter::restore). Since QCPPainter adds some new
  internal state to QPainter, the save/restore functions are reimplemented to
  also save/restore those members.

  \note this function hides the non-virtual base class implementation.

  \see save
*/
void QCPPainter::restore() {
  if (!mAntialiasingStack.isEmpty())
    mIsAntialiasing = mAntialiasingStack.pop();
  else
    qDebug() << Q_FUNC_INFO << "Unbalanced save/restore";
  QPainter::restore();
}

/*!
  Changes the pen width to 1 if it currently is 0. This function is called in
  the \ref setPen overrides when the \ref pmNonCosmetic mode is set.
*/
void QCPPainter::makeNonCosmetic() {
  if (qFuzzyIsNull(pen().widthF())) {
    QPen p = pen();
    p.setWidth(1);
    QPainter::setPen(p);
  }
}

////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////// QCPScatterStyle
////////////////////////////////////////////////////////////////////////////////////////////////////

/*! \class QCPScatterStyle
  \brief Represents the visual appearance of scatter points

  This class holds information about shape, color and size of scatter points. In
  plottables like QCPGraph it is used to store how scatter points shall be
  drawn. For example, \ref QCPGraph::setScatterStyle takes a QCPScatterStyle
  instance.

  A scatter style consists of a shape (\ref setShape), a line color (\ref
  setPen) and possibly a fill (\ref setBrush), if the shape provides a fillable
  area. Further, the size of the shape can be controlled with \ref setSize.

  \section QCPScatterStyle-defining Specifying a scatter style

  You can set all these configurations either by calling the respective
  functions on an instance: \snippet
  documentation/doc-code-snippets/mainwindow.cpp qcpscatterstyle-creation-1

  Or you can use one of the various constructors that take different parameter
  combinations, making it easy to specify a scatter style in a single call, like
  so: \snippet documentation/doc-code-snippets/mainwindow.cpp
  qcpscatterstyle-creation-2

  \section QCPScatterStyle-undefinedpen Leaving the color/pen up to the
  plottable

  There are two constructors which leave the pen undefined: \ref
  QCPScatterStyle() and \ref QCPScatterStyle(ScatterShape shape, double size).
  If those constructors are used, a call to \ref isPenDefined will return false.
  It leads to scatter points that inherit the pen from the plottable that uses
  the scatter style. Thus, if such a scatter style is passed to QCPGraph, the
  line color of the graph (\ref QCPGraph::setPen) will be used by the scatter
  points. This makes it very convenient to set up typical scatter settings:

  \snippet documentation/doc-code-snippets/mainwindow.cpp
  qcpscatterstyle-shortcreation

  Notice that it wasn't even necessary to explicitly call a QCPScatterStyle
  constructor. This works because QCPScatterStyle provides a constructor that
  can transform a \ref ScatterShape directly into a QCPScatterStyle instance
  (that's the \ref QCPScatterStyle(ScatterShape shape, double size) constructor
  with a default for \a size). In those cases, C++ allows directly supplying a
  \ref ScatterShape, where actually a QCPScatterStyle is expected.

  \section QCPScatterStyle-custompath-and-pixmap Custom shapes and pixmaps

  QCPScatterStyle supports drawing custom shapes and arbitrary pixmaps as
  scatter points.

  For custom shapes, you can provide a QPainterPath with the desired shape to
  the \ref setCustomPath function or call the constructor that takes a painter
  path. The scatter shape will automatically be set to \ref ssCustom.

  For pixmaps, you call \ref setPixmap with the desired QPixmap. Alternatively
  you can use the constructor that takes a QPixmap. The scatter shape will
  automatically be set to \ref ssPixmap. Note that \ref setSize does not
  influence the appearance of the pixmap.
*/

/* start documentation of inline functions */

/*! \fn bool QCPScatterStyle::isNone() const

  Returns whether the scatter shape is \ref ssNone.

  \see setShape
*/

/*! \fn bool QCPScatterStyle::isPenDefined() const

  Returns whether a pen has been defined for this scatter style.

  The pen is undefined if a constructor is called that does not carry \a pen as
  parameter. Those are \ref QCPScatterStyle() and \ref
  QCPScatterStyle(ScatterShape shape, double size). If the pen is left
  undefined, the scatter color will be inherited from the plottable that uses
  this scatter style.

  \see setPen
*/

/* end documentation of inline functions */

/*!
  Creates a new QCPScatterStyle instance with size set to 6. No shape, pen or
  brush is defined.

  Since the pen is undefined (\ref isPenDefined returns false), the scatter
  color will be inherited from the plottable that uses this scatter style.
*/
QCPScatterStyle::QCPScatterStyle()
    : mSize(6),
      mShape(ssNone),
      mPen(Qt::NoPen),
      mBrush(Qt::NoBrush),
      mPenDefined(false) {}

/*!
  Creates a new QCPScatterStyle instance with shape set to \a shape and size to
  \a size. No pen or brush is defined.

  Since the pen is undefined (\ref isPenDefined returns false), the scatter
  color will be inherited from the plottable that uses this scatter style.
*/
QCPScatterStyle::QCPScatterStyle(ScatterShape shape, double size)
    : mSize(size),
      mShape(shape),
      mPen(Qt::NoPen),
      mBrush(Qt::NoBrush),
      mPenDefined(false) {}

/*!
  Creates a new QCPScatterStyle instance with shape set to \a shape, the pen
  color set to \a color, and size to \a size. No brush is defined, i.e. the
  scatter point will not be filled.
*/
QCPScatterStyle::QCPScatterStyle(ScatterShape shape, const QColor &color,
                                 double size)
    : mSize(size),
      mShape(shape),
      mPen(QPen(color)),
      mBrush(Qt::NoBrush),
      mPenDefined(true) {}

/*!
  Creates a new QCPScatterStyle instance with shape set to \a shape, the pen
  color set to \a color, the brush color to \a fill (with a solid pattern), and
  size to \a size.
*/
QCPScatterStyle::QCPScatterStyle(ScatterShape shape, const QColor &color,
                                 const QColor &fill, double size)
    : mSize(size),
      mShape(shape),
      mPen(QPen(color)),
      mBrush(QBrush(fill)),
      mPenDefined(true) {}

/*!
  Creates a new QCPScatterStyle instance with shape set to \a shape, the pen set
  to \a pen, the brush to \a brush, and size to \a size.

  \warning In some cases it might be tempting to directly use a pen style like
  <tt>Qt::NoPen</tt> as \a pen and a color like <tt>Qt::blue</tt> as \a brush.
  Notice however, that the corresponding call\n
  <tt>QCPScatterStyle(QCPScatterShape::ssCircle, Qt::NoPen, Qt::blue, 5)</tt>\n
  doesn't necessarily lead C++ to use this constructor in some cases, but might
  mistake <tt>Qt::NoPen</tt> for a QColor and use the \ref
  QCPScatterStyle(ScatterShape shape, const QColor &color, const QColor &fill,
  double size) constructor instead (which will lead to an unexpected look of the
  scatter points). To prevent this, be more explicit with the parameter types.
  For example, use <tt>QBrush(Qt::blue)</tt> instead of just <tt>Qt::blue</tt>,
  to clearly point out to the compiler that this constructor is wanted.
*/
QCPScatterStyle::QCPScatterStyle(ScatterShape shape, const QPen &pen,
                                 const QBrush &brush, double size)
    : mSize(size),
      mShape(shape),
      mPen(pen),
      mBrush(brush),
      mPenDefined(pen.style() != Qt::NoPen) {}

/*!
  Creates a new QCPScatterStyle instance which will show the specified \a
  pixmap. The scatter shape is set to \ref ssPixmap.
*/
QCPScatterStyle::QCPScatterStyle(const QPixmap &pixmap)
    : mSize(5),
      mShape(ssPixmap),
      mPen(Qt::NoPen),
      mBrush(Qt::NoBrush),
      mPixmap(pixmap),
      mPenDefined(false) {}

/*!
  Creates a new QCPScatterStyle instance with a custom shape that is defined via
  \a customPath. The scatter shape is set to \ref ssCustom.

  The custom shape line will be drawn with \a pen and filled with \a brush. The
  size has a slightly different meaning than for built-in scatter points: The
  custom path will be drawn scaled by a factor of \a size/6.0. Since the default
  \a size is 6, the custom path will appear at a its natural size by default. To
  double the size of the path for example, set \a size to 12.
*/
QCPScatterStyle::QCPScatterStyle(const QPainterPath &customPath,
                                 const QPen &pen, const QBrush &brush,
                                 double size)
    : mSize(size),
      mShape(ssCustom),
      mPen(pen),
      mBrush(brush),
      mCustomPath(customPath),
      mPenDefined(pen.style() != Qt::NoPen) {}

/*!
  Sets the size (pixel diameter) of the drawn scatter points to \a size.

  \see setShape
*/
void QCPScatterStyle::setSize(double size) { mSize = size; }

/*!
  Sets the shape to \a shape.

  Note that the calls \ref setPixmap and \ref setCustomPath automatically set
  the shape to \ref ssPixmap and \ref ssCustom, respectively.

  \see setSize
*/
void QCPScatterStyle::setShape(QCPScatterStyle::ScatterShape shape) {
  mShape = shape;
}

/*!
  Sets the pen that will be used to draw scatter points to \a pen.

  If the pen was previously undefined (see \ref isPenDefined), the pen is
  considered defined after a call to this function, even if \a pen is
  <tt>Qt::NoPen</tt>.

  \see setBrush
*/
void QCPScatterStyle::setPen(const QPen &pen) {
  mPenDefined = true;
  mPen = pen;
}

/*!
  Sets the brush that will be used to fill scatter points to \a brush. Note that
  not all scatter shapes have fillable areas. For example, \ref ssPlus does not
  while \ref ssCircle does.

  \see setPen
*/
void QCPScatterStyle::setBrush(const QBrush &brush) { mBrush = brush; }

/*!
  Sets the pixmap that will be drawn as scatter point to \a pixmap.

  Note that \ref setSize does not influence the appearance of the pixmap.

  The scatter shape is automatically set to \ref ssPixmap.
*/
void QCPScatterStyle::setPixmap(const QPixmap &pixmap) {
  setShape(ssPixmap);
  mPixmap = pixmap;
}

/*!
  Sets the custom shape that will be drawn as scatter point to \a customPath.

  The scatter shape is automatically set to \ref ssCustom.
*/
void QCPScatterStyle::setCustomPath(const QPainterPath &customPath) {
  setShape(ssCustom);
  mCustomPath = customPath;
}

/*!
  Applies the pen and the brush of this scatter style to \a painter. If this
  scatter style has an undefined pen (\ref isPenDefined), sets the pen of \a
  painter to \a defaultPen instead.

  This function is used by plottables (or any class that wants to draw scatters)
  just before a number of scatters with this style shall be drawn with the \a
  painter.

  \see drawShape
*/
void QCPScatterStyle::applyTo(QCPPainter *painter,
                              const QPen &defaultPen) const {
  painter->setPen(mPenDefined ? mPen : defaultPen);
  painter->setBrush(mBrush);
}

/*!
  Draws the scatter shape with \a painter at position \a pos.

  This function does not modify the pen or the brush on the painter, as \ref
  applyTo is meant to be called before scatter points are drawn with \ref
  drawShape.

  \see applyTo
*/
void QCPScatterStyle::drawShape(QCPPainter *painter, QPointF pos) const {
  drawShape(painter, pos.x(), pos.y());
}

/*! \overload
  Draws the scatter shape with \a painter at position \a x and \a y.
*/
void QCPScatterStyle::drawShape(QCPPainter *painter, double x, double y) const {
  double w = mSize / 2.0;
  switch (mShape) {
    case ssNone:
      break;
    case ssDot: {
      painter->drawLine(QPointF(x, y), QPointF(x + 0.0001, y));
      break;
    }
    case ssCross: {
      painter->drawLine(QLineF(x - w, y - w, x + w, y + w));
      painter->drawLine(QLineF(x - w, y + w, x + w, y - w));
      break;
    }
    case ssPlus: {
      painter->drawLine(QLineF(x - w, y, x + w, y));
      painter->drawLine(QLineF(x, y + w, x, y - w));
      break;
    }
    case ssCircle: {
      painter->drawEllipse(QPointF(x, y), w, w);
      break;
    }
    case ssDisc: {
      QBrush b = painter->brush();
      painter->setBrush(painter->pen().color());
      painter->drawEllipse(QPointF(x, y), w, w);
      painter->setBrush(b);
      break;
    }
    case ssSquare: {
      painter->drawRect(QRectF(x - w, y - w, mSize, mSize));
      break;
    }
    case ssDiamond: {
      painter->drawLine(QLineF(x - w, y, x, y - w));
      painter->drawLine(QLineF(x, y - w, x + w, y));
      painter->drawLine(QLineF(x + w, y, x, y + w));
      painter->drawLine(QLineF(x, y + w, x - w, y));
      break;
    }
    case ssStar: {
      painter->drawLine(QLineF(x - w, y, x + w, y));
      painter->drawLine(QLineF(x, y + w, x, y - w));
      painter->drawLine(
          QLineF(x - w * 0.707, y - w * 0.707, x + w * 0.707, y + w * 0.707));
      painter->drawLine(
          QLineF(x - w * 0.707, y + w * 0.707, x + w * 0.707, y - w * 0.707));
      break;
    }
    case ssTriangle: {
      painter->drawLine(QLineF(x - w, y + 0.755 * w, x + w, y + 0.755 * w));
      painter->drawLine(QLineF(x + w, y + 0.755 * w, x, y - 0.977 * w));
      painter->drawLine(QLineF(x, y - 0.977 * w, x - w, y + 0.755 * w));
      break;
    }
    case ssTriangleInverted: {
      painter->drawLine(QLineF(x - w, y - 0.755 * w, x + w, y - 0.755 * w));
      painter->drawLine(QLineF(x + w, y - 0.755 * w, x, y + 0.977 * w));
      painter->drawLine(QLineF(x, y + 0.977 * w, x - w, y - 0.755 * w));
      break;
    }
    case ssCrossSquare: {
      painter->drawLine(QLineF(x - w, y - w, x + w * 0.95, y + w * 0.95));
      painter->drawLine(QLineF(x - w, y + w * 0.95, x + w * 0.95, y - w));
      painter->drawRect(QRectF(x - w, y - w, mSize, mSize));
      break;
    }
    case ssPlusSquare: {
      painter->drawLine(QLineF(x - w, y, x + w * 0.95, y));
      painter->drawLine(QLineF(x, y + w, x, y - w));
      painter->drawRect(QRectF(x - w, y - w, mSize, mSize));
      break;
    }
    case ssCrossCircle: {
      painter->drawLine(
          QLineF(x - w * 0.707, y - w * 0.707, x + w * 0.670, y + w * 0.670));
      painter->drawLine(
          QLineF(x - w * 0.707, y + w * 0.670, x + w * 0.670, y - w * 0.707));
      painter->drawEllipse(QPointF(x, y), w, w);
      break;
    }
    case ssPlusCircle: {
      painter->drawLine(QLineF(x - w, y, x + w, y));
      painter->drawLine(QLineF(x, y + w, x, y - w));
      painter->drawEllipse(QPointF(x, y), w, w);
      break;
    }
    case ssPeace: {
      painter->drawLine(QLineF(x, y - w, x, y + w));
      painter->drawLine(QLineF(x, y, x - w * 0.707, y + w * 0.707));
      painter->drawLine(QLineF(x, y, x + w * 0.707, y + w * 0.707));
      painter->drawEllipse(QPointF(x, y), w, w);
      break;
    }
    case ssPixmap: {
      painter->drawPixmap(x - mPixmap.width() * 0.5, y - mPixmap.height() * 0.5,
                          mPixmap);
      break;
    }
    case ssCustom: {
      QTransform oldTransform = painter->transform();
      painter->translate(x, y);
      painter->scale(mSize / 6.0, mSize / 6.0);
      painter->drawPath(mCustomPath);
      painter->setTransform(oldTransform);
      break;
    }
  }
}

////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////// QCPLayer
////////////////////////////////////////////////////////////////////////////////////////////////////

/*! \class QCPLayer
  \brief A layer that may contain objects, to control the rendering order

  The Layering system of QCustomPlot is the mechanism to control the rendering
  order of the elements inside the plot.

  It is based on the two classes QCPLayer and QCPLayerable. QCustomPlot holds an
  ordered list of one or more instances of QCPLayer (see QCustomPlot::addLayer,
  QCustomPlot::layer, QCustomPlot::moveLayer, etc.). When replotting,
  QCustomPlot goes through the list of layers bottom to top and successively
  draws the layerables of the layers.

  A QCPLayer contains an ordered list of QCPLayerable instances. QCPLayerable is
  an abstract base class from which almost all visible objects derive, like
  axes, grids, graphs, items, etc.

  Initially, QCustomPlot has five layers: "background", "grid", "main", "axes"
  and "legend" (in that order). The top two layers "axes" and "legend" contain
  the default axes and legend, so they will be drawn on top. In the middle,
  there is the "main" layer. It is initially empty and set as the current layer
  (see QCustomPlot::setCurrentLayer). This means, all new plottables, items etc.
  are created on this layer by default. Then comes the "grid" layer which
  contains the QCPGrid instances (which belong tightly to QCPAxis, see \ref
  QCPAxis::grid). The Axis rect background shall be drawn behind everything
  else, thus the default QCPAxisRect instance is placed on the "background"
  layer. Of course, the layer affiliation of the individual objects can be
  changed as required (\ref QCPLayerable::setLayer).

  Controlling the ordering of objects is easy: Create a new layer in the
  position you want it to be, e.g. above "main", with QCustomPlot::addLayer.
  Then set the current layer with QCustomPlot::setCurrentLayer to that new layer
  and finally create the objects normally. They will be placed on the new layer
  automatically, due to the current layer setting. Alternatively you could have
  also ignored the current layer setting and just moved the objects with
  QCPLayerable::setLayer to the desired layer after creating them.

  It is also possible to move whole layers. For example, If you want the grid to
  be shown in front of all plottables/items on the "main" layer, just move it
  above "main" with QCustomPlot::moveLayer.

  The rendering order within one layer is simply by order of creation or
  insertion. The item created last (or added last to the layer), is drawn on top
  of all other objects on that layer.

  When a layer is deleted, the objects on it are not deleted with it, but fall
  on the layer below the deleted layer, see QCustomPlot::removeLayer.
*/

/* start documentation of inline functions */

/*! \fn QList<QCPLayerable*> QCPLayer::children() const

  Returns a list of all layerables on this layer. The order corresponds to the
  rendering order: layerables with higher indices are drawn above layerables
  with lower indices.
*/

/*! \fn int QCPLayer::index() const

  Returns the index this layer has in the QCustomPlot. The index is the integer
  number by which this layer can be accessed via \ref QCustomPlot::layer.

  Layers with higher indices will be drawn above layers with lower indices.
*/

/* end documentation of inline functions */

/*!
  Creates a new QCPLayer instance.

  Normally you shouldn't directly instantiate layers, use \ref
  QCustomPlot::addLayer instead.

  \warning It is not checked that \a layerName is actually a unique layer name
  in \a parentPlot. This check is only performed by \ref QCustomPlot::addLayer.
*/
QCPLayer::QCPLayer(QCustomPlot *parentPlot, const QString &layerName)
    : QObject(parentPlot),
      mParentPlot(parentPlot),
      mName(layerName),
      mIndex(-1),  // will be set to a proper value by the QCustomPlot layer
                   // creation function
      mVisible(true) {
  // Note: no need to make sure layerName is unique, because layer
  // management is done with QCustomPlot functions.
}

QCPLayer::~QCPLayer() {
  // If child layerables are still on this layer, detach them, so they don't try
  // to reach back to this then invalid layer once they get deleted/moved
  // themselves. This only happens when layers are deleted directly, like in the
  // QCustomPlot destructor. (The regular layer removal procedure for the user
  // is to call QCustomPlot::removeLayer, which moves all layerables off this
  // layer before deleting it.)

  while (!mChildren.isEmpty())
    mChildren.last()->setLayer(
        0);  // removes itself from mChildren via removeChild()

  if (mParentPlot->currentLayer() == this)
    qDebug() << Q_FUNC_INFO
             << "The parent plot's mCurrentLayer will be a dangling pointer. "
                "Should have been set to a valid layer or 0 beforehand.";
}

/*!
  Sets whether this layer is visible or not. If \a visible is set to false, all
  layerables on this layer will be invisible.

  This function doesn't change the visibility property of the layerables (\ref
  QCPLayerable::setVisible), but the \ref QCPLayerable::realVisibility of each
  layerable takes the visibility of the parent layer into account.
*/
void QCPLayer::setVisible(bool visible) { mVisible = visible; }

/*! \internal

  Adds the \a layerable to the list of this layer. If \a prepend is set to true,
  the layerable will be prepended to the list, i.e. be drawn beneath the other
  layerables already in the list.

  This function does not change the \a mLayer member of \a layerable to this
  layer. (Use QCPLayerable::setLayer to change the layer of an object, not this
  function.)

  \see removeChild
*/
void QCPLayer::addChild(QCPLayerable *layerable, bool prepend) {
  if (!mChildren.contains(layerable)) {
    if (prepend)
      mChildren.prepend(layerable);
    else
      mChildren.append(layerable);
  } else
    qDebug() << Q_FUNC_INFO << "layerable is already child of this layer"
             << reinterpret_cast<quintptr>(layerable);
}

/*! \internal

  Removes the \a layerable from the list of this layer.

  This function does not change the \a mLayer member of \a layerable. (Use
  QCPLayerable::setLayer to change the layer of an object, not this function.)

  \see addChild
*/
void QCPLayer::removeChild(QCPLayerable *layerable) {
  if (!mChildren.removeOne(layerable))
    qDebug() << Q_FUNC_INFO << "layerable is not child of this layer"
             << reinterpret_cast<quintptr>(layerable);
}

////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////// QCPLayerable
////////////////////////////////////////////////////////////////////////////////////////////////////

/*! \class QCPLayerable
  \brief Base class for all drawable objects

  This is the abstract base class most visible objects derive from, e.g.
  plottables, axes, grid etc.

  Every layerable is on a layer (QCPLayer) which allows controlling the
  rendering order by stacking the layers accordingly.

  For details about the layering mechanism, see the QCPLayer documentation.
*/

/* start documentation of inline functions */

/*! \fn QCPLayerable *QCPLayerable::parentLayerable() const

  Returns the parent layerable of this layerable. The parent layerable is used
  to provide visibility hierarchies in conjunction with the method \ref
  realVisibility. This way, layerables only get drawn if their parent layerables
  are visible, too.

  Note that a parent layerable is not necessarily also the QObject parent for
  memory management. Further, a layerable doesn't always have a parent
  layerable, so this function may return 0.

  A parent layerable is set implicitly with when placed inside layout elements
  and doesn't need to be set manually by the user.
*/

/* end documentation of inline functions */
/* start documentation of pure virtual functions */

/*! \fn virtual void QCPLayerable::applyDefaultAntialiasingHint(QCPPainter
  *painter) const = 0 \internal

  This function applies the default antialiasing setting to the specified \a
  painter, using the function \ref applyAntialiasingHint. It is the antialiasing
  state the painter is put in, when \ref draw is called on the layerable. If the
  layerable has multiple entities whose antialiasing setting may be specified
  individually, this function should set the antialiasing state of the most
  prominent entity. In this case however, the \ref draw function usually calls
  the specialized versions of this function before drawing each entity,
  effectively overriding the setting of the default antialiasing hint.

  <b>First example:</b> QCPGraph has multiple entities that have an antialiasing
  setting: The graph line, fills, scatters and error bars. Those can be
  configured via QCPGraph::setAntialiased, QCPGraph::setAntialiasedFill,
  QCPGraph::setAntialiasedScatters etc. Consequently, there isn't only the
  QCPGraph::applyDefaultAntialiasingHint function (which corresponds to the
  graph line's antialiasing), but specialized ones like
  QCPGraph::applyFillAntialiasingHint and
  QCPGraph::applyScattersAntialiasingHint. So before drawing one of those
  entities, QCPGraph::draw calls the respective specialized
  applyAntialiasingHint function.

  <b>Second example:</b> QCPItemLine consists only of a line so there is only
  one antialiasing setting which can be controlled with
  QCPItemLine::setAntialiased. (This function is inherited by all layerables.
  The specialized functions, as seen on QCPGraph, must be added explicitly to
  the respective layerable subclass.) Consequently it only has the normal
  QCPItemLine::applyDefaultAntialiasingHint. The \ref QCPItemLine::draw function
  doesn't need to care about setting any antialiasing states, because the
  default antialiasing hint is already set on the painter when the \ref draw
  function is called, and that's the state it wants to draw the line with.
*/

/*! \fn virtual void QCPLayerable::draw(QCPPainter *painter) const = 0
  \internal

  This function draws the layerable with the specified \a painter. It is only
  called by QCustomPlot, if the layerable is visible (\ref setVisible).

  Before this function is called, the painter's antialiasing state is set via
  \ref applyDefaultAntialiasingHint, see the documentation there. Further, the
  clipping rectangle was set to \ref clipRect.
*/

/* end documentation of pure virtual functions */
/* start documentation of signals */

/*! \fn void QCPLayerable::layerChanged(QCPLayer *newLayer);

  This signal is emitted when the layer of this layerable changes, i.e. this
  layerable is moved to a different layer.

  \see setLayer
*/

/* end documentation of signals */

/*!
  Creates a new QCPLayerable instance.

  Since QCPLayerable is an abstract base class, it can't be instantiated
  directly. Use one of the derived classes.

  If \a plot is provided, it automatically places itself on the layer named \a
  targetLayer. If \a targetLayer is an empty string, it places itself on the
  current layer of the plot (see \ref QCustomPlot::setCurrentLayer).

  It is possible to provide 0 as \a plot. In that case, you should assign a
  parent plot at a later time with \ref initializeParentPlot.

  The layerable's parent layerable is set to \a parentLayerable, if provided.
  Direct layerable parents are mainly used to control visibility in a hierarchy
  of layerables. This means a layerable is only drawn, if all its ancestor
  layerables are also visible. Note that \a parentLayerable does not become the
  QObject-parent (for memory management) of this layerable, \a plot does. It is
  not uncommon to set the QObject-parent to something else in the constructors
  of QCPLayerable subclasses, to guarantee a working destruction hierarchy.
*/
QCPLayerable::QCPLayerable(QCustomPlot *plot, QString targetLayer,
                           QCPLayerable *parentLayerable)
    : QObject(plot),
      mVisible(true),
      mParentPlot(plot),
      mParentLayerable(parentLayerable),
      mLayer(0),
      mAntialiased(true) {
  if (mParentPlot) {
    if (targetLayer.isEmpty())
      setLayer(mParentPlot->currentLayer());
    else if (!setLayer(targetLayer))
      qDebug() << Q_FUNC_INFO << "setting QCPlayerable initial layer to"
               << targetLayer << "failed.";
  }
}

QCPLayerable::~QCPLayerable() {
  if (mLayer) {
    mLayer->removeChild(this);
    mLayer = 0;
  }
}

/*!
  Sets the visibility of this layerable object. If an object is not visible, it
  will not be drawn on the QCustomPlot surface, and user interaction with it
  (e.g. click and selection) is not possible.
*/
void QCPLayerable::setVisible(bool on) { mVisible = on; }

/*!
  Sets the \a layer of this layerable object. The object will be placed on top
  of the other objects already on \a layer.

  If \a layer is 0, this layerable will not be on any layer and thus not appear
  in the plot (or interact/receive events).

  Returns true if the layer of this layerable was successfully changed to \a
  layer.
*/
bool QCPLayerable::setLayer(QCPLayer *layer) {
  return moveToLayer(layer, false);
}

/*! \overload
  Sets the layer of this layerable object by name

  Returns true on success, i.e. if \a layerName is a valid layer name.
*/
bool QCPLayerable::setLayer(const QString &layerName) {
  if (!mParentPlot) {
    qDebug() << Q_FUNC_INFO << "no parent QCustomPlot set";
    return false;
  }
  if (QCPLayer *layer = mParentPlot->layer(layerName)) {
    return setLayer(layer);
  } else {
    qDebug() << Q_FUNC_INFO << "there is no layer with name" << layerName;
    return false;
  }
}

/*!
  Sets whether this object will be drawn antialiased or not.

  Note that antialiasing settings may be overridden by
  QCustomPlot::setAntialiasedElements and
  QCustomPlot::setNotAntialiasedElements.
*/
void QCPLayerable::setAntialiased(bool enabled) { mAntialiased = enabled; }

/*!
  Returns whether this layerable is visible, taking the visibility of the
  layerable parent and the visibility of the layer this layerable is on into
  account. This is the method that is consulted to decide whether a layerable
  shall be drawn or not.

  If this layerable has a direct layerable parent (usually set via hierarchies
  implemented in subclasses, like in the case of QCPLayoutElement), this
  function returns true only if this layerable has its visibility set to true
  and the parent layerable's \ref realVisibility returns true.

  If this layerable doesn't have a direct layerable parent, returns the state of
  this layerable's visibility.
*/
bool QCPLayerable::realVisibility() const {
  return mVisible && (!mLayer || mLayer->visible()) &&
         (!mParentLayerable || mParentLayerable.data()->realVisibility());
}

/*!
  This function is used to decide whether a click hits a layerable object or
  not.

  \a pos is a point in pixel coordinates on the QCustomPlot surface. This
  function returns the shortest pixel distance of this point to the object. If
  the object is either invisible or the distance couldn't be determined, -1.0 is
  returned. Further, if \a onlySelectable is true and the object is not
  selectable, -1.0 is returned, too.

  If the object is represented not by single lines but by an area like a \ref
  QCPItemText or the bars of a \ref QCPBars plottable, a click inside the area
  should also be considered a hit. In these cases this function thus returns a
  constant value greater zero but still below the parent plot's selection
  tolerance. (typically the selectionTolerance multiplied by 0.99).

  Providing a constant value for area objects allows selecting line objects even
  when they are obscured by such area objects, by clicking close to the lines
  (i.e. closer than 0.99*selectionTolerance).

  The actual setting of the selection state is not done by this function. This
  is handled by the parent QCustomPlot when the mouseReleaseEvent occurs, and
  the finally selected object is notified via the selectEvent/deselectEvent
  methods.

  \a details is an optional output parameter. Every layerable subclass may place
  any information in \a details. This information will be passed to \ref
  selectEvent when the parent QCustomPlot decides on the basis of this
  selectTest call, that the object was successfully selected. The subsequent
  call to \ref selectEvent will carry the \a details. This is useful for
  multi-part objects (like QCPAxis). This way, a possibly complex calculation to
  decide which part was clicked is only done once in \ref selectTest. The result
  (i.e. the actually clicked part) can then be placed in \a details. So in the
  subsequent \ref selectEvent, the decision which part was selected doesn't have
  to be done a second time for a single selection operation.

  You may pass 0 as \a details to indicate that you are not interested in those
  selection details.

  \see selectEvent, deselectEvent, QCustomPlot::setInteractions
*/
double QCPLayerable::selectTest(const QPointF &pos, bool onlySelectable,
                                QVariant *details) const {
  Q_UNUSED(pos)
  Q_UNUSED(onlySelectable)
  Q_UNUSED(details)
  return -1.0;
}

/*! \internal

  Sets the parent plot of this layerable. Use this function once to set the
  parent plot if you have passed 0 in the constructor. It can not be used to
  move a layerable from one QCustomPlot to another one.

  Note that, unlike when passing a non-null parent plot in the constructor, this
  function does not make \a parentPlot the QObject-parent of this layerable. If
  you want this, call QObject::setParent(\a parentPlot) in addition to this
  function.

  Further, you will probably want to set a layer (\ref setLayer) after calling
  this function, to make the layerable appear on the QCustomPlot.

  The parent plot change will be propagated to subclasses via a call to \ref
  parentPlotInitialized so they can react accordingly (e.g. also initialize the
  parent plot of child layerables, like QCPLayout does).
*/
void QCPLayerable::initializeParentPlot(QCustomPlot *parentPlot) {
  if (mParentPlot) {
    qDebug() << Q_FUNC_INFO << "called with mParentPlot already initialized";
    return;
  }

  if (!parentPlot) qDebug() << Q_FUNC_INFO << "called with parentPlot zero";

  mParentPlot = parentPlot;
  parentPlotInitialized(mParentPlot);
}

/*! \internal

  Sets the parent layerable of this layerable to \a parentLayerable. Note that
  \a parentLayerable does not become the QObject-parent (for memory management)
  of this layerable.

  The parent layerable has influence on the return value of the \ref
  realVisibility method. Only layerables with a fully visible parent tree will
  return true for \ref realVisibility, and thus be drawn.

  \see realVisibility
*/
void QCPLayerable::setParentLayerable(QCPLayerable *parentLayerable) {
  mParentLayerable = parentLayerable;
}

/*! \internal

  Moves this layerable object to \a layer. If \a prepend is true, this object
  will be prepended to the new layer's list, i.e. it will be drawn below the
  objects already on the layer. If it is false, the object will be appended.

  Returns true on success, i.e. if \a layer is a valid layer.
*/
bool QCPLayerable::moveToLayer(QCPLayer *layer, bool prepend) {
  if (layer && !mParentPlot) {
    qDebug() << Q_FUNC_INFO << "no parent QCustomPlot set";
    return false;
  }
  if (layer && layer->parentPlot() != mParentPlot) {
    qDebug() << Q_FUNC_INFO << "layer" << layer->name()
             << "is not in same QCustomPlot as this layerable";
    return false;
  }

  QCPLayer *oldLayer = mLayer;
  if (mLayer) mLayer->removeChild(this);
  mLayer = layer;
  if (mLayer) mLayer->addChild(this, prepend);
  if (mLayer != oldLayer) emit layerChanged(mLayer);
  return true;
}

/*! \internal

  Sets the QCPainter::setAntialiasing state on the provided \a painter,
  depending on the \a localAntialiased value as well as the overrides \ref
  QCustomPlot::setAntialiasedElements and \ref
  QCustomPlot::setNotAntialiasedElements. Which override enum this function
  takes into account is controlled via \a overrideElement.
*/
void QCPLayerable::applyAntialiasingHint(
    QCPPainter *painter, bool localAntialiased,
    QCP::AntialiasedElement overrideElement) const {
  if (mParentPlot &&
      mParentPlot->notAntialiasedElements().testFlag(overrideElement))
    painter->setAntialiasing(false);
  else if (mParentPlot &&
           mParentPlot->antialiasedElements().testFlag(overrideElement))
    painter->setAntialiasing(true);
  else
    painter->setAntialiasing(localAntialiased);
}

/*! \internal

  This function is called by \ref initializeParentPlot, to allow subclasses to
  react on the setting of a parent plot. This is the case when 0 was passed as
  parent plot in the constructor, and the parent plot is set at a later time.

  For example, QCPLayoutElement/QCPLayout hierarchies may be created
  independently of any QCustomPlot at first. When they are then added to a
  layout inside the QCustomPlot, the top level element of the hierarchy gets its
  parent plot initialized with \ref initializeParentPlot. To propagate the
  parent plot to all the children of the hierarchy, the top level element then
  uses this function to pass the parent plot on to its child elements.

  The default implementation does nothing.

  \see initializeParentPlot
*/
void QCPLayerable::parentPlotInitialized(QCustomPlot *parentPlot) {
  Q_UNUSED(parentPlot)
}

/*! \internal

  Returns the selection category this layerable shall belong to. The selection
  category is used in conjunction with \ref QCustomPlot::setInteractions to
  control which objects are selectable and which aren't.

  Subclasses that don't fit any of the normal \ref QCP::Interaction values can
  use \ref QCP::iSelectOther. This is what the default implementation returns.

  \see QCustomPlot::setInteractions
*/
QCP::Interaction QCPLayerable::selectionCategory() const {
  return QCP::iSelectOther;
}

/*! \internal

  Returns the clipping rectangle of this layerable object. By default, this is
  the viewport of the parent QCustomPlot. Specific subclasses may reimplement
  this function to provide different clipping rects.

  The returned clipping rect is set on the painter before the draw function of
  the respective object is called.
*/
QRect QCPLayerable::clipRect() const {
  if (mParentPlot)
    return mParentPlot->viewport();
  else
    return QRect();
}

/*! \internal

  This event is called when the layerable shall be selected, as a consequence of
  a click by the user. Subclasses should react to it by setting their selection
  state appropriately. The default implementation does nothing.

  \a event is the mouse event that caused the selection. \a additive indicates,
  whether the user was holding the multi-select-modifier while performing the
  selection (see \ref QCustomPlot::setMultiSelectModifier). if \a additive is
  true, the selection state must be toggled (i.e. become selected when
  unselected and unselected when selected).

  Every selectEvent is preceded by a call to \ref selectTest, which has returned
  positively (i.e. returned a value greater than 0 and less than the selection
  tolerance of the parent QCustomPlot). The \a details data you output from \ref
  selectTest is fed back via \a details here. You may use it to transport any
  kind of information from the selectTest to the possibly subsequent
  selectEvent. Usually \a details is used to transfer which part was clicked, if
  it is a layerable that has multiple individually selectable parts (like
  QCPAxis). This way selectEvent doesn't need to do the calculation again to
  find out which part was actually clicked.

  \a selectionStateChanged is an output parameter. If the pointer is non-null,
  this function must set the value either to true or false, depending on whether
  the selection state of this layerable was actually changed. For layerables
  that only are selectable as a whole and not in parts, this is simple: if \a
  additive is true, \a selectionStateChanged must also be set to true, because
  the selection toggles. If \a additive is false, \a selectionStateChanged is
  only set to true, if the layerable was previously unselected and now is
  switched to the selected state.

  \see selectTest, deselectEvent
*/
void QCPLayerable::selectEvent(QMouseEvent *event, bool additive,
                               const QVariant &details,
                               bool *selectionStateChanged) {
  Q_UNUSED(event)
  Q_UNUSED(additive)
  Q_UNUSED(details)
  Q_UNUSED(selectionStateChanged)
}

/*! \internal

  This event is called when the layerable shall be deselected, either as
  consequence of a user interaction or a call to \ref QCustomPlot::deselectAll.
  Subclasses should react to it by unsetting their selection appropriately.

  just as in \ref selectEvent, the output parameter \a selectionStateChanged (if
  non-null), must return true or false when the selection state of this
  layerable has changed or not changed, respectively.

  \see selectTest, selectEvent
*/
void QCPLayerable::deselectEvent(bool *selectionStateChanged) {
  Q_UNUSED(selectionStateChanged)
}

////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////// QCPRange
////////////////////////////////////////////////////////////////////////////////////////////////////
/*! \class QCPRange
  \brief Represents the range an axis is encompassing.

  contains a \a lower and \a upper double value and provides convenience input,
  output and modification functions.

  \see QCPAxis::setRange
*/

/*!
  Minimum range size (\a upper - \a lower) the range changing functions will
  accept. Smaller intervals would cause errors due to the 11-bit exponent of
  double precision numbers, corresponding to a minimum magnitude of roughly
  1e-308. \see validRange, maxRange
*/
const double QCPRange::minRange = 1e-280;

/*!
  Maximum values (negative and positive) the range will accept in range-changing
  functions. Larger absolute values would cause errors due to the 11-bit
  exponent of double precision numbers, corresponding to a maximum magnitude of
  roughly 1e308. Since the number of planck-volumes in the entire visible
  universe is only ~1e183, this should be enough. \see validRange, minRange
*/
const double QCPRange::maxRange = 1e250;

/*!
  Constructs a range with \a lower and \a upper set to zero.
*/
QCPRange::QCPRange() : lower(0), upper(0) {}

/*! \overload
  Constructs a range with the specified \a lower and \a upper values.
*/
QCPRange::QCPRange(double lower, double upper) : lower(lower), upper(upper) {
  normalize();
}

/*!
  Returns the size of the range, i.e. \a upper-\a lower
*/
double QCPRange::size() const { return upper - lower; }

/*!
  Returns the center of the range, i.e. (\a upper+\a lower)*0.5
*/
double QCPRange::center() const { return (upper + lower) * 0.5; }

/*!
  Makes sure \a lower is numerically smaller than \a upper. If this is not the
  case, the values are swapped.
*/
void QCPRange::normalize() {
  if (lower > upper) qSwap(lower, upper);
}

/*!
  Expands this range such that \a otherRange is contained in the new range. It
  is assumed that both this range and \a otherRange are normalized (see \ref
  normalize).

  If \a otherRange is already inside the current range, this function does
  nothing.

  \see expanded
*/
void QCPRange::expand(const QCPRange &otherRange) {
  if (lower > otherRange.lower) lower = otherRange.lower;
  if (upper < otherRange.upper) upper = otherRange.upper;
}

/*!
  Returns an expanded range that contains this and \a otherRange. It is assumed
  that both this range and \a otherRange are normalized (see \ref normalize).

  \see expand
*/
QCPRange QCPRange::expanded(const QCPRange &otherRange) const {
  QCPRange result = *this;
  result.expand(otherRange);
  return result;
}

/*!
  Returns a sanitized version of the range. Sanitized means for logarithmic
  scales, that the range won't span the positive and negative sign domain, i.e.
  contain zero. Further \a lower will always be numerically smaller (or equal)
  to \a upper.

  If the original range does span positive and negative sign domains or contains
  zero, the returned range will try to approximate the original range as good as
  possible. If the positive interval of the original range is wider than the
  negative interval, the returned range will only contain the positive interval,
  with lower bound set to \a rangeFac or \a rangeFac *\a upper, whichever is
  closer to zero. Same procedure is used if the negative interval is wider than
  the positive interval, this time by changing the \a upper bound.
*/
QCPRange QCPRange::sanitizedForLogScale() const {
  double rangeFac = 1e-3;
  QCPRange sanitizedRange(lower, upper);
  sanitizedRange.normalize();
  // can't have range spanning negative and positive values in log plot, so
  // change range to fix it
  // if (qFuzzyCompare(sanitizedRange.lower+1, 1) &&
  // !qFuzzyCompare(sanitizedRange.upper+1, 1))
  if (sanitizedRange.lower == 0.0 && sanitizedRange.upper != 0.0) {
    // case lower is 0
    if (rangeFac < sanitizedRange.upper * rangeFac)
      sanitizedRange.lower = rangeFac;
    else
      sanitizedRange.lower = sanitizedRange.upper * rangeFac;
  }  // else if (!qFuzzyCompare(lower+1, 1) && qFuzzyCompare(upper+1, 1))
  else if (sanitizedRange.lower != 0.0 && sanitizedRange.upper == 0.0) {
    // case upper is 0
    if (-rangeFac > sanitizedRange.lower * rangeFac)
      sanitizedRange.upper = -rangeFac;
    else
      sanitizedRange.upper = sanitizedRange.lower * rangeFac;
  } else if (sanitizedRange.lower < 0 && sanitizedRange.upper > 0) {
    // find out whether negative or positive interval is wider to decide which
    // sign domain will be chosen
    if (-sanitizedRange.lower > sanitizedRange.upper) {
      // negative is wider, do same as in case upper is 0
      if (-rangeFac > sanitizedRange.lower * rangeFac)
        sanitizedRange.upper = -rangeFac;
      else
        sanitizedRange.upper = sanitizedRange.lower * rangeFac;
    } else {
      // positive is wider, do same as in case lower is 0
      if (rangeFac < sanitizedRange.upper * rangeFac)
        sanitizedRange.lower = rangeFac;
      else
        sanitizedRange.lower = sanitizedRange.upper * rangeFac;
    }
  }
  // due to normalization, case lower>0 && upper<0 should never occur, because
  // that implies upper<lower
  return sanitizedRange;
}

/*!
  Returns a sanitized version of the range. Sanitized means for linear scales,
  that \a lower will always be numerically smaller (or equal) to \a upper.
*/
QCPRange QCPRange::sanitizedForLinScale() const {
  QCPRange sanitizedRange(lower, upper);
  sanitizedRange.normalize();
  return sanitizedRange;
}

/*!
  Returns true when \a value lies within or exactly on the borders of the range.
*/
bool QCPRange::contains(double value) const {
  return value >= lower && value <= upper;
}

/*!
  Checks, whether the specified range is within valid bounds, which are defined
  as QCPRange::maxRange and QCPRange::minRange.
  A valid range means:
  \li range bounds within -maxRange and maxRange
  \li range size above minRange
  \li range size below maxRange
*/
bool QCPRange::validRange(double lower, double upper) {
  return (lower > -maxRange && upper < maxRange &&
          qAbs(lower - upper) > minRange && qAbs(lower - upper) < maxRange &&
          !(lower > 0 && qIsInf(upper / lower)) &&
          !(upper < 0 && qIsInf(lower / upper)));
}

/*!
  \overload
  Checks, whether the specified range is within valid bounds, which are defined
  as QCPRange::maxRange and QCPRange::minRange.
  A valid range means:
  \li range bounds within -maxRange and maxRange
  \li range size above minRange
  \li range size below maxRange
*/
bool QCPRange::validRange(const QCPRange &range) {
  return (range.lower > -maxRange && range.upper < maxRange &&
          qAbs(range.lower - range.upper) > minRange &&
          qAbs(range.lower - range.upper) < maxRange &&
          !(range.lower > 0 && qIsInf(range.upper / range.lower)) &&
          !(range.upper < 0 && qIsInf(range.lower / range.upper)));
}

////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////// QCPMarginGroup
////////////////////////////////////////////////////////////////////////////////////////////////////

/*! \class QCPMarginGroup
  \brief A margin group allows synchronization of margin sides if working with
  multiple layout elements.

  QCPMarginGroup allows you to tie a margin side of two or more layout elements
  together, such that they will all have the same size, based on the largest
  required margin in the group.

  \n
  \image html QCPMarginGroup.png "Demonstration of QCPMarginGroup"
  \n

  In certain situations it is desirable that margins at specific sides are
  synchronized across layout elements. For example, if one QCPAxisRect is below
  another one in a grid layout, it will provide a cleaner look to the user if
  the left and right margins of the two axis rects are of the same size. The
  left axis of the top axis rect will then be at the same horizontal position as
  the left axis of the lower axis rect, making them appear aligned. The same
  applies for the right axes. This is what QCPMarginGroup makes possible.

  To add/remove a specific side of a layout element to/from a margin group, use
  the \ref QCPLayoutElement::setMarginGroup method. To completely break apart
  the margin group, either call \ref clear, or just delete the margin group.

  \section QCPMarginGroup-example Example

  First create a margin group:
  \snippet documentation/doc-code-snippets/mainwindow.cpp
  qcpmargingroup-creation-1 Then set this group on the layout element sides:
  \snippet documentation/doc-code-snippets/mainwindow.cpp
  qcpmargingroup-creation-2 Here, we've used the first two axis rects of the
  plot and synchronized their left margins with each other and their right
  margins with each other.
*/

/* start documentation of inline functions */

/*! \fn QList<QCPLayoutElement*> QCPMarginGroup::elements(QCP::MarginSide side)
  const

  Returns a list of all layout elements that have their margin \a side
  associated with this margin group.
*/

/* end documentation of inline functions */

/*!
  Creates a new QCPMarginGroup instance in \a parentPlot.
*/
QCPMarginGroup::QCPMarginGroup(QCustomPlot *parentPlot)
    : QObject(parentPlot), mParentPlot(parentPlot) {
  mChildren.insert(QCP::msLeft, QList<QCPLayoutElement *>());
  mChildren.insert(QCP::msRight, QList<QCPLayoutElement *>());
  mChildren.insert(QCP::msTop, QList<QCPLayoutElement *>());
  mChildren.insert(QCP::msBottom, QList<QCPLayoutElement *>());
}

QCPMarginGroup::~QCPMarginGroup() { clear(); }

/*!
  Returns whether this margin group is empty. If this function returns true, no
  layout elements use this margin group to synchronize margin sides.
*/
bool QCPMarginGroup::isEmpty() const {
  QHashIterator<QCP::MarginSide, QList<QCPLayoutElement *> > it(mChildren);
  while (it.hasNext()) {
    it.next();
    if (!it.value().isEmpty()) return false;
  }
  return true;
}

/*!
  Clears this margin group. The synchronization of the margin sides that use
  this margin group is lifted and they will use their individual margin sizes
  again.
*/
void QCPMarginGroup::clear() {
  // make all children remove themselves from this margin group:
  QHashIterator<QCP::MarginSide, QList<QCPLayoutElement *> > it(mChildren);
  while (it.hasNext()) {
    it.next();
    const QList<QCPLayoutElement *> elements = it.value();
    for (int i = elements.size() - 1; i >= 0; --i)
      elements.at(i)->setMarginGroup(
          it.key(), 0);  // removes itself from mChildren via removeChild
  }
}

/*! \internal

  Returns the synchronized common margin for \a side. This is the margin value
  that will be used by the layout element on the respective side, if it is part
  of this margin group.

  The common margin is calculated by requesting the automatic margin (\ref
  QCPLayoutElement::calculateAutoMargin) of each element associated with \a side
  in this margin group, and choosing the largest returned value.
  (QCPLayoutElement::minimumMargins is taken into account, too.)
*/
int QCPMarginGroup::commonMargin(QCP::MarginSide side) const {
  // query all automatic margins of the layout elements in this margin group
  // side and find maximum:
  int result = 0;
  const QList<QCPLayoutElement *> elements = mChildren.value(side);
  for (int i = 0; i < elements.size(); ++i) {
    if (!elements.at(i)->autoMargins().testFlag(side)) continue;
    int m = qMax(elements.at(i)->calculateAutoMargin(side),
                 QCP::getMarginValue(elements.at(i)->minimumMargins(), side));
    if (m > result) result = m;
  }
  return result;
}

/*! \internal

  Adds \a element to the internal list of child elements, for the margin \a
  side.

  This function does not modify the margin group property of \a element.
*/
void QCPMarginGroup::addChild(QCP::MarginSide side, QCPLayoutElement *element) {
  if (!mChildren[side].contains(element))
    mChildren[side].append(element);
  else
    qDebug() << Q_FUNC_INFO
             << "element is already child of this margin group side"
             << reinterpret_cast<quintptr>(element);
}

/*! \internal

  Removes \a element from the internal list of child elements, for the margin \a
  side.

  This function does not modify the margin group property of \a element.
*/
void QCPMarginGroup::removeChild(QCP::MarginSide side,
                                 QCPLayoutElement *element) {
  if (!mChildren[side].removeOne(element))
    qDebug() << Q_FUNC_INFO << "element is not child of this margin group side"
             << reinterpret_cast<quintptr>(element);
}

////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////// QCPLayoutElement
////////////////////////////////////////////////////////////////////////////////////////////////////

/*! \class QCPLayoutElement
  \brief The abstract base class for all objects that form \ref thelayoutsystem
  "the layout system".

  This is an abstract base class. As such, it can't be instantiated directly,
  rather use one of its subclasses.

  A Layout element is a rectangular object which can be placed in layouts. It
  has an outer rect (QCPLayoutElement::outerRect) and an inner rect (\ref
  QCPLayoutElement::rect). The difference between outer and inner rect is called
  its margin. The margin can either be set to automatic or manual (\ref
  setAutoMargins) on a per-side basis. If a side is set to manual, that margin
  can be set explicitly with \ref setMargins and will stay fixed at that value.
  If it's set to automatic, the layout element subclass will control the value
  itself (via \ref calculateAutoMargin).

  Layout elements can be placed in layouts (base class QCPLayout) like
  QCPLayoutGrid. The top level layout is reachable via \ref
  QCustomPlot::plotLayout, and is a \ref QCPLayoutGrid. Since \ref QCPLayout
  itself derives from \ref QCPLayoutElement, layouts can be nested.

  Thus in QCustomPlot one can divide layout elements into two categories: The
  ones that are invisible by themselves, because they don't draw anything. Their
  only purpose is to manage the position and size of other layout elements. This
  category of layout elements usually use QCPLayout as base class. Then there is
  the category of layout elements which actually draw something. For example,
  QCPAxisRect, QCPLegend and QCPPlotTitle are of this category. This does not
  necessarily mean that the latter category can't have child layout elements.
  QCPLegend for instance, actually derives from QCPLayoutGrid and the individual
  legend items are child layout elements in the grid layout.
*/

/* start documentation of inline functions */

/*! \fn QCPLayout *QCPLayoutElement::layout() const

  Returns the parent layout of this layout element.
*/

/*! \fn QRect QCPLayoutElement::rect() const

  Returns the inner rect of this layout element. The inner rect is the outer
  rect (\ref setOuterRect) shrinked by the margins (\ref setMargins, \ref
  setAutoMargins).

  In some cases, the area between outer and inner rect is left blank. In other
  cases the margin area is used to display peripheral graphics while the main
  content is in the inner rect. This is where automatic margin calculation
  becomes interesting because it allows the layout element to adapt the margins
  to the peripheral graphics it wants to draw. For example, \ref QCPAxisRect
  draws the axis labels and tick labels in the margin area, thus needs to adjust
  the margins (if \ref setAutoMargins is enabled) according to the space
  required by the labels of the axes.
*/

/*! \fn virtual void QCPLayoutElement::mousePressEvent(QMouseEvent *event)

  This event is called, if the mouse was pressed while being inside the outer
  rect of this layout element.
*/

/*! \fn virtual void QCPLayoutElement::mouseMoveEvent(QMouseEvent *event)

  This event is called, if the mouse is moved inside the outer rect of this
  layout element.
*/

/*! \fn virtual void QCPLayoutElement::mouseReleaseEvent(QMouseEvent *event)

  This event is called, if the mouse was previously pressed inside the outer
  rect of this layout element and is now released.
*/

/*! \fn virtual void QCPLayoutElement::mouseDoubleClickEvent(QMouseEvent *event)

  This event is called, if the mouse is double-clicked inside the outer rect of
  this layout element.
*/

/*! \fn virtual void QCPLayoutElement::wheelEvent(QWheelEvent *event)

  This event is called, if the mouse wheel is scrolled while the cursor is
  inside the rect of this layout element.
*/

/* end documentation of inline functions */

/*!
  Creates an instance of QCPLayoutElement and sets default values.
*/
QCPLayoutElement::QCPLayoutElement(QCustomPlot *parentPlot)
    : QCPLayerable(
          parentPlot),  // parenthood is changed as soon as layout element gets
                        // inserted into a layout (except for top level layout)
      mParentLayout(0),
      mMinimumSize(),
      mMaximumSize(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX),
      mRect(0, 0, 0, 0),
      mOuterRect(0, 0, 0, 0),
      mMargins(0, 0, 0, 0),
      mMinimumMargins(0, 0, 0, 0),
      mAutoMargins(QCP::msAll) {}

QCPLayoutElement::~QCPLayoutElement() {
  setMarginGroup(QCP::msAll,
                 0);  // unregister at margin groups, if there are any
  // unregister at layout:
  if (qobject_cast<QCPLayout *>(
          mParentLayout))  // the qobject_cast is just a safeguard in case the
                           // layout forgets to call clear() in its dtor and
                           // this dtor is called by QObject dtor
    mParentLayout->take(this);
}

/*!
  Sets the outer rect of this layout element. If the layout element is inside a
  layout, the layout sets the position and size of this layout element using
  this function.

  Calling this function externally has no effect, since the layout will
  overwrite any changes to the outer rect upon the next replot.

  The layout element will adapt its inner \ref rect by applying the margins
  inward to the outer rect.

  \see rect
*/
void QCPLayoutElement::setOuterRect(const QRect &rect) {
  if (mOuterRect != rect) {
    mOuterRect = rect;
    mRect = mOuterRect.adjusted(mMargins.left(), mMargins.top(),
                                -mMargins.right(), -mMargins.bottom());
  }
}

/*!
  Sets the margins of this layout element. If \ref setAutoMargins is disabled
  for some or all sides, this function is used to manually set the margin on
  those sides. Sides that are still set to be handled automatically are ignored
  and may have any value in \a margins.

  The margin is the distance between the outer rect (controlled by the parent
  layout via \ref setOuterRect) and the inner \ref rect (which usually contains
  the main content of this layout element).

  \see setAutoMargins
*/
void QCPLayoutElement::setMargins(const QMargins &margins) {
  if (mMargins != margins) {
    mMargins = margins;
    mRect = mOuterRect.adjusted(mMargins.left(), mMargins.top(),
                                -mMargins.right(), -mMargins.bottom());
  }
}

/*!
  If \ref setAutoMargins is enabled on some or all margins, this function is
  used to provide minimum values for those margins.

  The minimum values are not enforced on margin sides that were set to be under
  manual control via \ref setAutoMargins.

  \see setAutoMargins
*/
void QCPLayoutElement::setMinimumMargins(const QMargins &margins) {
  if (mMinimumMargins != margins) {
    mMinimumMargins = margins;
  }
}

/*!
  Sets on which sides the margin shall be calculated automatically. If a side is
  calculated automatically, a minimum margin value may be provided with \ref
  setMinimumMargins. If a side is set to be controlled manually, the value may
  be specified with \ref setMargins.

  Margin sides that are under automatic control may participate in a \ref
  QCPMarginGroup (see \ref setMarginGroup), to synchronize (align) it with other
  layout elements in the plot.

  \see setMinimumMargins, setMargins
*/
void QCPLayoutElement::setAutoMargins(QCP::MarginSides sides) {
  mAutoMargins = sides;
}

/*!
  Sets the minimum size for the inner \ref rect of this layout element. A parent
  layout tries to respect the \a size here by changing row/column sizes in the
  layout accordingly.

  If the parent layout size is not sufficient to satisfy all minimum size
  constraints of its child layout elements, the layout may set a size that is
  actually smaller than \a size. QCustomPlot propagates the layout's size
  constraints to the outside by setting its own minimum QWidget size
  accordingly, so violations of \a size should be exceptions.
*/
void QCPLayoutElement::setMinimumSize(const QSize &size) {
  if (mMinimumSize != size) {
    mMinimumSize = size;
    if (mParentLayout) mParentLayout->sizeConstraintsChanged();
  }
}

/*! \overload

  Sets the minimum size for the inner \ref rect of this layout element.
*/
void QCPLayoutElement::setMinimumSize(int width, int height) {
  setMinimumSize(QSize(width, height));
}

/*!
  Sets the maximum size for the inner \ref rect of this layout element. A parent
  layout tries to respect the \a size here by changing row/column sizes in the
  layout accordingly.
*/
void QCPLayoutElement::setMaximumSize(const QSize &size) {
  if (mMaximumSize != size) {
    mMaximumSize = size;
    if (mParentLayout) mParentLayout->sizeConstraintsChanged();
  }
}

/*! \overload

  Sets the maximum size for the inner \ref rect of this layout element.
*/
void QCPLayoutElement::setMaximumSize(int width, int height) {
  setMaximumSize(QSize(width, height));
}

/*!
  Sets the margin \a group of the specified margin \a sides.

  Margin groups allow synchronizing specified margins across layout elements,
  see the documentation of \ref QCPMarginGroup.

  To unset the margin group of \a sides, set \a group to 0.

  Note that margin groups only work for margin sides that are set to automatic
  (\ref setAutoMargins).
*/
void QCPLayoutElement::setMarginGroup(QCP::MarginSides sides,
                                      QCPMarginGroup *group) {
  QVector<QCP::MarginSide> sideVector;
  if (sides.testFlag(QCP::msLeft)) sideVector.append(QCP::msLeft);
  if (sides.testFlag(QCP::msRight)) sideVector.append(QCP::msRight);
  if (sides.testFlag(QCP::msTop)) sideVector.append(QCP::msTop);
  if (sides.testFlag(QCP::msBottom)) sideVector.append(QCP::msBottom);

  for (int i = 0; i < sideVector.size(); ++i) {
    QCP::MarginSide side = sideVector.at(i);
    if (marginGroup(side) != group) {
      QCPMarginGroup *oldGroup = marginGroup(side);
      if (oldGroup)  // unregister at old group
        oldGroup->removeChild(side, this);

      if (!group)  // if setting to 0, remove hash entry. Else set hash entry to
                   // new group and register there
      {
        mMarginGroups.remove(side);
      } else  // setting to a new group
      {
        mMarginGroups[side] = group;
        group->addChild(side, this);
      }
    }
  }
}

/*!
  Updates the layout element and sub-elements. This function is automatically
  called before every replot by the parent layout element. It is called multiple
  times, once for every \ref UpdatePhase. The phases are run through in the
  order of the enum values. For details about what happens at the different
  phases, see the documentation of \ref UpdatePhase.

  Layout elements that have child elements should call the \ref update method of
  their child elements, and pass the current \a phase unchanged.

  The default implementation executes the automatic margin mechanism in the \ref
  upMargins phase. Subclasses should make sure to call the base class
  implementation.
*/
void QCPLayoutElement::update(UpdatePhase phase) {
  if (phase == upMargins) {
    if (mAutoMargins != QCP::msNone) {
      // set the margins of this layout element according to automatic margin
      // calculation, either directly or via a margin group:
      QMargins newMargins = mMargins;
      QList<QCP::MarginSide> allMarginSides = QList<QCP::MarginSide>()
                                              << QCP::msLeft << QCP::msRight
                                              << QCP::msTop << QCP::msBottom;
      foreach (QCP::MarginSide side, allMarginSides) {
        if (mAutoMargins.testFlag(
                side))  // this side's margin shall be calculated automatically
        {
          if (mMarginGroups.contains(side))
            QCP::setMarginValue(
                newMargins, side,
                mMarginGroups[side]->commonMargin(
                    side));  // this side is part of a margin group, so get the
                             // margin value from that group
          else
            QCP::setMarginValue(
                newMargins, side,
                calculateAutoMargin(
                    side));  // this side is not part of a group, so calculate
                             // the value directly
          // apply minimum margin restrictions:
          if (QCP::getMarginValue(newMargins, side) <
              QCP::getMarginValue(mMinimumMargins, side))
            QCP::setMarginValue(newMargins, side,
                                QCP::getMarginValue(mMinimumMargins, side));
        }
      }
      setMargins(newMargins);
    }
  }
}

/*!
  Returns the minimum size this layout element (the inner \ref rect) may be
  compressed to.

  if a minimum size (\ref setMinimumSize) was not set manually, parent layouts
  consult this function to determine the minimum allowed size of this layout
  element. (A manual minimum size is considered set if it is non-zero.)
*/
QSize QCPLayoutElement::minimumSizeHint() const { return mMinimumSize; }

/*!
  Returns the maximum size this layout element (the inner \ref rect) may be
  expanded to.

  if a maximum size (\ref setMaximumSize) was not set manually, parent layouts
  consult this function to determine the maximum allowed size of this layout
  element. (A manual maximum size is considered set if it is smaller than Qt's
  QWIDGETSIZE_MAX.)
*/
QSize QCPLayoutElement::maximumSizeHint() const { return mMaximumSize; }

/*!
  Returns a list of all child elements in this layout element. If \a recursive
  is true, all sub-child elements are included in the list, too.

  \warning There may be entries with value 0 in the returned list. (For example,
  QCPLayoutGrid may have empty cells which yield 0 at the respective index.)
*/
QList<QCPLayoutElement *> QCPLayoutElement::elements(bool recursive) const {
  Q_UNUSED(recursive)
  return QList<QCPLayoutElement *>();
}

/*!
  Layout elements are sensitive to events inside their outer rect. If \a pos is
  within the outer rect, this method returns a value corresponding to 0.99 times
  the parent plot's selection tolerance. However, layout elements are not
  selectable by default. So if \a onlySelectable is true, -1.0 is returned.

  See \ref QCPLayerable::selectTest for a general explanation of this virtual
  method.

  QCPLayoutElement subclasses may reimplement this method to provide more
  specific selection test behaviour.
*/
double QCPLayoutElement::selectTest(const QPointF &pos, bool onlySelectable,
                                    QVariant *details) const {
  Q_UNUSED(details)

  if (onlySelectable) return -1;

  if (QRectF(mOuterRect).contains(pos)) {
    if (mParentPlot)
      return mParentPlot->selectionTolerance() * 0.99;
    else {
      qDebug() << Q_FUNC_INFO << "parent plot not defined";
      return -1;
    }
  } else
    return -1;
}

/*! \internal

  propagates the parent plot initialization to all child elements, by calling
  \ref QCPLayerable::initializeParentPlot on them.
*/
void QCPLayoutElement::parentPlotInitialized(QCustomPlot *parentPlot) {
  foreach (QCPLayoutElement *el, elements(false)) {
    if (!el->parentPlot()) el->initializeParentPlot(parentPlot);
  }
}

/*! \internal

  Returns the margin size for this \a side. It is used if automatic margins is
  enabled for this \a side (see \ref setAutoMargins). If a minimum margin was
  set with \ref setMinimumMargins, the returned value will not be smaller than
  the specified minimum margin.

  The default implementation just returns the respective manual margin (\ref
  setMargins) or the minimum margin, whichever is larger.
*/
int QCPLayoutElement::calculateAutoMargin(QCP::MarginSide side) {
  return qMax(QCP::getMarginValue(mMargins, side),
              QCP::getMarginValue(mMinimumMargins, side));
}

////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////// QCPLayout
////////////////////////////////////////////////////////////////////////////////////////////////////

/*! \class QCPLayout
  \brief The abstract base class for layouts

  This is an abstract base class for layout elements whose main purpose is to
  define the position and size of other child layout elements. In most cases,
  layouts don't draw anything themselves (but there are exceptions to this, e.g.
  QCPLegend).

  QCPLayout derives from QCPLayoutElement, and thus can itself be nested in
  other layouts.

  QCPLayout introduces a common interface for accessing and manipulating the
  child elements. Those functions are most notably \ref elementCount, \ref
  elementAt, \ref takeAt, \ref take, \ref simplify, \ref removeAt, \ref remove
  and \ref clear. Individual subclasses may add more functions to this interface
  which are more specialized to the form of the layout. For example, \ref
  QCPLayoutGrid adds functions that take row and column indices to access cells
  of the layout grid more conveniently.

  Since this is an abstract base class, you can't instantiate it directly.
  Rather use one of its subclasses like QCPLayoutGrid or QCPLayoutInset.

  For a general introduction to the layout system, see the dedicated
  documentation page \ref thelayoutsystem "The Layout System".
*/

/* start documentation of pure virtual functions */

/*! \fn virtual int QCPLayout::elementCount() const = 0

  Returns the number of elements/cells in the layout.

  \see elements, elementAt
*/

/*! \fn virtual QCPLayoutElement* QCPLayout::elementAt(int index) const = 0

  Returns the element in the cell with the given \a index. If \a index is
  invalid, returns 0.

  Note that even if \a index is valid, the respective cell may be empty in some
  layouts (e.g. QCPLayoutGrid), so this function may return 0 in those cases.
  You may use this function to check whether a cell is empty or not.

  \see elements, elementCount, takeAt
*/

/*! \fn virtual QCPLayoutElement* QCPLayout::takeAt(int index) = 0

  Removes the element with the given \a index from the layout and returns it.

  If the \a index is invalid or the cell with that index is empty, returns 0.

  Note that some layouts don't remove the respective cell right away but leave
  an empty cell after successful removal of the layout element. To collapse
  empty cells, use \ref simplify.

  \see elementAt, take
*/

/*! \fn virtual bool QCPLayout::take(QCPLayoutElement* element) = 0

  Removes the specified \a element from the layout and returns true on success.

  If the \a element isn't in this layout, returns false.

  Note that some layouts don't remove the respective cell right away but leave
  an empty cell after successful removal of the layout element. To collapse
  empty cells, use \ref simplify.

  \see takeAt
*/

/* end documentation of pure virtual functions */

/*!
  Creates an instance of QCPLayout and sets default values. Note that since
  QCPLayout is an abstract base class, it can't be instantiated directly.
*/
QCPLayout::QCPLayout() {}

/*!
  First calls the QCPLayoutElement::update base class implementation to update
  the margins on this layout.

  Then calls \ref updateLayout which subclasses reimplement to reposition and
  resize their cells.

  Finally, \ref update is called on all child elements.
*/
void QCPLayout::update(UpdatePhase phase) {
  QCPLayoutElement::update(phase);

  // set child element rects according to layout:
  if (phase == upLayout) updateLayout();

  // propagate update call to child elements:
  const int elCount = elementCount();
  for (int i = 0; i < elCount; ++i) {
    if (QCPLayoutElement *el = elementAt(i)) el->update(phase);
  }
}

/* inherits documentation from base class */
QList<QCPLayoutElement *> QCPLayout::elements(bool recursive) const {
  const int c = elementCount();
  QList<QCPLayoutElement *> result;
#if QT_VERSION >= QT_VERSION_CHECK(4, 7, 0)
  result.reserve(c);
#endif
  for (int i = 0; i < c; ++i) result.append(elementAt(i));
  if (recursive) {
    for (int i = 0; i < c; ++i) {
      if (result.at(i)) result << result.at(i)->elements(recursive);
    }
  }
  return result;
}

/*!
  Simplifies the layout by collapsing empty cells. The exact behavior depends on
  subclasses, the default implementation does nothing.

  Not all layouts need simplification. For example, QCPLayoutInset doesn't use
  explicit simplification while QCPLayoutGrid does.
*/
void QCPLayout::simplify() {}

/*!
  Removes and deletes the element at the provided \a index. Returns true on
  success. If \a index is invalid or points to an empty cell, returns false.

  This function internally uses \ref takeAt to remove the element from the
  layout and then deletes the returned element. Note that some layouts don't
  remove the respective cell right away but leave an empty cell after successful
  removal of the layout element. To collapse empty cells, use \ref simplify.

  \see remove, takeAt
*/
bool QCPLayout::removeAt(int index) {
  if (QCPLayoutElement *el = takeAt(index)) {
    delete el;
    return true;
  } else
    return false;
}

/*!
  Removes and deletes the provided \a element. Returns true on success. If \a
  element is not in the layout, returns false.

  This function internally uses \ref takeAt to remove the element from the
  layout and then deletes the element. Note that some layouts don't remove the
  respective cell right away but leave an empty cell after successful removal of
  the layout element. To collapse empty cells, use \ref simplify.

  \see removeAt, take
*/
bool QCPLayout::remove(QCPLayoutElement *element) {
  if (take(element)) {
    delete element;
    return true;
  } else
    return false;
}

/*!
  Removes and deletes all layout elements in this layout. Finally calls \ref
  simplify to make sure all empty cells are collapsed.

  \see remove, removeAt
*/
void QCPLayout::clear() {
  for (int i = elementCount() - 1; i >= 0; --i) {
    if (elementAt(i)) removeAt(i);
  }
  simplify();
}

/*!
  Subclasses call this method to report changed (minimum/maximum) size
  constraints.

  If the parent of this layout is again a QCPLayout, forwards the call to the
  parent's \ref sizeConstraintsChanged. If the parent is a QWidget (i.e. is the
  \ref QCustomPlot::plotLayout of QCustomPlot), calls QWidget::updateGeometry,
  so if the QCustomPlot widget is inside a Qt QLayout, it may update itself and
  resize cells accordingly.
*/
void QCPLayout::sizeConstraintsChanged() const {
  if (QWidget *w = qobject_cast<QWidget *>(parent()))
    w->updateGeometry();
  else if (QCPLayout *l = qobject_cast<QCPLayout *>(parent()))
    l->sizeConstraintsChanged();
}

/*! \internal

  Subclasses reimplement this method to update the position and sizes of the
  child elements/cells via calling their \ref QCPLayoutElement::setOuterRect.
  The default implementation does nothing.

  The geometry used as a reference is the inner \ref rect of this layout. Child
  elements should stay within that rect.

  \ref getSectionSizes may help with the reimplementation of this function.

  \see update
*/
void QCPLayout::updateLayout() {}

/*! \internal

  Associates \a el with this layout. This is done by setting the \ref
  QCPLayoutElement::layout, the \ref QCPLayerable::parentLayerable and the
  QObject parent to this layout.

  Further, if \a el didn't previously have a parent plot, calls \ref
  QCPLayerable::initializeParentPlot on \a el to set the paret plot.

  This method is used by subclass specific methods that add elements to the
  layout. Note that this method only changes properties in \a el. The removal
  from the old layout and the insertion into the new layout must be done
  additionally.
*/
void QCPLayout::adoptElement(QCPLayoutElement *el) {
  if (el) {
    el->mParentLayout = this;
    el->setParentLayerable(this);
    el->setParent(this);
    if (!el->parentPlot()) el->initializeParentPlot(mParentPlot);
  } else
    qDebug() << Q_FUNC_INFO << "Null element passed";
}

/*! \internal

  Disassociates \a el from this layout. This is done by setting the \ref
  QCPLayoutElement::layout and the \ref QCPLayerable::parentLayerable to zero.
  The QObject parent is set to the parent QCustomPlot.

  This method is used by subclass specific methods that remove elements from the
  layout (e.g. \ref take or \ref takeAt). Note that this method only changes
  properties in \a el. The removal from the old layout must be done
  additionally.
*/
void QCPLayout::releaseElement(QCPLayoutElement *el) {
  if (el) {
    el->mParentLayout = 0;
    el->setParentLayerable(0);
    el->setParent(mParentPlot);
    // Note: Don't initializeParentPlot(0) here, because layout element will
    // stay in same parent plot
  } else
    qDebug() << Q_FUNC_INFO << "Null element passed";
}

/*! \internal

  This is a helper function for the implementation of \ref updateLayout in
  subclasses.

  It calculates the sizes of one-dimensional sections with provided constraints
  on maximum section sizes, minimum section sizes, relative stretch factors and
  the final total size of all sections.

  The QVector entries refer to the sections. Thus all QVectors must have the
  same size.

  \a maxSizes gives the maximum allowed size of each section. If there shall be
  no maximum size imposed, set all vector values to Qt's QWIDGETSIZE_MAX.

  \a minSizes gives the minimum allowed size of each section. If there shall be
  no minimum size imposed, set all vector values to zero. If the \a minSizes
  entries add up to a value greater than \a totalSize, sections will be scaled
  smaller than the proposed minimum sizes. (In other words, not exceeding the
  allowed total size is taken to be more important than not going below minimum
  section sizes.)

  \a stretchFactors give the relative proportions of the sections to each other.
  If all sections shall be scaled equally, set all values equal. If the first
  section shall be double the size of each individual other section, set the
  first number of \a stretchFactors to double the value of the other individual
  values (e.g. {2, 1, 1, 1}).

  \a totalSize is the value that the final section sizes will add up to. Due to
  rounding, the actual sum may differ slightly. If you want the section sizes to
  sum up to exactly that value, you could distribute the remaining difference on
  the sections.

  The return value is a QVector containing the section sizes.
*/
QVector<int> QCPLayout::getSectionSizes(QVector<int> maxSizes,
                                        QVector<int> minSizes,
                                        QVector<double> stretchFactors,
                                        int totalSize) const {
  if (maxSizes.size() != minSizes.size() ||
      minSizes.size() != stretchFactors.size()) {
    qDebug() << Q_FUNC_INFO << "Passed vector sizes aren't equal:" << maxSizes
             << minSizes << stretchFactors;
    return QVector<int>();
  }
  if (stretchFactors.isEmpty()) return QVector<int>();
  int sectionCount = stretchFactors.size();
  QVector<double> sectionSizes(sectionCount);
  // if provided total size is forced smaller than total minimum size, ignore
  // minimum sizes (squeeze sections):
  int minSizeSum = 0;
  for (int i = 0; i < sectionCount; ++i) minSizeSum += minSizes.at(i);
  if (totalSize < minSizeSum) {
    // new stretch factors are minimum sizes and minimum sizes are set to zero:
    for (int i = 0; i < sectionCount; ++i) {
      stretchFactors[i] = minSizes.at(i);
      minSizes[i] = 0;
    }
  }

  QList<int> minimumLockedSections;
  QList<int> unfinishedSections;
  for (int i = 0; i < sectionCount; ++i) unfinishedSections.append(i);
  double freeSize = totalSize;

  int outerIterations = 0;
  while (!unfinishedSections.isEmpty() &&
         outerIterations <
             sectionCount * 2)  // the iteration check ist just a failsafe in
                                // case something really strange happens
  {
    ++outerIterations;
    int innerIterations = 0;
    while (!unfinishedSections.isEmpty() &&
           innerIterations <
               sectionCount * 2)  // the iteration check ist just a failsafe in
                                  // case something really strange happens
    {
      ++innerIterations;
      // find section that hits its maximum next:
      int nextId = -1;
      double nextMax = 1e12;
      for (int i = 0; i < unfinishedSections.size(); ++i) {
        int secId = unfinishedSections.at(i);
        double hitsMaxAt = (maxSizes.at(secId) - sectionSizes.at(secId)) /
                           stretchFactors.at(secId);
        if (hitsMaxAt < nextMax) {
          nextMax = hitsMaxAt;
          nextId = secId;
        }
      }
      // check if that maximum is actually within the bounds of the total size
      // (i.e. can we stretch all remaining sections so far that the found
      // section actually hits its maximum, without exceeding the total size
      // when we add up all sections)
      double stretchFactorSum = 0;
      for (int i = 0; i < unfinishedSections.size(); ++i)
        stretchFactorSum += stretchFactors.at(unfinishedSections.at(i));
      double nextMaxLimit = freeSize / stretchFactorSum;
      if (nextMax <
          nextMaxLimit)  // next maximum is actually hit, move forward to that
                         // point and fix the size of that section
      {
        for (int i = 0; i < unfinishedSections.size(); ++i) {
          sectionSizes[unfinishedSections.at(i)] +=
              nextMax * stretchFactors.at(unfinishedSections.at(
                            i));  // increment all sections
          freeSize -= nextMax * stretchFactors.at(unfinishedSections.at(i));
        }
        unfinishedSections.removeOne(
            nextId);  // exclude the section that is now at maximum from further
                      // changes
      } else  // next maximum isn't hit, just distribute rest of free space on
              // remaining sections
      {
        for (int i = 0; i < unfinishedSections.size(); ++i)
          sectionSizes[unfinishedSections.at(i)] +=
              nextMaxLimit * stretchFactors.at(unfinishedSections.at(
                                 i));  // increment all sections
        unfinishedSections.clear();
      }
    }
    if (innerIterations == sectionCount * 2)
      qDebug() << Q_FUNC_INFO
               << "Exceeded maximum expected inner iteration count, layouting "
                  "aborted. Input was:"
               << maxSizes << minSizes << stretchFactors << totalSize;

    // now check whether the resulting section sizes violate minimum
    // restrictions:
    bool foundMinimumViolation = false;
    for (int i = 0; i < sectionSizes.size(); ++i) {
      if (minimumLockedSections.contains(i)) continue;
      if (sectionSizes.at(i) < minSizes.at(i))  // section violates minimum
      {
        sectionSizes[i] = minSizes.at(i);  // set it to minimum
        foundMinimumViolation =
            true;  // make sure we repeat the whole optimization process
        minimumLockedSections.append(i);
      }
    }
    if (foundMinimumViolation) {
      freeSize = totalSize;
      for (int i = 0; i < sectionCount; ++i) {
        if (!minimumLockedSections.contains(
                i))  // only put sections that haven't hit their minimum back
                     // into the pool
          unfinishedSections.append(i);
        else
          freeSize -=
              sectionSizes.at(i);  // remove size of minimum locked sections
                                   // from available space in next round
      }
      // reset all section sizes to zero that are in unfinished sections (all
      // others have been set to their minimum):
      for (int i = 0; i < unfinishedSections.size(); ++i)
        sectionSizes[unfinishedSections.at(i)] = 0;
    }
  }
  if (outerIterations == sectionCount * 2)
    qDebug() << Q_FUNC_INFO
             << "Exceeded maximum expected outer iteration count, layouting "
                "aborted. Input was:"
             << maxSizes << minSizes << stretchFactors << totalSize;

  QVector<int> result(sectionCount);
  for (int i = 0; i < sectionCount; ++i) result[i] = qRound(sectionSizes.at(i));
  return result;
}

////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////// QCPLayoutGrid
////////////////////////////////////////////////////////////////////////////////////////////////////

/*! \class QCPLayoutGrid
  \brief A layout that arranges child elements in a grid

  Elements are laid out in a grid with configurable stretch factors (\ref
  setColumnStretchFactor, \ref setRowStretchFactor) and spacing (\ref
  setColumnSpacing, \ref setRowSpacing).

  Elements can be added to cells via \ref addElement. The grid is expanded if
  the specified row or column doesn't exist yet. Whether a cell contains a valid
  layout element can be checked with \ref hasElement, that element can be
  retrieved with \ref element. If rows and columns that only have empty cells
  shall be removed, call \ref simplify. Removal of elements is either done by
  just adding the element to a different layout or by using the QCPLayout
  interface \ref take or \ref remove.

  Row and column insertion can be performed with \ref insertRow and \ref
  insertColumn.
*/

/*!
  Creates an instance of QCPLayoutGrid and sets default values.
*/
QCPLayoutGrid::QCPLayoutGrid() : mColumnSpacing(5), mRowSpacing(5) {}

QCPLayoutGrid::~QCPLayoutGrid() {
  // clear all child layout elements. This is important because only the
  // specific layouts know how to handle removing elements (clear calls virtual
  // removeAt method to do that).
  clear();
}

/*!
  Returns the element in the cell in \a row and \a column.

  Returns 0 if either the row/column is invalid or if the cell is empty. In
  those cases, a qDebug message is printed. To check whether a cell exists and
  isn't empty, use \ref hasElement.

  \see addElement, hasElement
*/
QCPLayoutElement *QCPLayoutGrid::element(int row, int column) const {
  if (row >= 0 && row < mElements.size()) {
    if (column >= 0 && column < mElements.first().size()) {
      if (QCPLayoutElement *result = mElements.at(row).at(column))
        return result;
      else
        qDebug() << Q_FUNC_INFO << "Requested cell is empty. Row:" << row
                 << "Column:" << column;
    } else
      qDebug() << Q_FUNC_INFO << "Invalid column. Row:" << row
               << "Column:" << column;
  } else
    qDebug() << Q_FUNC_INFO << "Invalid row. Row:" << row
             << "Column:" << column;
  return 0;
}

/*!
  Returns the number of rows in the layout.

  \see columnCount
*/
int QCPLayoutGrid::rowCount() const { return mElements.size(); }

/*!
  Returns the number of columns in the layout.

  \see rowCount
*/
int QCPLayoutGrid::columnCount() const {
  if (mElements.size() > 0)
    return mElements.first().size();
  else
    return 0;
}

/*!
  Adds the \a element to cell with \a row and \a column. If \a element is
  already in a layout, it is first removed from there. If \a row or \a column
  don't exist yet, the layout is expanded accordingly.

  Returns true if the element was added successfully, i.e. if the cell at \a row
  and \a column didn't already have an element.

  \see element, hasElement, take, remove
*/
bool QCPLayoutGrid::addElement(int row, int column, QCPLayoutElement *element) {
  if (element) {
    if (!hasElement(row, column)) {
      if (element->layout())  // remove from old layout first
        element->layout()->take(element);
      expandTo(row + 1, column + 1);
      mElements[row][column] = element;
      adoptElement(element);
      return true;
    } else
      qDebug() << Q_FUNC_INFO
               << "There is already an element in the specified row/column:"
               << row << column;
  } else
    qDebug() << Q_FUNC_INFO << "Can't add null element to row/column:" << row
             << column;
  return false;
}

/*!
  Returns whether the cell at \a row and \a column exists and contains a valid
  element, i.e. isn't empty.

  \see element
*/
bool QCPLayoutGrid::hasElement(int row, int column) {
  if (row >= 0 && row < rowCount() && column >= 0 && column < columnCount())
    return mElements.at(row).at(column);
  else
    return false;
}

/*!
  Sets the stretch \a factor of \a column.

  Stretch factors control the relative sizes of rows and columns. Cells will not
  be resized beyond their minimum and maximum widths/heights (\ref
  QCPLayoutElement::setMinimumSize, \ref QCPLayoutElement::setMaximumSize),
  regardless of the stretch factor.

  The default stretch factor of newly created rows/columns is 1.

  \see setColumnStretchFactors, setRowStretchFactor
*/
void QCPLayoutGrid::setColumnStretchFactor(int column, double factor) {
  if (column >= 0 && column < columnCount()) {
    if (factor > 0)
      mColumnStretchFactors[column] = factor;
    else
      qDebug() << Q_FUNC_INFO
               << "Invalid stretch factor, must be positive:" << factor;
  } else
    qDebug() << Q_FUNC_INFO << "Invalid column:" << column;
}

/*!
  Sets the stretch \a factors of all columns. \a factors must have the size \ref
  columnCount.

  Stretch factors control the relative sizes of rows and columns. Cells will not
  be resized beyond their minimum and maximum widths/heights (\ref
  QCPLayoutElement::setMinimumSize, \ref QCPLayoutElement::setMaximumSize),
  regardless of the stretch factor.

  The default stretch factor of newly created rows/columns is 1.

  \see setColumnStretchFactor, setRowStretchFactors
*/
void QCPLayoutGrid::setColumnStretchFactors(const QList<double> &factors) {
  if (factors.size() == mColumnStretchFactors.size()) {
    mColumnStretchFactors = factors;
    for (int i = 0; i < mColumnStretchFactors.size(); ++i) {
      if (mColumnStretchFactors.at(i) <= 0) {
        qDebug() << Q_FUNC_INFO << "Invalid stretch factor, must be positive:"
                 << mColumnStretchFactors.at(i);
        mColumnStretchFactors[i] = 1;
      }
    }
  } else
    qDebug() << Q_FUNC_INFO
             << "Column count not equal to passed stretch factor count:"
             << factors;
}

/*!
  Sets the stretch \a factor of \a row.

  Stretch factors control the relative sizes of rows and columns. Cells will not
  be resized beyond their minimum and maximum widths/heights (\ref
  QCPLayoutElement::setMinimumSize, \ref QCPLayoutElement::setMaximumSize),
  regardless of the stretch factor.

  The default stretch factor of newly created rows/columns is 1.

  \see setColumnStretchFactors, setRowStretchFactor
*/
void QCPLayoutGrid::setRowStretchFactor(int row, double factor) {
  if (row >= 0 && row < rowCount()) {
    if (factor > 0)
      mRowStretchFactors[row] = factor;
    else
      qDebug() << Q_FUNC_INFO
               << "Invalid stretch factor, must be positive:" << factor;
  } else
    qDebug() << Q_FUNC_INFO << "Invalid row:" << row;
}

/*!
  Sets the stretch \a factors of all rows. \a factors must have the size \ref
  rowCount.

  Stretch factors control the relative sizes of rows and columns. Cells will not
  be resized beyond their minimum and maximum widths/heights (\ref
  QCPLayoutElement::setMinimumSize, \ref QCPLayoutElement::setMaximumSize),
  regardless of the stretch factor.

  The default stretch factor of newly created rows/columns is 1.

  \see setRowStretchFactor, setColumnStretchFactors
*/
void QCPLayoutGrid::setRowStretchFactors(const QList<double> &factors) {
  if (factors.size() == mRowStretchFactors.size()) {
    mRowStretchFactors = factors;
    for (int i = 0; i < mRowStretchFactors.size(); ++i) {
      if (mRowStretchFactors.at(i) <= 0) {
        qDebug() << Q_FUNC_INFO << "Invalid stretch factor, must be positive:"
                 << mRowStretchFactors.at(i);
        mRowStretchFactors[i] = 1;
      }
    }
  } else
    qDebug() << Q_FUNC_INFO
             << "Row count not equal to passed stretch factor count:"
             << factors;
}

/*!
  Sets the gap that is left blank between columns to \a pixels.

  \see setRowSpacing
*/
void QCPLayoutGrid::setColumnSpacing(int pixels) { mColumnSpacing = pixels; }

/*!
  Sets the gap that is left blank between rows to \a pixels.

  \see setColumnSpacing
*/
void QCPLayoutGrid::setRowSpacing(int pixels) { mRowSpacing = pixels; }

/*!
  Expands the layout to have \a newRowCount rows and \a newColumnCount columns.
  So the last valid row index will be \a newRowCount-1, the last valid column
  index will be \a newColumnCount-1.

  If the current column/row count is already larger or equal to \a
  newColumnCount/\a newRowCount, this function does nothing in that dimension.

  Newly created cells are empty, new rows and columns have the stretch factor 1.

  Note that upon a call to \ref addElement, the layout is expanded automatically
  to contain the specified row and column, using this function.

  \see simplify
*/
void QCPLayoutGrid::expandTo(int newRowCount, int newColumnCount) {
  // add rows as necessary:
  while (rowCount() < newRowCount) {
    mElements.append(QList<QCPLayoutElement *>());
    mRowStretchFactors.append(1);
  }
  // go through rows and expand columns as necessary:
  int newColCount = qMax(columnCount(), newColumnCount);
  for (int i = 0; i < rowCount(); ++i) {
    while (mElements.at(i).size() < newColCount) mElements[i].append(0);
  }
  while (mColumnStretchFactors.size() < newColCount)
    mColumnStretchFactors.append(1);
}

/*!
  Inserts a new row with empty cells at the row index \a newIndex. Valid values
  for \a newIndex range from 0 (inserts a row at the top) to \a rowCount
  (appends a row at the bottom).

  \see insertColumn
*/
void QCPLayoutGrid::insertRow(int newIndex) {
  if (mElements.isEmpty() ||
      mElements.first()
          .isEmpty())  // if grid is completely empty, add first cell
  {
    expandTo(1, 1);
    return;
  }

  if (newIndex < 0) newIndex = 0;
  if (newIndex > rowCount()) newIndex = rowCount();

  mRowStretchFactors.insert(newIndex, 1);
  QList<QCPLayoutElement *> newRow;
  for (int col = 0; col < columnCount(); ++col)
    newRow.append((QCPLayoutElement *)0);
  mElements.insert(newIndex, newRow);
}

/*!
  Inserts a new column with empty cells at the column index \a newIndex. Valid
  values for \a newIndex range from 0 (inserts a row at the left) to \a rowCount
  (appends a row at the right).

  \see insertRow
*/
void QCPLayoutGrid::insertColumn(int newIndex) {
  if (mElements.isEmpty() ||
      mElements.first()
          .isEmpty())  // if grid is completely empty, add first cell
  {
    expandTo(1, 1);
    return;
  }

  if (newIndex < 0) newIndex = 0;
  if (newIndex > columnCount()) newIndex = columnCount();

  mColumnStretchFactors.insert(newIndex, 1);
  for (int row = 0; row < rowCount(); ++row)
    mElements[row].insert(newIndex, (QCPLayoutElement *)0);
}

/* inherits documentation from base class */
void QCPLayoutGrid::updateLayout() {
  QVector<int> minColWidths, minRowHeights, maxColWidths, maxRowHeights;
  getMinimumRowColSizes(&minColWidths, &minRowHeights);
  getMaximumRowColSizes(&maxColWidths, &maxRowHeights);

  int totalRowSpacing = (rowCount() - 1) * mRowSpacing;
  int totalColSpacing = (columnCount() - 1) * mColumnSpacing;
  QVector<int> colWidths = getSectionSizes(maxColWidths, minColWidths,
                                           mColumnStretchFactors.toVector(),
                                           mRect.width() - totalColSpacing);
  QVector<int> rowHeights = getSectionSizes(maxRowHeights, minRowHeights,
                                            mRowStretchFactors.toVector(),
                                            mRect.height() - totalRowSpacing);

  // go through cells and set rects accordingly:
  int yOffset = mRect.top();
  for (int row = 0; row < rowCount(); ++row) {
    if (row > 0) yOffset += rowHeights.at(row - 1) + mRowSpacing;
    int xOffset = mRect.left();
    for (int col = 0; col < columnCount(); ++col) {
      if (col > 0) xOffset += colWidths.at(col - 1) + mColumnSpacing;
      if (mElements.at(row).at(col))
        mElements.at(row).at(col)->setOuterRect(
            QRect(xOffset, yOffset, colWidths.at(col), rowHeights.at(row)));
    }
  }
}

/* inherits documentation from base class */
int QCPLayoutGrid::elementCount() const { return rowCount() * columnCount(); }

/* inherits documentation from base class */
QCPLayoutElement *QCPLayoutGrid::elementAt(int index) const {
  if (index >= 0 && index < elementCount())
    return mElements.at(index / columnCount()).at(index % columnCount());
  else
    return 0;
}

/* inherits documentation from base class */
QCPLayoutElement *QCPLayoutGrid::takeAt(int index) {
  if (QCPLayoutElement *el = elementAt(index)) {
    releaseElement(el);
    mElements[index / columnCount()][index % columnCount()] = 0;
    return el;
  } else {
    qDebug() << Q_FUNC_INFO << "Attempt to take invalid index:" << index;
    return 0;
  }
}

/* inherits documentation from base class */
bool QCPLayoutGrid::take(QCPLayoutElement *element) {
  if (element) {
    for (int i = 0; i < elementCount(); ++i) {
      if (elementAt(i) == element) {
        takeAt(i);
        return true;
      }
    }
    qDebug() << Q_FUNC_INFO << "Element not in this layout, couldn't take";
  } else
    qDebug() << Q_FUNC_INFO << "Can't take null element";
  return false;
}

/* inherits documentation from base class */
QList<QCPLayoutElement *> QCPLayoutGrid::elements(bool recursive) const {
  QList<QCPLayoutElement *> result;
  int colC = columnCount();
  int rowC = rowCount();
#if QT_VERSION >= QT_VERSION_CHECK(4, 7, 0)
  result.reserve(colC * rowC);
#endif
  for (int row = 0; row < rowC; ++row) {
    for (int col = 0; col < colC; ++col) {
      result.append(mElements.at(row).at(col));
    }
  }
  if (recursive) {
    int c = result.size();
    for (int i = 0; i < c; ++i) {
      if (result.at(i)) result << result.at(i)->elements(recursive);
    }
  }
  return result;
}

/*!
  Simplifies the layout by collapsing rows and columns which only contain empty
  cells.
*/
void QCPLayoutGrid::simplify() {
  // remove rows with only empty cells:
  for (int row = rowCount() - 1; row >= 0; --row) {
    bool hasElements = false;
    for (int col = 0; col < columnCount(); ++col) {
      if (mElements.at(row).at(col)) {
        hasElements = true;
        break;
      }
    }
    if (!hasElements) {
      mRowStretchFactors.removeAt(row);
      mElements.removeAt(row);
      if (mElements.isEmpty())  // removed last element, also remove stretch
                                // factor (wouldn't happen below because also
                                // columnCount changed to 0 now)
        mColumnStretchFactors.clear();
    }
  }

  // remove columns with only empty cells:
  for (int col = columnCount() - 1; col >= 0; --col) {
    bool hasElements = false;
    for (int row = 0; row < rowCount(); ++row) {
      if (mElements.at(row).at(col)) {
        hasElements = true;
        break;
      }
    }
    if (!hasElements) {
      mColumnStretchFactors.removeAt(col);
      for (int row = 0; row < rowCount(); ++row) mElements[row].removeAt(col);
    }
  }
}

/* inherits documentation from base class */
QSize QCPLayoutGrid::minimumSizeHint() const {
  QVector<int> minColWidths, minRowHeights;
  getMinimumRowColSizes(&minColWidths, &minRowHeights);
  QSize result(0, 0);
  for (int i = 0; i < minColWidths.size(); ++i)
    result.rwidth() += minColWidths.at(i);
  for (int i = 0; i < minRowHeights.size(); ++i)
    result.rheight() += minRowHeights.at(i);
  result.rwidth() += qMax(0, columnCount() - 1) * mColumnSpacing +
                     mMargins.left() + mMargins.right();
  result.rheight() += qMax(0, rowCount() - 1) * mRowSpacing + mMargins.top() +
                      mMargins.bottom();
  return result;
}

/* inherits documentation from base class */
QSize QCPLayoutGrid::maximumSizeHint() const {
  QVector<int> maxColWidths, maxRowHeights;
  getMaximumRowColSizes(&maxColWidths, &maxRowHeights);

  QSize result(0, 0);
  for (int i = 0; i < maxColWidths.size(); ++i)
    result.setWidth(qMin(result.width() + maxColWidths.at(i), QWIDGETSIZE_MAX));
  for (int i = 0; i < maxRowHeights.size(); ++i)
    result.setHeight(
        qMin(result.height() + maxRowHeights.at(i), QWIDGETSIZE_MAX));
  result.rwidth() += qMax(0, columnCount() - 1) * mColumnSpacing +
                     mMargins.left() + mMargins.right();
  result.rheight() += qMax(0, rowCount() - 1) * mRowSpacing + mMargins.top() +
                      mMargins.bottom();
  return result;
}

/*! \internal

  Places the minimum column widths and row heights into \a minColWidths and \a
  minRowHeights respectively.

  The minimum height of a row is the largest minimum height of any element in
  that row. The minimum width of a column is the largest minimum width of any
  element in that column.

  This is a helper function for \ref updateLayout.

  \see getMaximumRowColSizes
*/
void QCPLayoutGrid::getMinimumRowColSizes(QVector<int> *minColWidths,
                                          QVector<int> *minRowHeights) const {
  *minColWidths = QVector<int>(columnCount(), 0);
  *minRowHeights = QVector<int>(rowCount(), 0);
  for (int row = 0; row < rowCount(); ++row) {
    for (int col = 0; col < columnCount(); ++col) {
      if (mElements.at(row).at(col)) {
        QSize minHint = mElements.at(row).at(col)->minimumSizeHint();
        QSize min = mElements.at(row).at(col)->minimumSize();
        QSize final(min.width() > 0 ? min.width() : minHint.width(),
                    min.height() > 0 ? min.height() : minHint.height());
        if (minColWidths->at(col) < final.width())
          (*minColWidths)[col] = final.width();
        if (minRowHeights->at(row) < final.height())
          (*minRowHeights)[row] = final.height();
      }
    }
  }
}

/*! \internal

  Places the maximum column widths and row heights into \a maxColWidths and \a
  maxRowHeights respectively.

  The maximum height of a row is the smallest maximum height of any element in
  that row. The maximum width of a column is the smallest maximum width of any
  element in that column.

  This is a helper function for \ref updateLayout.

  \see getMinimumRowColSizes
*/
void QCPLayoutGrid::getMaximumRowColSizes(QVector<int> *maxColWidths,
                                          QVector<int> *maxRowHeights) const {
  *maxColWidths = QVector<int>(columnCount(), QWIDGETSIZE_MAX);
  *maxRowHeights = QVector<int>(rowCount(), QWIDGETSIZE_MAX);
  for (int row = 0; row < rowCount(); ++row) {
    for (int col = 0; col < columnCount(); ++col) {
      if (mElements.at(row).at(col)) {
        QSize maxHint = mElements.at(row).at(col)->maximumSizeHint();
        QSize max = mElements.at(row).at(col)->maximumSize();
        QSize final(
            max.width() < QWIDGETSIZE_MAX ? max.width() : maxHint.width(),
            max.height() < QWIDGETSIZE_MAX ? max.height() : maxHint.height());
        if (maxColWidths->at(col) > final.width())
          (*maxColWidths)[col] = final.width();
        if (maxRowHeights->at(row) > final.height())
          (*maxRowHeights)[row] = final.height();
      }
    }
  }
}

////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////// QCPLayoutInset
////////////////////////////////////////////////////////////////////////////////////////////////////
/*! \class QCPLayoutInset
  \brief A layout that places child elements aligned to the border or
  arbitrarily positioned

  Elements are placed either aligned to the border or at arbitrary position in
  the area of the layout. Which placement applies is controlled with the \ref
  InsetPlacement (\ref setInsetPlacement).

  Elements are added via \ref addElement(QCPLayoutElement *element,
  Qt::Alignment alignment) or addElement(QCPLayoutElement *element, const QRectF
  &rect). If the first method is used, the inset placement will default to \ref
  ipBorderAligned and the element will be aligned according to the \a alignment
  parameter. The second method defaults to \ref ipFree and allows placing
  elements at arbitrary position and size, defined by \a rect.

  The alignment or rect can be set via \ref setInsetAlignment or \ref
  setInsetRect, respectively.

  This is the layout that every QCPAxisRect has as \ref
  QCPAxisRect::insetLayout.
*/

/* start documentation of inline functions */

/*! \fn virtual void QCPLayoutInset::simplify()

  The QCPInsetLayout does not need simplification since it can never have empty
  cells due to its linear index structure. This method does nothing.
*/

/* end documentation of inline functions */

/*!
  Creates an instance of QCPLayoutInset and sets default values.
*/
QCPLayoutInset::QCPLayoutInset() {}

QCPLayoutInset::~QCPLayoutInset() {
  // clear all child layout elements. This is important because only the
  // specific layouts know how to handle removing elements (clear calls virtual
  // removeAt method to do that).
  clear();
}

/*!
  Returns the placement type of the element with the specified \a index.
*/
QCPLayoutInset::InsetPlacement QCPLayoutInset::insetPlacement(int index) const {
  if (elementAt(index))
    return mInsetPlacement.at(index);
  else {
    qDebug() << Q_FUNC_INFO << "Invalid element index:" << index;
    return ipFree;
  }
}

/*!
  Returns the alignment of the element with the specified \a index. The
  alignment only has a meaning, if the inset placement (\ref setInsetPlacement)
  is \ref ipBorderAligned.
*/
Qt::Alignment QCPLayoutInset::insetAlignment(int index) const {
  if (elementAt(index))
    return mInsetAlignment.at(index);
  else {
    qDebug() << Q_FUNC_INFO << "Invalid element index:" << index;
    return 0;
  }
}

/*!
  Returns the rect of the element with the specified \a index. The rect only has
  a meaning, if the inset placement (\ref setInsetPlacement) is \ref ipFree.
*/
QRectF QCPLayoutInset::insetRect(int index) const {
  if (elementAt(index))
    return mInsetRect.at(index);
  else {
    qDebug() << Q_FUNC_INFO << "Invalid element index:" << index;
    return QRectF();
  }
}

/*!
  Sets the inset placement type of the element with the specified \a index to \a
  placement.

  \see InsetPlacement
*/
void QCPLayoutInset::setInsetPlacement(
    int index, QCPLayoutInset::InsetPlacement placement) {
  if (elementAt(index))
    mInsetPlacement[index] = placement;
  else
    qDebug() << Q_FUNC_INFO << "Invalid element index:" << index;
}

/*!
  If the inset placement (\ref setInsetPlacement) is \ref ipBorderAligned, this
  function is used to set the alignment of the element with the specified \a
  index to \a alignment.

  \a alignment is an or combination of the following alignment flags:
  Qt::AlignLeft, Qt::AlignHCenter, Qt::AlighRight, Qt::AlignTop,
  Qt::AlignVCenter, Qt::AlignBottom. Any other alignment flags will be ignored.
*/
void QCPLayoutInset::setInsetAlignment(int index, Qt::Alignment alignment) {
  if (elementAt(index))
    mInsetAlignment[index] = alignment;
  else
    qDebug() << Q_FUNC_INFO << "Invalid element index:" << index;
}

/*!
  If the inset placement (\ref setInsetPlacement) is \ref ipFree, this function
  is used to set the position and size of the element with the specified \a
  index to \a rect.

  \a rect is given in fractions of the whole inset layout rect. So an inset with
  rect (0, 0, 1, 1) will span the entire layout. An inset with rect (0.6, 0.1,
  0.35, 0.35) will be in the top right corner of the layout, with 35% width and
  height of the parent layout.

  Note that the minimum and maximum sizes of the embedded element (\ref
  QCPLayoutElement::setMinimumSize, \ref QCPLayoutElement::setMaximumSize) are
  enforced.
*/
void QCPLayoutInset::setInsetRect(int index, const QRectF &rect) {
  if (elementAt(index))
    mInsetRect[index] = rect;
  else
    qDebug() << Q_FUNC_INFO << "Invalid element index:" << index;
}

/* inherits documentation from base class */
void QCPLayoutInset::updateLayout() {
  for (int i = 0; i < mElements.size(); ++i) {
    QRect insetRect;
    QSize finalMinSize, finalMaxSize;
    QSize minSizeHint = mElements.at(i)->minimumSizeHint();
    QSize maxSizeHint = mElements.at(i)->maximumSizeHint();
    finalMinSize.setWidth(mElements.at(i)->minimumSize().width() > 0
                              ? mElements.at(i)->minimumSize().width()
                              : minSizeHint.width());
    finalMinSize.setHeight(mElements.at(i)->minimumSize().height() > 0
                               ? mElements.at(i)->minimumSize().height()
                               : minSizeHint.height());
    finalMaxSize.setWidth(mElements.at(i)->maximumSize().width() <
                                  QWIDGETSIZE_MAX
                              ? mElements.at(i)->maximumSize().width()
                              : maxSizeHint.width());
    finalMaxSize.setHeight(mElements.at(i)->maximumSize().height() <
                                   QWIDGETSIZE_MAX
                               ? mElements.at(i)->maximumSize().height()
                               : maxSizeHint.height());
    if (mInsetPlacement.at(i) == ipFree) {
      insetRect = QRect(rect().x() + rect().width() * mInsetRect.at(i).x(),
                        rect().y() + rect().height() * mInsetRect.at(i).y(),
                        rect().width() * mInsetRect.at(i).width(),
                        rect().height() * mInsetRect.at(i).height());
      if (insetRect.size().width() < finalMinSize.width())
        insetRect.setWidth(finalMinSize.width());
      if (insetRect.size().height() < finalMinSize.height())
        insetRect.setHeight(finalMinSize.height());
      if (insetRect.size().width() > finalMaxSize.width())
        insetRect.setWidth(finalMaxSize.width());
      if (insetRect.size().height() > finalMaxSize.height())
        insetRect.setHeight(finalMaxSize.height());
    } else if (mInsetPlacement.at(i) == ipBorderAligned) {
      insetRect.setSize(finalMinSize);
      Qt::Alignment al = mInsetAlignment.at(i);
      if (al.testFlag(Qt::AlignLeft))
        insetRect.moveLeft(rect().x());
      else if (al.testFlag(Qt::AlignRight))
        insetRect.moveRight(rect().x() + rect().width());
      else
        insetRect.moveLeft(rect().x() + rect().width() * 0.5 -
                           finalMinSize.width() *
                               0.5);  // default to Qt::AlignHCenter
      if (al.testFlag(Qt::AlignTop))
        insetRect.moveTop(rect().y());
      else if (al.testFlag(Qt::AlignBottom))
        insetRect.moveBottom(rect().y() + rect().height());
      else
        insetRect.moveTop(rect().y() + rect().height() * 0.5 -
                          finalMinSize.height() *
                              0.5);  // default to Qt::AlignVCenter
    }
    mElements.at(i)->setOuterRect(insetRect);
  }
}

/* inherits documentation from base class */
int QCPLayoutInset::elementCount() const { return mElements.size(); }

/* inherits documentation from base class */
QCPLayoutElement *QCPLayoutInset::elementAt(int index) const {
  if (index >= 0 && index < mElements.size())
    return mElements.at(index);
  else
    return 0;
}

/* inherits documentation from base class */
QCPLayoutElement *QCPLayoutInset::takeAt(int index) {
  if (QCPLayoutElement *el = elementAt(index)) {
    releaseElement(el);
    mElements.removeAt(index);
    mInsetPlacement.removeAt(index);
    mInsetAlignment.removeAt(index);
    mInsetRect.removeAt(index);
    return el;
  } else {
    qDebug() << Q_FUNC_INFO << "Attempt to take invalid index:" << index;
    return 0;
  }
}

/* inherits documentation from base class */
bool QCPLayoutInset::take(QCPLayoutElement *element) {
  if (element) {
    for (int i = 0; i < elementCount(); ++i) {
      if (elementAt(i) == element) {
        takeAt(i);
        return true;
      }
    }
    qDebug() << Q_FUNC_INFO << "Element not in this layout, couldn't take";
  } else
    qDebug() << Q_FUNC_INFO << "Can't take null element";
  return false;
}

/*!
  The inset layout is sensitive to events only at areas where its (visible)
  child elements are sensitive. If the selectTest method of any of the child
  elements returns a positive number for \a pos, this method returns a value
  corresponding to 0.99 times the parent plot's selection tolerance. The inset
  layout is not selectable itself by default. So if \a onlySelectable is true,
  -1.0 is returned.

  See \ref QCPLayerable::selectTest for a general explanation of this virtual
  method.
*/
double QCPLayoutInset::selectTest(const QPointF &pos, bool onlySelectable,
                                  QVariant *details) const {
  Q_UNUSED(details)
  if (onlySelectable) return -1;

  for (int i = 0; i < mElements.size(); ++i) {
    // inset layout shall only return positive selectTest, if actually an inset
    // object is at pos else it would block the entire underlying QCPAxisRect
    // with its surface.
    if (mElements.at(i)->realVisibility() &&
        mElements.at(i)->selectTest(pos, onlySelectable) >= 0)
      return mParentPlot->selectionTolerance() * 0.99;
  }
  return -1;
}

/*!
  Adds the specified \a element to the layout as an inset aligned at the border
  (\ref setInsetAlignment is initialized with \ref ipBorderAligned). The
  alignment is set to \a alignment.

  \a alignment is an or combination of the following alignment flags:
  Qt::AlignLeft, Qt::AlignHCenter, Qt::AlighRight, Qt::AlignTop,
  Qt::AlignVCenter, Qt::AlignBottom. Any other alignment flags will be ignored.

  \see addElement(QCPLayoutElement *element, const QRectF &rect)
*/
void QCPLayoutInset::addElement(QCPLayoutElement *element,
                                Qt::Alignment alignment) {
  if (element) {
    if (element->layout())  // remove from old layout first
      element->layout()->take(element);
    mElements.append(element);
    mInsetPlacement.append(ipBorderAligned);
    mInsetAlignment.append(alignment);
    mInsetRect.append(QRectF(0.6, 0.6, 0.4, 0.4));
    adoptElement(element);
  } else
    qDebug() << Q_FUNC_INFO << "Can't add null element";
}

/*!
  Adds the specified \a element to the layout as an inset with free
  positioning/sizing (\ref setInsetAlignment is initialized with \ref ipFree).
  The position and size is set to \a rect.

  \a rect is given in fractions of the whole inset layout rect. So an inset with
  rect (0, 0, 1, 1) will span the entire layout. An inset with rect (0.6, 0.1,
  0.35, 0.35) will be in the top right corner of the layout, with 35% width and
  height of the parent layout.

  \see addElement(QCPLayoutElement *element, Qt::Alignment alignment)
*/
void QCPLayoutInset::addElement(QCPLayoutElement *element, const QRectF &rect) {
  if (element) {
    if (element->layout())  // remove from old layout first
      element->layout()->take(element);
    mElements.append(element);
    mInsetPlacement.append(ipFree);
    mInsetAlignment.append(Qt::AlignRight | Qt::AlignTop);
    mInsetRect.append(rect);
    adoptElement(element);
  } else
    qDebug() << Q_FUNC_INFO << "Can't add null element";
}

////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////// QCPLineEnding
////////////////////////////////////////////////////////////////////////////////////////////////////

/*! \class QCPLineEnding
  \brief Handles the different ending decorations for line-like items

  \image html QCPLineEnding.png "The various ending styles currently supported"

  For every ending a line-like item has, an instance of this class exists. For
  example, QCPItemLine has two endings which can be set with
  QCPItemLine::setHead and QCPItemLine::setTail.

  The styles themselves are defined via the enum QCPLineEnding::EndingStyle.
  Most decorations can be modified regarding width and length, see \ref setWidth
  and \ref setLength. The direction of the ending decoration (e.g. direction an
  arrow is pointing) is controlled by the line-like item. For example, when both
  endings of a QCPItemLine are set to be arrows, they will point to opposite
  directions, e.g. "outward". This can be changed by \ref setInverted, which
  would make the respective arrow point inward.

  Note that due to the overloaded QCPLineEnding constructor, you may directly
  specify a QCPLineEnding::EndingStyle where actually a QCPLineEnding is
  expected, e.g. \snippet documentation/doc-code-snippets/mainwindow.cpp
  qcplineending-sethead
*/

/*!
  Creates a QCPLineEnding instance with default values (style \ref esNone).
*/
QCPLineEnding::QCPLineEnding()
    : mStyle(esNone), mWidth(8), mLength(10), mInverted(false) {}

/*!
  Creates a QCPLineEnding instance with the specified values.
*/
QCPLineEnding::QCPLineEnding(QCPLineEnding::EndingStyle style, double width,
                             double length, bool inverted)
    : mStyle(style), mWidth(width), mLength(length), mInverted(inverted) {}

/*!
  Sets the style of the ending decoration.
*/
void QCPLineEnding::setStyle(QCPLineEnding::EndingStyle style) {
  mStyle = style;
}

/*!
  Sets the width of the ending decoration, if the style supports it. On arrows,
  for example, the width defines the size perpendicular to the arrow's pointing
  direction.

  \see setLength
*/
void QCPLineEnding::setWidth(double width) { mWidth = width; }

/*!
  Sets the length of the ending decoration, if the style supports it. On arrows,
  for example, the length defines the size in pointing direction.

  \see setWidth
*/
void QCPLineEnding::setLength(double length) { mLength = length; }

/*!
  Sets whether the ending decoration shall be inverted. For example, an arrow
  decoration will point inward when \a inverted is set to true.

  Note that also the \a width direction is inverted. For symmetrical ending
  styles like arrows or discs, this doesn't make a difference. However,
  asymmetric styles like \ref esHalfBar are affected by it, which can be used to
  control to which side the half bar points to.
*/
void QCPLineEnding::setInverted(bool inverted) { mInverted = inverted; }

/*! \internal

  Returns the maximum pixel radius the ending decoration might cover, starting
  from the position the decoration is drawn at (typically a line ending/\ref
  QCPItemPosition of an item).

  This is relevant for clipping. Only omit painting of the decoration when the
  position where the decoration is supposed to be drawn is farther away from the
  clipping rect than the returned distance.
*/
double QCPLineEnding::boundingDistance() const {
  switch (mStyle) {
    case esNone:
      return 0;

    case esFlatArrow:
    case esSpikeArrow:
    case esLineArrow:
    case esSkewedBar:
      return qSqrt(mWidth * mWidth +
                   mLength * mLength);  // items that have width and length

    case esDisc:
    case esSquare:
    case esDiamond:
    case esBar:
    case esHalfBar:
      return mWidth * 1.42;  // items that only have a width -> width*sqrt(2)
  }
  return 0;
}

/*!
  Starting from the origin of this line ending (which is style specific),
  returns the length covered by the line ending symbol, in backward direction.

  For example, the \ref esSpikeArrow has a shorter real length than a \ref
  esFlatArrow, even if both have the same \ref setLength value, because the
  spike arrow has an inward curved back, which reduces the length along its
  center axis (the drawing origin for arrows is at the tip).

  This function is used for precise, style specific placement of line endings,
  for example in QCPAxes.
*/
double QCPLineEnding::realLength() const {
  switch (mStyle) {
    case esNone:
    case esLineArrow:
    case esSkewedBar:
    case esBar:
    case esHalfBar:
      return 0;

    case esFlatArrow:
      return mLength;

    case esDisc:
    case esSquare:
    case esDiamond:
      return mWidth * 0.5;

    case esSpikeArrow:
      return mLength * 0.8;
  }
  return 0;
}

/*! \internal

  Draws the line ending with the specified \a painter at the position \a pos.
  The direction of the line ending is controlled with \a dir.
*/
void QCPLineEnding::draw(QCPPainter *painter, const QVector2D &pos,
                         const QVector2D &dir) const {
  if (mStyle == esNone) return;

  QVector2D lengthVec(dir.normalized());
  if (lengthVec.isNull()) lengthVec = QVector2D(1, 0);
  QVector2D widthVec(-lengthVec.y(), lengthVec.x());
  lengthVec *= (float)(mLength * (mInverted ? -1 : 1));
  widthVec *= (float)(mWidth * 0.5 * (mInverted ? -1 : 1));

  QPen penBackup = painter->pen();
  QBrush brushBackup = painter->brush();
  QPen miterPen = penBackup;
  miterPen.setJoinStyle(Qt::MiterJoin);  // to make arrow heads spikey
  QBrush brush(painter->pen().color(), Qt::SolidPattern);
  switch (mStyle) {
    case esNone:
      break;
    case esFlatArrow: {
      QPointF points[3] = {pos.toPointF(),
                           (pos - lengthVec + widthVec).toPointF(),
                           (pos - lengthVec - widthVec).toPointF()};
      painter->setPen(miterPen);
      painter->setBrush(brush);
      painter->drawConvexPolygon(points, 3);
      painter->setBrush(brushBackup);
      painter->setPen(penBackup);
      break;
    }
    case esSpikeArrow: {
      QPointF points[4] = {pos.toPointF(),
                           (pos - lengthVec + widthVec).toPointF(),
                           (pos - lengthVec * 0.8f).toPointF(),
                           (pos - lengthVec - widthVec).toPointF()};
      painter->setPen(miterPen);
      painter->setBrush(brush);
      painter->drawConvexPolygon(points, 4);
      painter->setBrush(brushBackup);
      painter->setPen(penBackup);
      break;
    }
    case esLineArrow: {
      QPointF points[3] = {(pos - lengthVec + widthVec).toPointF(),
                           pos.toPointF(),
                           (pos - lengthVec - widthVec).toPointF()};
      painter->setPen(miterPen);
      painter->drawPolyline(points, 3);
      painter->setPen(penBackup);
      break;
    }
    case esDisc: {
      painter->setBrush(brush);
      painter->drawEllipse(pos.toPointF(), mWidth * 0.5, mWidth * 0.5);
      painter->setBrush(brushBackup);
      break;
    }
    case esSquare: {
      QVector2D widthVecPerp(-widthVec.y(), widthVec.x());
      QPointF points[4] = {(pos - widthVecPerp + widthVec).toPointF(),
                           (pos - widthVecPerp - widthVec).toPointF(),
                           (pos + widthVecPerp - widthVec).toPointF(),
                           (pos + widthVecPerp + widthVec).toPointF()};
      painter->setPen(miterPen);
      painter->setBrush(brush);
      painter->drawConvexPolygon(points, 4);
      painter->setBrush(brushBackup);
      painter->setPen(penBackup);
      break;
    }
    case esDiamond: {
      QVector2D widthVecPerp(-widthVec.y(), widthVec.x());
      QPointF points[4] = {
          (pos - widthVecPerp).toPointF(), (pos - widthVec).toPointF(),
          (pos + widthVecPerp).toPointF(), (pos + widthVec).toPointF()};
      painter->setPen(miterPen);
      painter->setBrush(brush);
      painter->drawConvexPolygon(points, 4);
      painter->setBrush(brushBackup);
      painter->setPen(penBackup);
      break;
    }
    case esBar: {
      painter->drawLine((pos + widthVec).toPointF(),
                        (pos - widthVec).toPointF());
      break;
    }
    case esHalfBar: {
      painter->drawLine((pos + widthVec).toPointF(), pos.toPointF());
      break;
    }
    case esSkewedBar: {
      if (qFuzzyIsNull(painter->pen().widthF()) &&
          !painter->modes().testFlag(QCPPainter::pmNonCosmetic)) {
        // if drawing with cosmetic pen (perfectly thin stroke, happens only in
        // vector exports), draw bar exactly on tip of line
        painter->drawLine(
            (pos + widthVec + lengthVec * 0.2f * (mInverted ? -1 : 1))
                .toPointF(),
            (pos - widthVec - lengthVec * 0.2f * (mInverted ? -1 : 1))
                .toPointF());
      } else {
        // if drawing with thick (non-cosmetic) pen, shift bar a little in line
        // direction to prevent line from sticking through bar slightly
        painter->drawLine(
            (pos + widthVec + lengthVec * 0.2f * (mInverted ? -1 : 1) +
             dir.normalized() * qMax(1.0f, (float)painter->pen().widthF()) *
                 0.5f)
                .toPointF(),
            (pos - widthVec - lengthVec * 0.2f * (mInverted ? -1 : 1) +
             dir.normalized() * qMax(1.0f, (float)painter->pen().widthF()) *
                 0.5f)
                .toPointF());
      }
      break;
    }
  }
}

/*! \internal
  \overload

  Draws the line ending. The direction is controlled with the \a angle parameter
  in radians.
*/
void QCPLineEnding::draw(QCPPainter *painter, const QVector2D &pos,
                         double angle) const {
  draw(painter, pos, QVector2D(qCos(angle), qSin(angle)));
}

////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////// QCPGrid
////////////////////////////////////////////////////////////////////////////////////////////////////

/*! \class QCPGrid
  \brief Responsible for drawing the grid of a QCPAxis.

  This class is tightly bound to QCPAxis. Every axis owns a grid instance and
  uses it to draw the grid lines, sub grid lines and zero-line. You can interact
  with the grid of an axis via \ref QCPAxis::grid. Normally, you don't need to
  create an instance of QCPGrid yourself.

  The axis and grid drawing was split into two classes to allow them to be
  placed on different layers (both QCPAxis and QCPGrid inherit from
  QCPLayerable). Thus it is possible to have the grid in the background and the
  axes in the foreground, and any plottables/items in between. This described
  situation is the default setup, see the QCPLayer documentation.
*/

/*!
  Creates a QCPGrid instance and sets default values.

  You shouldn't instantiate grids on their own, since every QCPAxis brings its
  own QCPGrid.
*/
QCPGrid::QCPGrid(QCPAxis *parentAxis)
    : QCPLayerable(parentAxis->parentPlot(), QString(), parentAxis),
      mParentAxis(parentAxis) {
  // warning: this is called in QCPAxis constructor, so parentAxis members
  // should not be accessed/called
  setParent(parentAxis);
  setPen(QPen(QColor(200, 200, 200), 0, Qt::DotLine));
  setSubGridPen(QPen(QColor(220, 220, 220), 0, Qt::DotLine));
  setZeroLinePen(QPen(QColor(200, 200, 200), 0, Qt::SolidLine));
  setSubGridVisible(false);
  setAntialiased(false);
  setAntialiasedSubGrid(false);
  setAntialiasedZeroLine(false);
}

/*!
  Sets whether grid lines at sub tick marks are drawn.

  \see setSubGridPen
*/
void QCPGrid::setSubGridVisible(bool visible) { mSubGridVisible = visible; }

/*!
  Sets whether sub grid lines are drawn antialiased.
*/
void QCPGrid::setAntialiasedSubGrid(bool enabled) {
  mAntialiasedSubGrid = enabled;
}

/*!
  Sets whether zero lines are drawn antialiased.
*/
void QCPGrid::setAntialiasedZeroLine(bool enabled) {
  mAntialiasedZeroLine = enabled;
}

/*!
  Sets the pen with which (major) grid lines are drawn.
*/
void QCPGrid::setPen(const QPen &pen) { mPen = pen; }

/*!
  Sets the pen with which sub grid lines are drawn.
*/
void QCPGrid::setSubGridPen(const QPen &pen) { mSubGridPen = pen; }

/*!
  Sets the pen with which zero lines are drawn.

  Zero lines are lines at value coordinate 0 which may be drawn with a different
  pen than other grid lines. To disable zero lines and just draw normal grid
  lines at zero, set \a pen to Qt::NoPen.
*/
void QCPGrid::setZeroLinePen(const QPen &pen) { mZeroLinePen = pen; }

/*! \internal

  A convenience function to easily set the QPainter::Antialiased hint on the
  provided \a painter before drawing the major grid lines.

  This is the antialiasing state the painter passed to the \ref draw method is
  in by default.

  This function takes into account the local setting of the antialiasing flag as
  well as the overrides set with \ref QCustomPlot::setAntialiasedElements and
  \ref QCustomPlot::setNotAntialiasedElements.

  \see setAntialiased
*/
void QCPGrid::applyDefaultAntialiasingHint(QCPPainter *painter) const {
  applyAntialiasingHint(painter, mAntialiased, QCP::aeGrid);
}

/*! \internal

  Draws grid lines and sub grid lines at the positions of (sub) ticks of the
  parent axis, spanning over the complete axis rect. Also draws the zero line,
  if appropriate (\ref setZeroLinePen).
*/
void QCPGrid::draw(QCPPainter *painter) {
  if (!mParentAxis) {
    qDebug() << Q_FUNC_INFO << "invalid parent axis";
    return;
  }

  if (mSubGridVisible) drawSubGridLines(painter);
  drawGridLines(painter);
}

/*! \internal

  Draws the main grid lines and possibly a zero line with the specified painter.

  This is a helper function called by \ref draw.
*/
void QCPGrid::drawGridLines(QCPPainter *painter) const {
  if (!mParentAxis) {
    qDebug() << Q_FUNC_INFO << "invalid parent axis";
    return;
  }

  int lowTick = mParentAxis->mLowestVisibleTick;
  int highTick = mParentAxis->mHighestVisibleTick;
  double t;  // helper variable, result of coordinate-to-pixel transforms
  if (mParentAxis->orientation() == Qt::Horizontal) {
    // draw zeroline:
    int zeroLineIndex = -1;
    if (mZeroLinePen.style() != Qt::NoPen && mParentAxis->mRange.lower < 0 &&
        mParentAxis->mRange.upper > 0) {
      applyAntialiasingHint(painter, mAntialiasedZeroLine, QCP::aeZeroLine);
      painter->setPen(mZeroLinePen);
      double epsilon =
          mParentAxis->range().size() * 1E-6;  // for comparing double to zero
      for (int i = lowTick; i <= highTick; ++i) {
        if (qAbs(mParentAxis->mTickVector.at(i)) < epsilon) {
          zeroLineIndex = i;
          t = mParentAxis->coordToPixel(mParentAxis->mTickVector.at(i));  // x
          painter->drawLine(QLineF(t, mParentAxis->mAxisRect->bottom(), t,
                                   mParentAxis->mAxisRect->top()));
          break;
        }
      }
    }
    // draw grid lines:
    applyDefaultAntialiasingHint(painter);
    painter->setPen(mPen);
    for (int i = lowTick; i <= highTick; ++i) {
      if (i == zeroLineIndex)
        continue;  // don't draw a gridline on top of the zeroline
      t = mParentAxis->coordToPixel(mParentAxis->mTickVector.at(i));  // x
      painter->drawLine(QLineF(t, mParentAxis->mAxisRect->bottom(), t,
                               mParentAxis->mAxisRect->top()));
    }
  } else {
    // draw zeroline:
    int zeroLineIndex = -1;
    if (mZeroLinePen.style() != Qt::NoPen && mParentAxis->mRange.lower < 0 &&
        mParentAxis->mRange.upper > 0) {
      applyAntialiasingHint(painter, mAntialiasedZeroLine, QCP::aeZeroLine);
