|
|
@@ -0,0 +1,30121 @@
|
|
|
+/***************************************************************************
|
|
|
+** **
|
|
|
+** QCustomPlot, an easy to use, modern plotting widget for Qt **
|
|
|
+** Copyright (C) 2011-2017 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: 04.09.17 **
|
|
|
+** Version: 2.0.0 **
|
|
|
+****************************************************************************/
|
|
|
+
|
|
|
+#include "qcustomplot.h"
|
|
|
+
|
|
|
+
|
|
|
+/* including file 'src/vector2d.cpp', size 7340 */
|
|
|
+/* commit 9868e55d3b412f2f89766bb482fcf299e93a0988 2017-09-04 01:56:22 +0200 */
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPVector2D
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+/*! \class QCPVector2D
|
|
|
+ \brief Represents two doubles as a mathematical 2D vector
|
|
|
+
|
|
|
+ This class acts as a replacement for QVector2D with the advantage of double precision instead of
|
|
|
+ single, and some convenience methods tailored for the QCustomPlot library.
|
|
|
+*/
|
|
|
+
|
|
|
+/* start documentation of inline functions */
|
|
|
+
|
|
|
+/*! \fn void QCPVector2D::setX(double x)
|
|
|
+
|
|
|
+ Sets the x coordinate of this vector to \a x.
|
|
|
+
|
|
|
+ \see setY
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn void QCPVector2D::setY(double y)
|
|
|
+
|
|
|
+ Sets the y coordinate of this vector to \a y.
|
|
|
+
|
|
|
+ \see setX
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn double QCPVector2D::length() const
|
|
|
+
|
|
|
+ Returns the length of this vector.
|
|
|
+
|
|
|
+ \see lengthSquared
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn double QCPVector2D::lengthSquared() const
|
|
|
+
|
|
|
+ Returns the squared length of this vector. In some situations, e.g. when just trying to find the
|
|
|
+ shortest vector of a group, this is faster than calculating \ref length, because it avoids
|
|
|
+ calculation of a square root.
|
|
|
+
|
|
|
+ \see length
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn QPoint QCPVector2D::toPoint() const
|
|
|
+
|
|
|
+ Returns a QPoint which has the x and y coordinates of this vector, truncating any floating point
|
|
|
+ information.
|
|
|
+
|
|
|
+ \see toPointF
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn QPointF QCPVector2D::toPointF() const
|
|
|
+
|
|
|
+ Returns a QPointF which has the x and y coordinates of this vector.
|
|
|
+
|
|
|
+ \see toPoint
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn bool QCPVector2D::isNull() const
|
|
|
+
|
|
|
+ Returns whether this vector is null. A vector is null if \c qIsNull returns true for both x and y
|
|
|
+ coordinates, i.e. if both are binary equal to 0.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn QCPVector2D QCPVector2D::perpendicular() const
|
|
|
+
|
|
|
+ Returns a vector perpendicular to this vector, with the same length.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn double QCPVector2D::dot() const
|
|
|
+
|
|
|
+ Returns the dot/scalar product of this vector with the specified vector \a vec.
|
|
|
+*/
|
|
|
+
|
|
|
+/* end documentation of inline functions */
|
|
|
+
|
|
|
+/*!
|
|
|
+ Creates a QCPVector2D object and initializes the x and y coordinates to 0.
|
|
|
+*/
|
|
|
+QCPVector2D::QCPVector2D() :
|
|
|
+ mX(0),
|
|
|
+ mY(0)
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Creates a QCPVector2D object and initializes the \a x and \a y coordinates with the specified
|
|
|
+ values.
|
|
|
+*/
|
|
|
+QCPVector2D::QCPVector2D(double x, double y) :
|
|
|
+ mX(x),
|
|
|
+ mY(y)
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Creates a QCPVector2D object and initializes the x and y coordinates respective coordinates of
|
|
|
+ the specified \a point.
|
|
|
+*/
|
|
|
+QCPVector2D::QCPVector2D(const QPoint &point) :
|
|
|
+ mX(point.x()),
|
|
|
+ mY(point.y())
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Creates a QCPVector2D object and initializes the x and y coordinates respective coordinates of
|
|
|
+ the specified \a point.
|
|
|
+*/
|
|
|
+QCPVector2D::QCPVector2D(const QPointF &point) :
|
|
|
+ mX(point.x()),
|
|
|
+ mY(point.y())
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Normalizes this vector. After this operation, the length of the vector is equal to 1.
|
|
|
+
|
|
|
+ \see normalized, length, lengthSquared
|
|
|
+*/
|
|
|
+void QCPVector2D::normalize()
|
|
|
+{
|
|
|
+ double len = length();
|
|
|
+ mX /= len;
|
|
|
+ mY /= len;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns a normalized version of this vector. The length of the returned vector is equal to 1.
|
|
|
+
|
|
|
+ \see normalize, length, lengthSquared
|
|
|
+*/
|
|
|
+QCPVector2D QCPVector2D::normalized() const
|
|
|
+{
|
|
|
+ QCPVector2D result(mX, mY);
|
|
|
+ result.normalize();
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Returns the squared shortest distance of this vector (interpreted as a point) to the finite line
|
|
|
+ segment given by \a start and \a end.
|
|
|
+
|
|
|
+ \see distanceToStraightLine
|
|
|
+*/
|
|
|
+double QCPVector2D::distanceSquaredToLine(const QCPVector2D &start, const QCPVector2D &end) const
|
|
|
+{
|
|
|
+ QCPVector2D v(end-start);
|
|
|
+ double vLengthSqr = v.lengthSquared();
|
|
|
+ if (!qFuzzyIsNull(vLengthSqr))
|
|
|
+ {
|
|
|
+ double mu = v.dot(*this-start)/vLengthSqr;
|
|
|
+ if (mu < 0)
|
|
|
+ return (*this-start).lengthSquared();
|
|
|
+ else if (mu > 1)
|
|
|
+ return (*this-end).lengthSquared();
|
|
|
+ else
|
|
|
+ return ((start + mu*v)-*this).lengthSquared();
|
|
|
+ } else
|
|
|
+ return (*this-start).lengthSquared();
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Returns the squared shortest distance of this vector (interpreted as a point) to the finite line
|
|
|
+ segment given by \a line.
|
|
|
+
|
|
|
+ \see distanceToStraightLine
|
|
|
+*/
|
|
|
+double QCPVector2D::distanceSquaredToLine(const QLineF &line) const
|
|
|
+{
|
|
|
+ return distanceSquaredToLine(QCPVector2D(line.p1()), QCPVector2D(line.p2()));
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns the shortest distance of this vector (interpreted as a point) to the infinite straight
|
|
|
+ line given by a \a base point and a \a direction vector.
|
|
|
+
|
|
|
+ \see distanceSquaredToLine
|
|
|
+*/
|
|
|
+double QCPVector2D::distanceToStraightLine(const QCPVector2D &base, const QCPVector2D &direction) const
|
|
|
+{
|
|
|
+ return qAbs((*this-base).dot(direction.perpendicular()))/direction.length();
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Scales this vector by the given \a factor, i.e. the x and y components are multiplied by \a
|
|
|
+ factor.
|
|
|
+*/
|
|
|
+QCPVector2D &QCPVector2D::operator*=(double factor)
|
|
|
+{
|
|
|
+ mX *= factor;
|
|
|
+ mY *= factor;
|
|
|
+ return *this;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Scales this vector by the given \a divisor, i.e. the x and y components are divided by \a
|
|
|
+ divisor.
|
|
|
+*/
|
|
|
+QCPVector2D &QCPVector2D::operator/=(double divisor)
|
|
|
+{
|
|
|
+ mX /= divisor;
|
|
|
+ mY /= divisor;
|
|
|
+ return *this;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Adds the given \a vector to this vector component-wise.
|
|
|
+*/
|
|
|
+QCPVector2D &QCPVector2D::operator+=(const QCPVector2D &vector)
|
|
|
+{
|
|
|
+ mX += vector.mX;
|
|
|
+ mY += vector.mY;
|
|
|
+ return *this;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ subtracts the given \a vector from this vector component-wise.
|
|
|
+*/
|
|
|
+QCPVector2D &QCPVector2D::operator-=(const QCPVector2D &vector)
|
|
|
+{
|
|
|
+ mX -= vector.mX;
|
|
|
+ mY -= vector.mY;
|
|
|
+ return *this;
|
|
|
+}
|
|
|
+/* end of 'src/vector2d.cpp' */
|
|
|
+
|
|
|
+
|
|
|
+/* including file 'src/painter.cpp', size 8670 */
|
|
|
+/* commit 9868e55d3b412f2f89766bb482fcf299e93a0988 2017-09-04 01:56:22 +0200 */
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// 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
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ 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);
|
|
|
+ }
|
|
|
+}
|
|
|
+/* end of 'src/painter.cpp' */
|
|
|
+
|
|
|
+
|
|
|
+/* including file 'src/paintbuffer.cpp', size 18502 */
|
|
|
+/* commit 9868e55d3b412f2f89766bb482fcf299e93a0988 2017-09-04 01:56:22 +0200 */
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPAbstractPaintBuffer
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+/*! \class QCPAbstractPaintBuffer
|
|
|
+ \brief The abstract base class for paint buffers, which define the rendering backend
|
|
|
+
|
|
|
+ This abstract base class defines the basic interface that a paint buffer needs to provide in
|
|
|
+ order to be usable by QCustomPlot.
|
|
|
+
|
|
|
+ A paint buffer manages both a surface to draw onto, and the matching paint device. The size of
|
|
|
+ the surface can be changed via \ref setSize. External classes (\ref QCustomPlot and \ref
|
|
|
+ QCPLayer) request a painter via \ref startPainting and then perform the draw calls. Once the
|
|
|
+ painting is complete, \ref donePainting is called, so the paint buffer implementation can do
|
|
|
+ clean up if necessary. Before rendering a frame, each paint buffer is usually filled with a color
|
|
|
+ using \ref clear (usually the color is \c Qt::transparent), to remove the contents of the
|
|
|
+ previous frame.
|
|
|
+
|
|
|
+ The simplest paint buffer implementation is \ref QCPPaintBufferPixmap which allows regular
|
|
|
+ software rendering via the raster engine. Hardware accelerated rendering via pixel buffers and
|
|
|
+ frame buffer objects is provided by \ref QCPPaintBufferGlPbuffer and \ref QCPPaintBufferGlFbo.
|
|
|
+ They are used automatically if \ref QCustomPlot::setOpenGl is enabled.
|
|
|
+*/
|
|
|
+
|
|
|
+/* start documentation of pure virtual functions */
|
|
|
+
|
|
|
+/*! \fn virtual QCPPainter *QCPAbstractPaintBuffer::startPainting() = 0
|
|
|
+
|
|
|
+ Returns a \ref QCPPainter which is ready to draw to this buffer. The ownership and thus the
|
|
|
+ responsibility to delete the painter after the painting operations are complete is given to the
|
|
|
+ caller of this method.
|
|
|
+
|
|
|
+ Once you are done using the painter, delete the painter and call \ref donePainting.
|
|
|
+
|
|
|
+ While a painter generated with this method is active, you must not call \ref setSize, \ref
|
|
|
+ setDevicePixelRatio or \ref clear.
|
|
|
+
|
|
|
+ This method may return 0, if a painter couldn't be activated on the buffer. This usually
|
|
|
+ indicates a problem with the respective painting backend.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn virtual void QCPAbstractPaintBuffer::draw(QCPPainter *painter) const = 0
|
|
|
+
|
|
|
+ Draws the contents of this buffer with the provided \a painter. This is the method that is used
|
|
|
+ to finally join all paint buffers and draw them onto the screen.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn virtual void QCPAbstractPaintBuffer::clear(const QColor &color) = 0
|
|
|
+
|
|
|
+ Fills the entire buffer with the provided \a color. To have an empty transparent buffer, use the
|
|
|
+ named color \c Qt::transparent.
|
|
|
+
|
|
|
+ This method must not be called if there is currently a painter (acquired with \ref startPainting)
|
|
|
+ active.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn virtual void QCPAbstractPaintBuffer::reallocateBuffer() = 0
|
|
|
+
|
|
|
+ Reallocates the internal buffer with the currently configured size (\ref setSize) and device
|
|
|
+ pixel ratio, if applicable (\ref setDevicePixelRatio). It is called as soon as any of those
|
|
|
+ properties are changed on this paint buffer.
|
|
|
+
|
|
|
+ \note Subclasses of \ref QCPAbstractPaintBuffer must call their reimplementation of this method
|
|
|
+ in their constructor, to perform the first allocation (this can not be done by the base class
|
|
|
+ because calling pure virtual methods in base class constructors is not possible).
|
|
|
+*/
|
|
|
+
|
|
|
+/* end documentation of pure virtual functions */
|
|
|
+/* start documentation of inline functions */
|
|
|
+
|
|
|
+/*! \fn virtual void QCPAbstractPaintBuffer::donePainting()
|
|
|
+
|
|
|
+ If you have acquired a \ref QCPPainter to paint onto this paint buffer via \ref startPainting,
|
|
|
+ call this method as soon as you are done with the painting operations and have deleted the
|
|
|
+ painter.
|
|
|
+
|
|
|
+ paint buffer subclasses may use this method to perform any type of cleanup that is necessary. The
|
|
|
+ default implementation does nothing.
|
|
|
+*/
|
|
|
+
|
|
|
+/* end documentation of inline functions */
|
|
|
+
|
|
|
+/*!
|
|
|
+ Creates a paint buffer and initializes it with the provided \a size and \a devicePixelRatio.
|
|
|
+
|
|
|
+ Subclasses must call their \ref reallocateBuffer implementation in their respective constructors.
|
|
|
+*/
|
|
|
+QCPAbstractPaintBuffer::QCPAbstractPaintBuffer(const QSize &size, double devicePixelRatio) :
|
|
|
+ mSize(size),
|
|
|
+ mDevicePixelRatio(devicePixelRatio),
|
|
|
+ mInvalidated(true)
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+QCPAbstractPaintBuffer::~QCPAbstractPaintBuffer()
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the paint buffer size.
|
|
|
+
|
|
|
+ The buffer is reallocated (by calling \ref reallocateBuffer), so any painters that were obtained
|
|
|
+ by \ref startPainting are invalidated and must not be used after calling this method.
|
|
|
+
|
|
|
+ If \a size is already the current buffer size, this method does nothing.
|
|
|
+*/
|
|
|
+void QCPAbstractPaintBuffer::setSize(const QSize &size)
|
|
|
+{
|
|
|
+ if (mSize != size)
|
|
|
+ {
|
|
|
+ mSize = size;
|
|
|
+ reallocateBuffer();
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the invalidated flag to \a invalidated.
|
|
|
+
|
|
|
+ This mechanism is used internally in conjunction with isolated replotting of \ref QCPLayer
|
|
|
+ instances (in \ref QCPLayer::lmBuffered mode). If \ref QCPLayer::replot is called on a buffered
|
|
|
+ layer, i.e. an isolated repaint of only that layer (and its dedicated paint buffer) is requested,
|
|
|
+ QCustomPlot will decide depending on the invalidated flags of other paint buffers whether it also
|
|
|
+ replots them, instead of only the layer on which the replot was called.
|
|
|
+
|
|
|
+ The invalidated flag is set to true when \ref QCPLayer association has changed, i.e. if layers
|
|
|
+ were added or removed from this buffer, or if they were reordered. It is set to false as soon as
|
|
|
+ all associated \ref QCPLayer instances are drawn onto the buffer.
|
|
|
+
|
|
|
+ Under normal circumstances, it is not necessary to manually call this method.
|
|
|
+*/
|
|
|
+void QCPAbstractPaintBuffer::setInvalidated(bool invalidated)
|
|
|
+{
|
|
|
+ mInvalidated = invalidated;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the the device pixel ratio to \a ratio. This is useful to render on high-DPI output devices.
|
|
|
+ The ratio is automatically set to the device pixel ratio used by the parent QCustomPlot instance.
|
|
|
+
|
|
|
+ The buffer is reallocated (by calling \ref reallocateBuffer), so any painters that were obtained
|
|
|
+ by \ref startPainting are invalidated and must not be used after calling this method.
|
|
|
+
|
|
|
+ \note This method is only available for Qt versions 5.4 and higher.
|
|
|
+*/
|
|
|
+void QCPAbstractPaintBuffer::setDevicePixelRatio(double ratio)
|
|
|
+{
|
|
|
+ if (!qFuzzyCompare(ratio, mDevicePixelRatio))
|
|
|
+ {
|
|
|
+#ifdef QCP_DEVICEPIXELRATIO_SUPPORTED
|
|
|
+ mDevicePixelRatio = ratio;
|
|
|
+ reallocateBuffer();
|
|
|
+#else
|
|
|
+ qDebug() << Q_FUNC_INFO << "Device pixel ratios not supported for Qt versions before 5.4";
|
|
|
+ mDevicePixelRatio = 1.0;
|
|
|
+#endif
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPPaintBufferPixmap
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+/*! \class QCPPaintBufferPixmap
|
|
|
+ \brief A paint buffer based on QPixmap, using software raster rendering
|
|
|
+
|
|
|
+ This paint buffer is the default and fall-back paint buffer which uses software rendering and
|
|
|
+ QPixmap as internal buffer. It is used if \ref QCustomPlot::setOpenGl is false.
|
|
|
+*/
|
|
|
+
|
|
|
+/*!
|
|
|
+ Creates a pixmap paint buffer instancen with the specified \a size and \a devicePixelRatio, if
|
|
|
+ applicable.
|
|
|
+*/
|
|
|
+QCPPaintBufferPixmap::QCPPaintBufferPixmap(const QSize &size, double devicePixelRatio) :
|
|
|
+ QCPAbstractPaintBuffer(size, devicePixelRatio)
|
|
|
+{
|
|
|
+ QCPPaintBufferPixmap::reallocateBuffer();
|
|
|
+}
|
|
|
+
|
|
|
+QCPPaintBufferPixmap::~QCPPaintBufferPixmap()
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+QCPPainter *QCPPaintBufferPixmap::startPainting()
|
|
|
+{
|
|
|
+ QCPPainter *result = new QCPPainter(&mBuffer);
|
|
|
+ result->setRenderHint(QPainter::HighQualityAntialiasing);
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPPaintBufferPixmap::draw(QCPPainter *painter) const
|
|
|
+{
|
|
|
+ if (painter && painter->isActive())
|
|
|
+ painter->drawPixmap(0, 0, mBuffer);
|
|
|
+ else
|
|
|
+ qDebug() << Q_FUNC_INFO << "invalid or inactive painter passed";
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPPaintBufferPixmap::clear(const QColor &color)
|
|
|
+{
|
|
|
+ mBuffer.fill(color);
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPPaintBufferPixmap::reallocateBuffer()
|
|
|
+{
|
|
|
+ setInvalidated();
|
|
|
+ if (!qFuzzyCompare(1.0, mDevicePixelRatio))
|
|
|
+ {
|
|
|
+#ifdef QCP_DEVICEPIXELRATIO_SUPPORTED
|
|
|
+ mBuffer = QPixmap(mSize*mDevicePixelRatio);
|
|
|
+ mBuffer.setDevicePixelRatio(mDevicePixelRatio);
|
|
|
+#else
|
|
|
+ qDebug() << Q_FUNC_INFO << "Device pixel ratios not supported for Qt versions before 5.4";
|
|
|
+ mDevicePixelRatio = 1.0;
|
|
|
+ mBuffer = QPixmap(mSize);
|
|
|
+#endif
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ mBuffer = QPixmap(mSize);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+#ifdef QCP_OPENGL_PBUFFER
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPPaintBufferGlPbuffer
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+/*! \class QCPPaintBufferGlPbuffer
|
|
|
+ \brief A paint buffer based on OpenGL pixel buffers, using hardware accelerated rendering
|
|
|
+
|
|
|
+ This paint buffer is one of the OpenGL paint buffers which facilitate hardware accelerated plot
|
|
|
+ rendering. It is based on OpenGL pixel buffers (pbuffer) and is used in Qt versions before 5.0.
|
|
|
+ (See \ref QCPPaintBufferGlFbo used in newer Qt versions.)
|
|
|
+
|
|
|
+ The OpenGL paint buffers are used if \ref QCustomPlot::setOpenGl is set to true, and if they are
|
|
|
+ supported by the system.
|
|
|
+*/
|
|
|
+
|
|
|
+/*!
|
|
|
+ Creates a \ref QCPPaintBufferGlPbuffer instance with the specified \a size and \a
|
|
|
+ devicePixelRatio, if applicable.
|
|
|
+
|
|
|
+ The parameter \a multisamples defines how many samples are used per pixel. Higher values thus
|
|
|
+ result in higher quality antialiasing. If the specified \a multisamples value exceeds the
|
|
|
+ capability of the graphics hardware, the highest supported multisampling is used.
|
|
|
+*/
|
|
|
+QCPPaintBufferGlPbuffer::QCPPaintBufferGlPbuffer(const QSize &size, double devicePixelRatio, int multisamples) :
|
|
|
+ QCPAbstractPaintBuffer(size, devicePixelRatio),
|
|
|
+ mGlPBuffer(0),
|
|
|
+ mMultisamples(qMax(0, multisamples))
|
|
|
+{
|
|
|
+ QCPPaintBufferGlPbuffer::reallocateBuffer();
|
|
|
+}
|
|
|
+
|
|
|
+QCPPaintBufferGlPbuffer::~QCPPaintBufferGlPbuffer()
|
|
|
+{
|
|
|
+ if (mGlPBuffer)
|
|
|
+ delete mGlPBuffer;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+QCPPainter *QCPPaintBufferGlPbuffer::startPainting()
|
|
|
+{
|
|
|
+ if (!mGlPBuffer->isValid())
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "OpenGL frame buffer object doesn't exist, reallocateBuffer was not called?";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ QCPPainter *result = new QCPPainter(mGlPBuffer);
|
|
|
+ result->setRenderHint(QPainter::HighQualityAntialiasing);
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPPaintBufferGlPbuffer::draw(QCPPainter *painter) const
|
|
|
+{
|
|
|
+ if (!painter || !painter->isActive())
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "invalid or inactive painter passed";
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ if (!mGlPBuffer->isValid())
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "OpenGL pbuffer isn't valid, reallocateBuffer was not called?";
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ painter->drawImage(0, 0, mGlPBuffer->toImage());
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPPaintBufferGlPbuffer::clear(const QColor &color)
|
|
|
+{
|
|
|
+ if (mGlPBuffer->isValid())
|
|
|
+ {
|
|
|
+ mGlPBuffer->makeCurrent();
|
|
|
+ glClearColor(color.redF(), color.greenF(), color.blueF(), color.alphaF());
|
|
|
+ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
|
+ mGlPBuffer->doneCurrent();
|
|
|
+ } else
|
|
|
+ qDebug() << Q_FUNC_INFO << "OpenGL pbuffer invalid or context not current";
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPPaintBufferGlPbuffer::reallocateBuffer()
|
|
|
+{
|
|
|
+ if (mGlPBuffer)
|
|
|
+ delete mGlPBuffer;
|
|
|
+
|
|
|
+ QGLFormat format;
|
|
|
+ format.setAlpha(true);
|
|
|
+ format.setSamples(mMultisamples);
|
|
|
+ mGlPBuffer = new QGLPixelBuffer(mSize, format);
|
|
|
+}
|
|
|
+#endif // QCP_OPENGL_PBUFFER
|
|
|
+
|
|
|
+
|
|
|
+#ifdef QCP_OPENGL_FBO
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPPaintBufferGlFbo
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+/*! \class QCPPaintBufferGlFbo
|
|
|
+ \brief A paint buffer based on OpenGL frame buffers objects, using hardware accelerated rendering
|
|
|
+
|
|
|
+ This paint buffer is one of the OpenGL paint buffers which facilitate hardware accelerated plot
|
|
|
+ rendering. It is based on OpenGL frame buffer objects (fbo) and is used in Qt versions 5.0 and
|
|
|
+ higher. (See \ref QCPPaintBufferGlPbuffer used in older Qt versions.)
|
|
|
+
|
|
|
+ The OpenGL paint buffers are used if \ref QCustomPlot::setOpenGl is set to true, and if they are
|
|
|
+ supported by the system.
|
|
|
+*/
|
|
|
+
|
|
|
+/*!
|
|
|
+ Creates a \ref QCPPaintBufferGlFbo instance with the specified \a size and \a devicePixelRatio,
|
|
|
+ if applicable.
|
|
|
+
|
|
|
+ All frame buffer objects shall share one OpenGL context and paint device, which need to be set up
|
|
|
+ externally and passed via \a glContext and \a glPaintDevice. The set-up is done in \ref
|
|
|
+ QCustomPlot::setupOpenGl and the context and paint device are managed by the parent QCustomPlot
|
|
|
+ instance.
|
|
|
+*/
|
|
|
+QCPPaintBufferGlFbo::QCPPaintBufferGlFbo(const QSize &size, double devicePixelRatio, QWeakPointer<QOpenGLContext> glContext, QWeakPointer<QOpenGLPaintDevice> glPaintDevice) :
|
|
|
+ QCPAbstractPaintBuffer(size, devicePixelRatio),
|
|
|
+ mGlContext(glContext),
|
|
|
+ mGlPaintDevice(glPaintDevice),
|
|
|
+ mGlFrameBuffer(0)
|
|
|
+{
|
|
|
+ QCPPaintBufferGlFbo::reallocateBuffer();
|
|
|
+}
|
|
|
+
|
|
|
+QCPPaintBufferGlFbo::~QCPPaintBufferGlFbo()
|
|
|
+{
|
|
|
+ if (mGlFrameBuffer)
|
|
|
+ delete mGlFrameBuffer;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+QCPPainter *QCPPaintBufferGlFbo::startPainting()
|
|
|
+{
|
|
|
+ if (mGlPaintDevice.isNull())
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "OpenGL paint device doesn't exist";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ if (!mGlFrameBuffer)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "OpenGL frame buffer object doesn't exist, reallocateBuffer was not called?";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (QOpenGLContext::currentContext() != mGlContext.data())
|
|
|
+ mGlContext.data()->makeCurrent(mGlContext.data()->surface());
|
|
|
+ mGlFrameBuffer->bind();
|
|
|
+ QCPPainter *result = new QCPPainter(mGlPaintDevice.data());
|
|
|
+ result->setRenderHint(QPainter::HighQualityAntialiasing);
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPPaintBufferGlFbo::donePainting()
|
|
|
+{
|
|
|
+ if (mGlFrameBuffer && mGlFrameBuffer->isBound())
|
|
|
+ mGlFrameBuffer->release();
|
|
|
+ else
|
|
|
+ qDebug() << Q_FUNC_INFO << "Either OpenGL frame buffer not valid or was not bound";
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPPaintBufferGlFbo::draw(QCPPainter *painter) const
|
|
|
+{
|
|
|
+ if (!painter || !painter->isActive())
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "invalid or inactive painter passed";
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ if (!mGlFrameBuffer)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "OpenGL frame buffer object doesn't exist, reallocateBuffer was not called?";
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ painter->drawImage(0, 0, mGlFrameBuffer->toImage());
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPPaintBufferGlFbo::clear(const QColor &color)
|
|
|
+{
|
|
|
+ if (mGlContext.isNull())
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "OpenGL context doesn't exist";
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ if (!mGlFrameBuffer)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "OpenGL frame buffer object doesn't exist, reallocateBuffer was not called?";
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (QOpenGLContext::currentContext() != mGlContext.data())
|
|
|
+ mGlContext.data()->makeCurrent(mGlContext.data()->surface());
|
|
|
+ mGlFrameBuffer->bind();
|
|
|
+ glClearColor(color.redF(), color.greenF(), color.blueF(), color.alphaF());
|
|
|
+ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
|
+ mGlFrameBuffer->release();
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPPaintBufferGlFbo::reallocateBuffer()
|
|
|
+{
|
|
|
+ // release and delete possibly existing framebuffer:
|
|
|
+ if (mGlFrameBuffer)
|
|
|
+ {
|
|
|
+ if (mGlFrameBuffer->isBound())
|
|
|
+ mGlFrameBuffer->release();
|
|
|
+ delete mGlFrameBuffer;
|
|
|
+ mGlFrameBuffer = 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (mGlContext.isNull())
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "OpenGL context doesn't exist";
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ if (mGlPaintDevice.isNull())
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "OpenGL paint device doesn't exist";
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ // create new fbo with appropriate size:
|
|
|
+ mGlContext.data()->makeCurrent(mGlContext.data()->surface());
|
|
|
+ QOpenGLFramebufferObjectFormat frameBufferFormat;
|
|
|
+ frameBufferFormat.setSamples(mGlContext.data()->format().samples());
|
|
|
+ frameBufferFormat.setAttachment(QOpenGLFramebufferObject::CombinedDepthStencil);
|
|
|
+ mGlFrameBuffer = new QOpenGLFramebufferObject(mSize*mDevicePixelRatio, frameBufferFormat);
|
|
|
+ if (mGlPaintDevice.data()->size() != mSize*mDevicePixelRatio)
|
|
|
+ mGlPaintDevice.data()->setSize(mSize*mDevicePixelRatio);
|
|
|
+#ifdef QCP_DEVICEPIXELRATIO_SUPPORTED
|
|
|
+ mGlPaintDevice.data()->setDevicePixelRatio(mDevicePixelRatio);
|
|
|
+#endif
|
|
|
+}
|
|
|
+#endif // QCP_OPENGL_FBO
|
|
|
+/* end of 'src/paintbuffer.cpp' */
|
|
|
+
|
|
|
+
|
|
|
+/* including file 'src/layer.cpp', size 37064 */
|
|
|
+/* commit 9868e55d3b412f2f89766bb482fcf299e93a0988 2017-09-04 01:56:22 +0200 */
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// 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 into the paint buffer(s).
|
|
|
+
|
|
|
+ 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.
|
|
|
+
|
|
|
+ \section qcplayer-defaultlayers Default layers
|
|
|
+
|
|
|
+ Initially, QCustomPlot has six layers: "background", "grid", "main", "axes", "legend" and
|
|
|
+ "overlay" (in that order). On top is the "overlay" layer, which only contains the QCustomPlot's
|
|
|
+ selection rect (\ref QCustomPlot::selectionRect). The next two layers "axes" and "legend" contain
|
|
|
+ the default axes and legend, so they will be drawn above plottables. 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).
|
|
|
+
|
|
|
+ \section qcplayer-ordering Controlling the rendering order via layers
|
|
|
+
|
|
|
+ Controlling the ordering of layerables in the plot is easy: Create a new layer in the position
|
|
|
+ you want the layerable to be in, e.g. above "main", with \ref QCustomPlot::addLayer. Then set the
|
|
|
+ current layer with \ref 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 \ref 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.
|
|
|
+
|
|
|
+ \section qcplayer-buffering Replotting only a specific layer
|
|
|
+
|
|
|
+ If the layer mode (\ref setMode) is set to \ref lmBuffered, you can replot only this specific
|
|
|
+ layer by calling \ref replot. In certain situations this can provide better replot performance,
|
|
|
+ compared with a full replot of all layers. Upon creation of a new layer, the layer mode is
|
|
|
+ initialized to \ref lmLogical. The only layer that is set to \ref lmBuffered in a new \ref
|
|
|
+ QCustomPlot instance is the "overlay" layer, containing the selection rect.
|
|
|
+*/
|
|
|
+
|
|
|
+/* 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),
|
|
|
+ mMode(lmLogical)
|
|
|
+{
|
|
|
+ // 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;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the rendering mode of this layer.
|
|
|
+
|
|
|
+ If \a mode is set to \ref lmBuffered for a layer, it will be given a dedicated paint buffer by
|
|
|
+ the parent QCustomPlot instance. This means it may be replotted individually by calling \ref
|
|
|
+ QCPLayer::replot, without needing to replot all other layers.
|
|
|
+
|
|
|
+ Layers which are set to \ref lmLogical (the default) are used only to define the rendering order
|
|
|
+ and can't be replotted individually.
|
|
|
+
|
|
|
+ Note that each layer which is set to \ref lmBuffered requires additional paint buffers for the
|
|
|
+ layers below, above and for the layer itself. This increases the memory consumption and
|
|
|
+ (slightly) decreases the repainting speed because multiple paint buffers need to be joined. So
|
|
|
+ you should carefully choose which layers benefit from having their own paint buffer. A typical
|
|
|
+ example would be a layer which contains certain layerables (e.g. items) that need to be changed
|
|
|
+ and thus replotted regularly, while all other layerables on other layers stay static. By default,
|
|
|
+ only the topmost layer called "overlay" is in mode \ref lmBuffered, and contains the selection
|
|
|
+ rect.
|
|
|
+
|
|
|
+ \see replot
|
|
|
+*/
|
|
|
+void QCPLayer::setMode(QCPLayer::LayerMode mode)
|
|
|
+{
|
|
|
+ if (mMode != mode)
|
|
|
+ {
|
|
|
+ mMode = mode;
|
|
|
+ if (!mPaintBuffer.isNull())
|
|
|
+ mPaintBuffer.data()->setInvalidated();
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Draws the contents of this layer with the provided \a painter.
|
|
|
+
|
|
|
+ \see replot, drawToPaintBuffer
|
|
|
+*/
|
|
|
+void QCPLayer::draw(QCPPainter *painter)
|
|
|
+{
|
|
|
+ foreach (QCPLayerable *child, mChildren)
|
|
|
+ {
|
|
|
+ if (child->realVisibility())
|
|
|
+ {
|
|
|
+ painter->save();
|
|
|
+ painter->setClipRect(child->clipRect().translated(0, -1));
|
|
|
+ child->applyDefaultAntialiasingHint(painter);
|
|
|
+ child->draw(painter);
|
|
|
+ painter->restore();
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Draws the contents of this layer into the paint buffer which is associated with this layer. The
|
|
|
+ association is established by the parent QCustomPlot, which manages all paint buffers (see \ref
|
|
|
+ QCustomPlot::setupPaintBuffers).
|
|
|
+
|
|
|
+ \see draw
|
|
|
+*/
|
|
|
+void QCPLayer::drawToPaintBuffer()
|
|
|
+{
|
|
|
+ if (!mPaintBuffer.isNull())
|
|
|
+ {
|
|
|
+ if (QCPPainter *painter = mPaintBuffer.data()->startPainting())
|
|
|
+ {
|
|
|
+ if (painter->isActive())
|
|
|
+ draw(painter);
|
|
|
+ else
|
|
|
+ qDebug() << Q_FUNC_INFO << "paint buffer returned inactive painter";
|
|
|
+ delete painter;
|
|
|
+ mPaintBuffer.data()->donePainting();
|
|
|
+ } else
|
|
|
+ qDebug() << Q_FUNC_INFO << "paint buffer returned zero painter";
|
|
|
+ } else
|
|
|
+ qDebug() << Q_FUNC_INFO << "no valid paint buffer associated with this layer";
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ If the layer mode (\ref setMode) is set to \ref lmBuffered, this method allows replotting only
|
|
|
+ the layerables on this specific layer, without the need to replot all other layers (as a call to
|
|
|
+ \ref QCustomPlot::replot would do).
|
|
|
+
|
|
|
+ If the layer mode is \ref lmLogical however, this method simply calls \ref QCustomPlot::replot on
|
|
|
+ the parent QCustomPlot instance.
|
|
|
+
|
|
|
+ QCustomPlot also makes sure to replot all layers instead of only this one, if the layer ordering
|
|
|
+ has changed since the last full replot and the other paint buffers were thus invalidated.
|
|
|
+
|
|
|
+ \see draw
|
|
|
+*/
|
|
|
+void QCPLayer::replot()
|
|
|
+{
|
|
|
+ if (mMode == lmBuffered && !mParentPlot->hasInvalidatedPaintBuffers())
|
|
|
+ {
|
|
|
+ if (!mPaintBuffer.isNull())
|
|
|
+ {
|
|
|
+ mPaintBuffer.data()->clear(Qt::transparent);
|
|
|
+ drawToPaintBuffer();
|
|
|
+ mPaintBuffer.data()->setInvalidated(false);
|
|
|
+ mParentPlot->update();
|
|
|
+ } else
|
|
|
+ qDebug() << Q_FUNC_INFO << "no valid paint buffer associated with this layer";
|
|
|
+ } else if (mMode == lmLogical)
|
|
|
+ mParentPlot->replot();
|
|
|
+}
|
|
|
+
|
|
|
+/*! \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);
|
|
|
+ if (!mPaintBuffer.isNull())
|
|
|
+ mPaintBuffer.data()->setInvalidated();
|
|
|
+ } 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))
|
|
|
+ {
|
|
|
+ if (!mPaintBuffer.isNull())
|
|
|
+ mPaintBuffer.data()->setInvalidated();
|
|
|
+ } else
|
|
|
+ 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 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 and scatters. Those can be configured via QCPGraph::setAntialiased,
|
|
|
+ QCPGraph::setAntialiasedFill and QCPGraph::setAntialiasedScatters. 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 this layerable's layer 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 \ref QCPLayoutElement), this function returns true only if this
|
|
|
+ layerable has its visibility set to true and the parent layerable's \ref realVisibility returns
|
|
|
+ true.
|
|
|
+*/
|
|
|
+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 \ref selectEvent/\ref 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 decition 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, mousePressEvent, wheelEvent, 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)
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ This event gets called when the user presses a mouse button while the cursor is over the
|
|
|
+ layerable. Whether a cursor is over the layerable is decided by a preceding call to \ref
|
|
|
+ selectTest.
|
|
|
+
|
|
|
+ The current pixel position of the cursor on the QCustomPlot widget is accessible via \c
|
|
|
+ event->pos(). The parameter \a details contains layerable-specific details about the hit, which
|
|
|
+ were generated in the previous call to \ref selectTest. For example, One-dimensional plottables
|
|
|
+ like \ref QCPGraph or \ref QCPBars convey the clicked data point in the \a details parameter, as
|
|
|
+ \ref QCPDataSelection packed as QVariant. Multi-part objects convey the specific \c
|
|
|
+ SelectablePart that was hit (e.g. \ref QCPAxis::SelectablePart in the case of axes).
|
|
|
+
|
|
|
+ QCustomPlot uses an event propagation system that works the same as Qt's system. If your
|
|
|
+ layerable doesn't reimplement the \ref mousePressEvent or explicitly calls \c event->ignore() in
|
|
|
+ its reimplementation, the event will be propagated to the next layerable in the stacking order.
|
|
|
+
|
|
|
+ Once a layerable has accepted the \ref mousePressEvent, it is considered the mouse grabber and
|
|
|
+ will receive all following calls to \ref mouseMoveEvent or \ref mouseReleaseEvent for this mouse
|
|
|
+ interaction (a "mouse interaction" in this context ends with the release).
|
|
|
+
|
|
|
+ The default implementation does nothing except explicitly ignoring the event with \c
|
|
|
+ event->ignore().
|
|
|
+
|
|
|
+ \see mouseMoveEvent, mouseReleaseEvent, mouseDoubleClickEvent, wheelEvent
|
|
|
+*/
|
|
|
+void QCPLayerable::mousePressEvent(QMouseEvent *event, const QVariant &details)
|
|
|
+{
|
|
|
+ Q_UNUSED(details)
|
|
|
+ event->ignore();
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ This event gets called when the user moves the mouse while holding a mouse button, after this
|
|
|
+ layerable has become the mouse grabber by accepting the preceding \ref mousePressEvent.
|
|
|
+
|
|
|
+ The current pixel position of the cursor on the QCustomPlot widget is accessible via \c
|
|
|
+ event->pos(). The parameter \a startPos indicates the position where the initial \ref
|
|
|
+ mousePressEvent occured, that started the mouse interaction.
|
|
|
+
|
|
|
+ The default implementation does nothing.
|
|
|
+
|
|
|
+ \see mousePressEvent, mouseReleaseEvent, mouseDoubleClickEvent, wheelEvent
|
|
|
+*/
|
|
|
+void QCPLayerable::mouseMoveEvent(QMouseEvent *event, const QPointF &startPos)
|
|
|
+{
|
|
|
+ Q_UNUSED(startPos)
|
|
|
+ event->ignore();
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ This event gets called when the user releases the mouse button, after this layerable has become
|
|
|
+ the mouse grabber by accepting the preceding \ref mousePressEvent.
|
|
|
+
|
|
|
+ The current pixel position of the cursor on the QCustomPlot widget is accessible via \c
|
|
|
+ event->pos(). The parameter \a startPos indicates the position where the initial \ref
|
|
|
+ mousePressEvent occured, that started the mouse interaction.
|
|
|
+
|
|
|
+ The default implementation does nothing.
|
|
|
+
|
|
|
+ \see mousePressEvent, mouseMoveEvent, mouseDoubleClickEvent, wheelEvent
|
|
|
+*/
|
|
|
+void QCPLayerable::mouseReleaseEvent(QMouseEvent *event, const QPointF &startPos)
|
|
|
+{
|
|
|
+ Q_UNUSED(startPos)
|
|
|
+ event->ignore();
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ This event gets called when the user presses the mouse button a second time in a double-click,
|
|
|
+ while the cursor is over the layerable. Whether a cursor is over the layerable is decided by a
|
|
|
+ preceding call to \ref selectTest.
|
|
|
+
|
|
|
+ The \ref mouseDoubleClickEvent is called instead of the second \ref mousePressEvent. So in the
|
|
|
+ case of a double-click, the event succession is
|
|
|
+ <i>pressEvent – releaseEvent – doubleClickEvent – releaseEvent</i>.
|
|
|
+
|
|
|
+ The current pixel position of the cursor on the QCustomPlot widget is accessible via \c
|
|
|
+ event->pos(). The parameter \a details contains layerable-specific details about the hit, which
|
|
|
+ were generated in the previous call to \ref selectTest. For example, One-dimensional plottables
|
|
|
+ like \ref QCPGraph or \ref QCPBars convey the clicked data point in the \a details parameter, as
|
|
|
+ \ref QCPDataSelection packed as QVariant. Multi-part objects convey the specific \c
|
|
|
+ SelectablePart that was hit (e.g. \ref QCPAxis::SelectablePart in the case of axes).
|
|
|
+
|
|
|
+ Similarly to \ref mousePressEvent, once a layerable has accepted the \ref mouseDoubleClickEvent,
|
|
|
+ it is considered the mouse grabber and will receive all following calls to \ref mouseMoveEvent
|
|
|
+ and \ref mouseReleaseEvent for this mouse interaction (a "mouse interaction" in this context ends
|
|
|
+ with the release).
|
|
|
+
|
|
|
+ The default implementation does nothing except explicitly ignoring the event with \c
|
|
|
+ event->ignore().
|
|
|
+
|
|
|
+ \see mousePressEvent, mouseMoveEvent, mouseReleaseEvent, wheelEvent
|
|
|
+*/
|
|
|
+void QCPLayerable::mouseDoubleClickEvent(QMouseEvent *event, const QVariant &details)
|
|
|
+{
|
|
|
+ Q_UNUSED(details)
|
|
|
+ event->ignore();
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ This event gets called when the user turns the mouse scroll wheel while the cursor is over the
|
|
|
+ layerable. Whether a cursor is over the layerable is decided by a preceding call to \ref
|
|
|
+ selectTest.
|
|
|
+
|
|
|
+ The current pixel position of the cursor on the QCustomPlot widget is accessible via \c
|
|
|
+ event->pos().
|
|
|
+
|
|
|
+ The \c event->delta() indicates how far the mouse wheel was turned, which is usually +/- 120 for
|
|
|
+ single rotation steps. However, if the mouse wheel is turned rapidly, multiple steps may
|
|
|
+ accumulate to one event, making \c event->delta() larger. On the other hand, if the wheel has
|
|
|
+ very smooth steps or none at all, the delta may be smaller.
|
|
|
+
|
|
|
+ The default implementation does nothing.
|
|
|
+
|
|
|
+ \see mousePressEvent, mouseMoveEvent, mouseReleaseEvent, mouseDoubleClickEvent
|
|
|
+*/
|
|
|
+void QCPLayerable::wheelEvent(QWheelEvent *event)
|
|
|
+{
|
|
|
+ event->ignore();
|
|
|
+}
|
|
|
+/* end of 'src/layer.cpp' */
|
|
|
+
|
|
|
+
|
|
|
+/* including file 'src/axis/range.cpp', size 12221 */
|
|
|
+/* commit 9868e55d3b412f2f89766bb482fcf299e93a0988 2017-09-04 01:56:22 +0200 */
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// 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
|
|
|
+*/
|
|
|
+
|
|
|
+/* start of documentation of inline functions */
|
|
|
+
|
|
|
+/*! \fn double QCPRange::size() const
|
|
|
+
|
|
|
+ Returns the size of the range, i.e. \a upper-\a lower
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn double QCPRange::center() const
|
|
|
+
|
|
|
+ Returns the center of the range, i.e. (\a upper+\a lower)*0.5
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn void QCPRange::normalize()
|
|
|
+
|
|
|
+ Makes sure \a lower is numerically smaller than \a upper. If this is not the case, the values are
|
|
|
+ swapped.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn bool QCPRange::contains(double value) const
|
|
|
+
|
|
|
+ Returns true when \a value lies within or exactly on the borders of the range.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn QCPRange &QCPRange::operator+=(const double& value)
|
|
|
+
|
|
|
+ Adds \a value to both boundaries of the range.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn QCPRange &QCPRange::operator-=(const double& value)
|
|
|
+
|
|
|
+ Subtracts \a value from both boundaries of the range.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn QCPRange &QCPRange::operator*=(const double& value)
|
|
|
+
|
|
|
+ Multiplies both boundaries of the range by \a value.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn QCPRange &QCPRange::operator/=(const double& value)
|
|
|
+
|
|
|
+ Divides both boundaries of the range by \a value.
|
|
|
+*/
|
|
|
+
|
|
|
+/* end of documentation of inline functions */
|
|
|
+
|
|
|
+/*!
|
|
|
+ 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.
|
|
|
+
|
|
|
+ \warning Do not use this constant to indicate "arbitrarily small" values in plotting logic (as
|
|
|
+ values that will appear in the plot)! It is intended only as a bound to compare against, e.g. to
|
|
|
+ prevent axis ranges from obtaining underflowing ranges.
|
|
|
+
|
|
|
+ \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.
|
|
|
+
|
|
|
+ \warning Do not use this constant to indicate "arbitrarily large" values in plotting logic (as
|
|
|
+ values that will appear in the plot)! It is intended only as a bound to compare against, e.g. to
|
|
|
+ prevent axis ranges from obtaining overflowing ranges.
|
|
|
+
|
|
|
+ \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.
|
|
|
+
|
|
|
+ The resulting range will be normalized (see \ref normalize), so if \a lower is not numerically
|
|
|
+ smaller than \a upper, they will be swapped.
|
|
|
+*/
|
|
|
+QCPRange::QCPRange(double lower, double upper) :
|
|
|
+ lower(lower),
|
|
|
+ upper(upper)
|
|
|
+{
|
|
|
+ normalize();
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ 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 this range contains NaN as lower or upper bound, it will be replaced by the respective bound
|
|
|
+ of \a otherRange.
|
|
|
+
|
|
|
+ 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 || qIsNaN(lower))
|
|
|
+ lower = otherRange.lower;
|
|
|
+ if (upper < otherRange.upper || qIsNaN(upper))
|
|
|
+ upper = otherRange.upper;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Expands this range such that \a includeCoord is contained in the new range. It is assumed that
|
|
|
+ this range is normalized (see \ref normalize).
|
|
|
+
|
|
|
+ If this range contains NaN as lower or upper bound, the respective bound will be set to \a
|
|
|
+ includeCoord.
|
|
|
+
|
|
|
+ If \a includeCoord is already inside the current range, this function does nothing.
|
|
|
+
|
|
|
+ \see expand
|
|
|
+*/
|
|
|
+void QCPRange::expand(double includeCoord)
|
|
|
+{
|
|
|
+ if (lower > includeCoord || qIsNaN(lower))
|
|
|
+ lower = includeCoord;
|
|
|
+ if (upper < includeCoord || qIsNaN(upper))
|
|
|
+ upper = includeCoord;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ 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).
|
|
|
+
|
|
|
+ If this range contains NaN as lower or upper bound, the returned range's bound will be taken from
|
|
|
+ \a otherRange.
|
|
|
+
|
|
|
+ \see expand
|
|
|
+*/
|
|
|
+QCPRange QCPRange::expanded(const QCPRange &otherRange) const
|
|
|
+{
|
|
|
+ QCPRange result = *this;
|
|
|
+ result.expand(otherRange);
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Returns an expanded range that includes the specified \a includeCoord. It is assumed that this
|
|
|
+ range is normalized (see \ref normalize).
|
|
|
+
|
|
|
+ If this range contains NaN as lower or upper bound, the returned range's bound will be set to \a
|
|
|
+ includeCoord.
|
|
|
+
|
|
|
+ \see expand
|
|
|
+*/
|
|
|
+QCPRange QCPRange::expanded(double includeCoord) const
|
|
|
+{
|
|
|
+ QCPRange result = *this;
|
|
|
+ result.expand(includeCoord);
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns this range, possibly modified to not exceed the bounds provided as \a lowerBound and \a
|
|
|
+ upperBound. If possible, the size of the current range is preserved in the process.
|
|
|
+
|
|
|
+ If the range shall only be bounded at the lower side, you can set \a upperBound to \ref
|
|
|
+ QCPRange::maxRange. If it shall only be bounded at the upper side, set \a lowerBound to -\ref
|
|
|
+ QCPRange::maxRange.
|
|
|
+*/
|
|
|
+QCPRange QCPRange::bounded(double lowerBound, double upperBound) const
|
|
|
+{
|
|
|
+ if (lowerBound > upperBound)
|
|
|
+ qSwap(lowerBound, upperBound);
|
|
|
+
|
|
|
+ QCPRange result(lower, upper);
|
|
|
+ if (result.lower < lowerBound)
|
|
|
+ {
|
|
|
+ result.lower = lowerBound;
|
|
|
+ result.upper = lowerBound + size();
|
|
|
+ if (result.upper > upperBound || qFuzzyCompare(size(), upperBound-lowerBound))
|
|
|
+ result.upper = upperBound;
|
|
|
+ } else if (result.upper > upperBound)
|
|
|
+ {
|
|
|
+ result.upper = upperBound;
|
|
|
+ result.lower = upperBound - size();
|
|
|
+ if (result.lower < lowerBound || qFuzzyCompare(size(), upperBound-lowerBound))
|
|
|
+ result.lower = lowerBound;
|
|
|
+ }
|
|
|
+
|
|
|
+ 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;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ 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)));
|
|
|
+}
|
|
|
+/* end of 'src/axis/range.cpp' */
|
|
|
+
|
|
|
+
|
|
|
+/* including file 'src/selection.cpp', size 21906 */
|
|
|
+/* commit 9868e55d3b412f2f89766bb482fcf299e93a0988 2017-09-04 01:56:22 +0200 */
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPDataRange
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+/*! \class QCPDataRange
|
|
|
+ \brief Describes a data range given by begin and end index
|
|
|
+
|
|
|
+ QCPDataRange holds two integers describing the begin (\ref setBegin) and end (\ref setEnd) index
|
|
|
+ of a contiguous set of data points. The end index points to the data point above the last data point that's part of
|
|
|
+ the data range, similarly to the nomenclature used in standard iterators.
|
|
|
+
|
|
|
+ Data Ranges are not bound to a certain plottable, thus they can be freely exchanged, created and
|
|
|
+ modified. If a non-contiguous data set shall be described, the class \ref QCPDataSelection is
|
|
|
+ used, which holds and manages multiple instances of \ref QCPDataRange. In most situations, \ref
|
|
|
+ QCPDataSelection is thus used.
|
|
|
+
|
|
|
+ Both \ref QCPDataRange and \ref QCPDataSelection offer convenience methods to work with them,
|
|
|
+ e.g. \ref bounded, \ref expanded, \ref intersects, \ref intersection, \ref adjusted, \ref
|
|
|
+ contains. Further, addition and subtraction operators (defined in \ref QCPDataSelection) can be
|
|
|
+ used to join/subtract data ranges and data selections (or mixtures), to retrieve a corresponding
|
|
|
+ \ref QCPDataSelection.
|
|
|
+
|
|
|
+ %QCustomPlot's \ref dataselection "data selection mechanism" is based on \ref QCPDataSelection and
|
|
|
+ QCPDataRange.
|
|
|
+
|
|
|
+ \note Do not confuse \ref QCPDataRange with \ref QCPRange. A \ref QCPRange describes an interval
|
|
|
+ in floating point plot coordinates, e.g. the current axis range.
|
|
|
+*/
|
|
|
+
|
|
|
+/* start documentation of inline functions */
|
|
|
+
|
|
|
+/*! \fn int QCPDataRange::size() const
|
|
|
+
|
|
|
+ Returns the number of data points described by this data range. This is equal to the end index
|
|
|
+ minus the begin index.
|
|
|
+
|
|
|
+ \see length
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn int QCPDataRange::length() const
|
|
|
+
|
|
|
+ Returns the number of data points described by this data range. Equivalent to \ref size.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn void QCPDataRange::setBegin(int begin)
|
|
|
+
|
|
|
+ Sets the begin of this data range. The \a begin index points to the first data point that is part
|
|
|
+ of the data range.
|
|
|
+
|
|
|
+ No checks or corrections are made to ensure the resulting range is valid (\ref isValid).
|
|
|
+
|
|
|
+ \see setEnd
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn void QCPDataRange::setEnd(int end)
|
|
|
+
|
|
|
+ Sets the end of this data range. The \a end index points to the data point just above the last
|
|
|
+ data point that is part of the data range.
|
|
|
+
|
|
|
+ No checks or corrections are made to ensure the resulting range is valid (\ref isValid).
|
|
|
+
|
|
|
+ \see setBegin
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn bool QCPDataRange::isValid() const
|
|
|
+
|
|
|
+ Returns whether this range is valid. A valid range has a begin index greater or equal to 0, and
|
|
|
+ an end index greater or equal to the begin index.
|
|
|
+
|
|
|
+ \note Invalid ranges should be avoided and are never the result of any of QCustomPlot's methods
|
|
|
+ (unless they are themselves fed with invalid ranges). Do not pass invalid ranges to QCustomPlot's
|
|
|
+ methods. The invalid range is not inherently prevented in QCPDataRange, to allow temporary
|
|
|
+ invalid begin/end values while manipulating the range. An invalid range is not necessarily empty
|
|
|
+ (\ref isEmpty), since its \ref length can be negative and thus non-zero.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn bool QCPDataRange::isEmpty() const
|
|
|
+
|
|
|
+ Returns whether this range is empty, i.e. whether its begin index equals its end index.
|
|
|
+
|
|
|
+ \see size, length
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn QCPDataRange QCPDataRange::adjusted(int changeBegin, int changeEnd) const
|
|
|
+
|
|
|
+ Returns a data range where \a changeBegin and \a changeEnd were added to the begin and end
|
|
|
+ indices, respectively.
|
|
|
+*/
|
|
|
+
|
|
|
+/* end documentation of inline functions */
|
|
|
+
|
|
|
+/*!
|
|
|
+ Creates an empty QCPDataRange, with begin and end set to 0.
|
|
|
+*/
|
|
|
+QCPDataRange::QCPDataRange() :
|
|
|
+ mBegin(0),
|
|
|
+ mEnd(0)
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Creates a QCPDataRange, initialized with the specified \a begin and \a end.
|
|
|
+
|
|
|
+ No checks or corrections are made to ensure the resulting range is valid (\ref isValid).
|
|
|
+*/
|
|
|
+QCPDataRange::QCPDataRange(int begin, int end) :
|
|
|
+ mBegin(begin),
|
|
|
+ mEnd(end)
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns a data range that matches this data range, except that parts exceeding \a other are
|
|
|
+ excluded.
|
|
|
+
|
|
|
+ This method is very similar to \ref intersection, with one distinction: If this range and the \a
|
|
|
+ other range share no intersection, the returned data range will be empty with begin and end set
|
|
|
+ to the respective boundary side of \a other, at which this range is residing. (\ref intersection
|
|
|
+ would just return a range with begin and end set to 0.)
|
|
|
+*/
|
|
|
+QCPDataRange QCPDataRange::bounded(const QCPDataRange &other) const
|
|
|
+{
|
|
|
+ QCPDataRange result(intersection(other));
|
|
|
+ if (result.isEmpty()) // no intersection, preserve respective bounding side of otherRange as both begin and end of return value
|
|
|
+ {
|
|
|
+ if (mEnd <= other.mBegin)
|
|
|
+ result = QCPDataRange(other.mBegin, other.mBegin);
|
|
|
+ else
|
|
|
+ result = QCPDataRange(other.mEnd, other.mEnd);
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns a data range that contains both this data range as well as \a other.
|
|
|
+*/
|
|
|
+QCPDataRange QCPDataRange::expanded(const QCPDataRange &other) const
|
|
|
+{
|
|
|
+ return QCPDataRange(qMin(mBegin, other.mBegin), qMax(mEnd, other.mEnd));
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns the data range which is contained in both this data range and \a other.
|
|
|
+
|
|
|
+ This method is very similar to \ref bounded, with one distinction: If this range and the \a other
|
|
|
+ range share no intersection, the returned data range will be empty with begin and end set to 0.
|
|
|
+ (\ref bounded would return a range with begin and end set to one of the boundaries of \a other,
|
|
|
+ depending on which side this range is on.)
|
|
|
+
|
|
|
+ \see QCPDataSelection::intersection
|
|
|
+*/
|
|
|
+QCPDataRange QCPDataRange::intersection(const QCPDataRange &other) const
|
|
|
+{
|
|
|
+ QCPDataRange result(qMax(mBegin, other.mBegin), qMin(mEnd, other.mEnd));
|
|
|
+ if (result.isValid())
|
|
|
+ return result;
|
|
|
+ else
|
|
|
+ return QCPDataRange();
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns whether this data range and \a other share common data points.
|
|
|
+
|
|
|
+ \see intersection, contains
|
|
|
+*/
|
|
|
+bool QCPDataRange::intersects(const QCPDataRange &other) const
|
|
|
+{
|
|
|
+ return !( (mBegin > other.mBegin && mBegin >= other.mEnd) ||
|
|
|
+ (mEnd <= other.mBegin && mEnd < other.mEnd) );
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns whether all data points described by this data range are also in \a other.
|
|
|
+
|
|
|
+ \see intersects
|
|
|
+*/
|
|
|
+bool QCPDataRange::contains(const QCPDataRange &other) const
|
|
|
+{
|
|
|
+ return mBegin <= other.mBegin && mEnd >= other.mEnd;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPDataSelection
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+/*! \class QCPDataSelection
|
|
|
+ \brief Describes a data set by holding multiple QCPDataRange instances
|
|
|
+
|
|
|
+ QCPDataSelection manages multiple instances of QCPDataRange in order to represent any (possibly
|
|
|
+ disjoint) set of data selection.
|
|
|
+
|
|
|
+ The data selection can be modified with addition and subtraction operators which take
|
|
|
+ QCPDataSelection and QCPDataRange instances, as well as methods such as \ref addDataRange and
|
|
|
+ \ref clear. Read access is provided by \ref dataRange, \ref dataRanges, \ref dataRangeCount, etc.
|
|
|
+
|
|
|
+ The method \ref simplify is used to join directly adjacent or even overlapping QCPDataRange
|
|
|
+ instances. QCPDataSelection automatically simplifies when using the addition/subtraction
|
|
|
+ operators. The only case when \ref simplify is left to the user, is when calling \ref
|
|
|
+ addDataRange, with the parameter \a simplify explicitly set to false. This is useful if many data
|
|
|
+ ranges will be added to the selection successively and the overhead for simplifying after each
|
|
|
+ iteration shall be avoided. In this case, you should make sure to call \ref simplify after
|
|
|
+ completing the operation.
|
|
|
+
|
|
|
+ Use \ref enforceType to bring the data selection into a state complying with the constraints for
|
|
|
+ selections defined in \ref QCP::SelectionType.
|
|
|
+
|
|
|
+ %QCustomPlot's \ref dataselection "data selection mechanism" is based on QCPDataSelection and
|
|
|
+ QCPDataRange.
|
|
|
+
|
|
|
+ \section qcpdataselection-iterating Iterating over a data selection
|
|
|
+
|
|
|
+ As an example, the following code snippet calculates the average value of a graph's data
|
|
|
+ \ref QCPAbstractPlottable::selection "selection":
|
|
|
+
|
|
|
+ \snippet documentation/doc-code-snippets/mainwindow.cpp qcpdataselection-iterating-1
|
|
|
+
|
|
|
+*/
|
|
|
+
|
|
|
+/* start documentation of inline functions */
|
|
|
+
|
|
|
+/*! \fn int QCPDataSelection::dataRangeCount() const
|
|
|
+
|
|
|
+ Returns the number of ranges that make up the data selection. The ranges can be accessed by \ref
|
|
|
+ dataRange via their index.
|
|
|
+
|
|
|
+ \see dataRange, dataPointCount
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn QList<QCPDataRange> QCPDataSelection::dataRanges() const
|
|
|
+
|
|
|
+ Returns all data ranges that make up the data selection. If the data selection is simplified (the
|
|
|
+ usual state of the selection, see \ref simplify), the ranges are sorted by ascending data point
|
|
|
+ index.
|
|
|
+
|
|
|
+ \see dataRange
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn bool QCPDataSelection::isEmpty() const
|
|
|
+
|
|
|
+ Returns true if there are no data ranges, and thus no data points, in this QCPDataSelection
|
|
|
+ instance.
|
|
|
+
|
|
|
+ \see dataRangeCount
|
|
|
+*/
|
|
|
+
|
|
|
+/* end documentation of inline functions */
|
|
|
+
|
|
|
+/*!
|
|
|
+ Creates an empty QCPDataSelection.
|
|
|
+*/
|
|
|
+QCPDataSelection::QCPDataSelection()
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Creates a QCPDataSelection containing the provided \a range.
|
|
|
+*/
|
|
|
+QCPDataSelection::QCPDataSelection(const QCPDataRange &range)
|
|
|
+{
|
|
|
+ mDataRanges.append(range);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns true if this selection is identical (contains the same data ranges with the same begin
|
|
|
+ and end indices) to \a other.
|
|
|
+
|
|
|
+ Note that both data selections must be in simplified state (the usual state of the selection, see
|
|
|
+ \ref simplify) for this operator to return correct results.
|
|
|
+*/
|
|
|
+bool QCPDataSelection::operator==(const QCPDataSelection &other) const
|
|
|
+{
|
|
|
+ if (mDataRanges.size() != other.mDataRanges.size())
|
|
|
+ return false;
|
|
|
+ for (int i=0; i<mDataRanges.size(); ++i)
|
|
|
+ {
|
|
|
+ if (mDataRanges.at(i) != other.mDataRanges.at(i))
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Adds the data selection of \a other to this data selection, and then simplifies this data
|
|
|
+ selection (see \ref simplify).
|
|
|
+*/
|
|
|
+QCPDataSelection &QCPDataSelection::operator+=(const QCPDataSelection &other)
|
|
|
+{
|
|
|
+ mDataRanges << other.mDataRanges;
|
|
|
+ simplify();
|
|
|
+ return *this;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Adds the data range \a other to this data selection, and then simplifies this data selection (see
|
|
|
+ \ref simplify).
|
|
|
+*/
|
|
|
+QCPDataSelection &QCPDataSelection::operator+=(const QCPDataRange &other)
|
|
|
+{
|
|
|
+ addDataRange(other);
|
|
|
+ return *this;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Removes all data point indices that are described by \a other from this data selection.
|
|
|
+*/
|
|
|
+QCPDataSelection &QCPDataSelection::operator-=(const QCPDataSelection &other)
|
|
|
+{
|
|
|
+ for (int i=0; i<other.dataRangeCount(); ++i)
|
|
|
+ *this -= other.dataRange(i);
|
|
|
+
|
|
|
+ return *this;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Removes all data point indices that are described by \a other from this data selection.
|
|
|
+*/
|
|
|
+QCPDataSelection &QCPDataSelection::operator-=(const QCPDataRange &other)
|
|
|
+{
|
|
|
+ if (other.isEmpty() || isEmpty())
|
|
|
+ return *this;
|
|
|
+
|
|
|
+ simplify();
|
|
|
+ int i=0;
|
|
|
+ while (i < mDataRanges.size())
|
|
|
+ {
|
|
|
+ const int thisBegin = mDataRanges.at(i).begin();
|
|
|
+ const int thisEnd = mDataRanges.at(i).end();
|
|
|
+ if (thisBegin >= other.end())
|
|
|
+ break; // since data ranges are sorted after the simplify() call, no ranges which contain other will come after this
|
|
|
+
|
|
|
+ if (thisEnd > other.begin()) // ranges which don't fulfill this are entirely before other and can be ignored
|
|
|
+ {
|
|
|
+ if (thisBegin >= other.begin()) // range leading segment is encompassed
|
|
|
+ {
|
|
|
+ if (thisEnd <= other.end()) // range fully encompassed, remove completely
|
|
|
+ {
|
|
|
+ mDataRanges.removeAt(i);
|
|
|
+ continue;
|
|
|
+ } else // only leading segment is encompassed, trim accordingly
|
|
|
+ mDataRanges[i].setBegin(other.end());
|
|
|
+ } else // leading segment is not encompassed
|
|
|
+ {
|
|
|
+ if (thisEnd <= other.end()) // only trailing segment is encompassed, trim accordingly
|
|
|
+ {
|
|
|
+ mDataRanges[i].setEnd(other.begin());
|
|
|
+ } else // other lies inside this range, so split range
|
|
|
+ {
|
|
|
+ mDataRanges[i].setEnd(other.begin());
|
|
|
+ mDataRanges.insert(i+1, QCPDataRange(other.end(), thisEnd));
|
|
|
+ break; // since data ranges are sorted (and don't overlap) after simplify() call, we're done here
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ++i;
|
|
|
+ }
|
|
|
+
|
|
|
+ return *this;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns the total number of data points contained in all data ranges that make up this data
|
|
|
+ selection.
|
|
|
+*/
|
|
|
+int QCPDataSelection::dataPointCount() const
|
|
|
+{
|
|
|
+ int result = 0;
|
|
|
+ for (int i=0; i<mDataRanges.size(); ++i)
|
|
|
+ result += mDataRanges.at(i).length();
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns the data range with the specified \a index.
|
|
|
+
|
|
|
+ If the data selection is simplified (the usual state of the selection, see \ref simplify), the
|
|
|
+ ranges are sorted by ascending data point index.
|
|
|
+
|
|
|
+ \see dataRangeCount
|
|
|
+*/
|
|
|
+QCPDataRange QCPDataSelection::dataRange(int index) const
|
|
|
+{
|
|
|
+ if (index >= 0 && index < mDataRanges.size())
|
|
|
+ {
|
|
|
+ return mDataRanges.at(index);
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "index out of range:" << index;
|
|
|
+ return QCPDataRange();
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns a \ref QCPDataRange which spans the entire data selection, including possible
|
|
|
+ intermediate segments which are not part of the original data selection.
|
|
|
+*/
|
|
|
+QCPDataRange QCPDataSelection::span() const
|
|
|
+{
|
|
|
+ if (isEmpty())
|
|
|
+ return QCPDataRange();
|
|
|
+ else
|
|
|
+ return QCPDataRange(mDataRanges.first().begin(), mDataRanges.last().end());
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Adds the given \a dataRange to this data selection. This is equivalent to the += operator but
|
|
|
+ allows disabling immediate simplification by setting \a simplify to false. This can improve
|
|
|
+ performance if adding a very large amount of data ranges successively. In this case, make sure to
|
|
|
+ call \ref simplify manually, after the operation.
|
|
|
+*/
|
|
|
+void QCPDataSelection::addDataRange(const QCPDataRange &dataRange, bool simplify)
|
|
|
+{
|
|
|
+ mDataRanges.append(dataRange);
|
|
|
+ if (simplify)
|
|
|
+ this->simplify();
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Removes all data ranges. The data selection then contains no data points.
|
|
|
+
|
|
|
+ \ref isEmpty
|
|
|
+*/
|
|
|
+void QCPDataSelection::clear()
|
|
|
+{
|
|
|
+ mDataRanges.clear();
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sorts all data ranges by range begin index in ascending order, and then joins directly adjacent
|
|
|
+ or overlapping ranges. This can reduce the number of individual data ranges in the selection, and
|
|
|
+ prevents possible double-counting when iterating over the data points held by the data ranges.
|
|
|
+
|
|
|
+ This method is automatically called when using the addition/subtraction operators. The only case
|
|
|
+ when \ref simplify is left to the user, is when calling \ref addDataRange, with the parameter \a
|
|
|
+ simplify explicitly set to false.
|
|
|
+*/
|
|
|
+void QCPDataSelection::simplify()
|
|
|
+{
|
|
|
+ // remove any empty ranges:
|
|
|
+ for (int i=mDataRanges.size()-1; i>=0; --i)
|
|
|
+ {
|
|
|
+ if (mDataRanges.at(i).isEmpty())
|
|
|
+ mDataRanges.removeAt(i);
|
|
|
+ }
|
|
|
+ if (mDataRanges.isEmpty())
|
|
|
+ return;
|
|
|
+
|
|
|
+ // sort ranges by starting value, ascending:
|
|
|
+ std::sort(mDataRanges.begin(), mDataRanges.end(), lessThanDataRangeBegin);
|
|
|
+
|
|
|
+ // join overlapping/contiguous ranges:
|
|
|
+ int i = 1;
|
|
|
+ while (i < mDataRanges.size())
|
|
|
+ {
|
|
|
+ if (mDataRanges.at(i-1).end() >= mDataRanges.at(i).begin()) // range i overlaps/joins with i-1, so expand range i-1 appropriately and remove range i from list
|
|
|
+ {
|
|
|
+ mDataRanges[i-1].setEnd(qMax(mDataRanges.at(i-1).end(), mDataRanges.at(i).end()));
|
|
|
+ mDataRanges.removeAt(i);
|
|
|
+ } else
|
|
|
+ ++i;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Makes sure this data selection conforms to the specified \a type selection type. Before the type
|
|
|
+ is enforced, \ref simplify is called.
|
|
|
+
|
|
|
+ Depending on \a type, enforcing means adding new data points that were previously not part of the
|
|
|
+ selection, or removing data points from the selection. If the current selection already conforms
|
|
|
+ to \a type, the data selection is not changed.
|
|
|
+
|
|
|
+ \see QCP::SelectionType
|
|
|
+*/
|
|
|
+void QCPDataSelection::enforceType(QCP::SelectionType type)
|
|
|
+{
|
|
|
+ simplify();
|
|
|
+ switch (type)
|
|
|
+ {
|
|
|
+ case QCP::stNone:
|
|
|
+ {
|
|
|
+ mDataRanges.clear();
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case QCP::stWhole:
|
|
|
+ {
|
|
|
+ // whole selection isn't defined by data range, so don't change anything (is handled in plottable methods)
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case QCP::stSingleData:
|
|
|
+ {
|
|
|
+ // reduce all data ranges to the single first data point:
|
|
|
+ if (!mDataRanges.isEmpty())
|
|
|
+ {
|
|
|
+ if (mDataRanges.size() > 1)
|
|
|
+ mDataRanges = QList<QCPDataRange>() << mDataRanges.first();
|
|
|
+ if (mDataRanges.first().length() > 1)
|
|
|
+ mDataRanges.first().setEnd(mDataRanges.first().begin()+1);
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case QCP::stDataRange:
|
|
|
+ {
|
|
|
+ mDataRanges = QList<QCPDataRange>() << span();
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case QCP::stMultipleDataRanges:
|
|
|
+ {
|
|
|
+ // this is the selection type that allows all concievable combinations of ranges, so do nothing
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns true if the data selection \a other is contained entirely in this data selection, i.e.
|
|
|
+ all data point indices that are in \a other are also in this data selection.
|
|
|
+
|
|
|
+ \see QCPDataRange::contains
|
|
|
+*/
|
|
|
+bool QCPDataSelection::contains(const QCPDataSelection &other) const
|
|
|
+{
|
|
|
+ if (other.isEmpty()) return false;
|
|
|
+
|
|
|
+ int otherIndex = 0;
|
|
|
+ int thisIndex = 0;
|
|
|
+ while (thisIndex < mDataRanges.size() && otherIndex < other.mDataRanges.size())
|
|
|
+ {
|
|
|
+ if (mDataRanges.at(thisIndex).contains(other.mDataRanges.at(otherIndex)))
|
|
|
+ ++otherIndex;
|
|
|
+ else
|
|
|
+ ++thisIndex;
|
|
|
+ }
|
|
|
+ return thisIndex < mDataRanges.size(); // if thisIndex ran all the way to the end to find a containing range for the current otherIndex, other is not contained in this
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns a data selection containing the points which are both in this data selection and in the
|
|
|
+ data range \a other.
|
|
|
+
|
|
|
+ A common use case is to limit an unknown data selection to the valid range of a data container,
|
|
|
+ using \ref QCPDataContainer::dataRange as \a other. One can then safely iterate over the returned
|
|
|
+ data selection without exceeding the data container's bounds.
|
|
|
+*/
|
|
|
+QCPDataSelection QCPDataSelection::intersection(const QCPDataRange &other) const
|
|
|
+{
|
|
|
+ QCPDataSelection result;
|
|
|
+ for (int i=0; i<mDataRanges.size(); ++i)
|
|
|
+ result.addDataRange(mDataRanges.at(i).intersection(other), false);
|
|
|
+ result.simplify();
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns a data selection containing the points which are both in this data selection and in the
|
|
|
+ data selection \a other.
|
|
|
+*/
|
|
|
+QCPDataSelection QCPDataSelection::intersection(const QCPDataSelection &other) const
|
|
|
+{
|
|
|
+ QCPDataSelection result;
|
|
|
+ for (int i=0; i<other.dataRangeCount(); ++i)
|
|
|
+ result += intersection(other.dataRange(i));
|
|
|
+ result.simplify();
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns a data selection which is the exact inverse of this data selection, with \a outerRange
|
|
|
+ defining the base range on which to invert. If \a outerRange is smaller than the \ref span of
|
|
|
+ this data selection, it is expanded accordingly.
|
|
|
+
|
|
|
+ For example, this method can be used to retrieve all unselected segments by setting \a outerRange
|
|
|
+ to the full data range of the plottable, and calling this method on a data selection holding the
|
|
|
+ selected segments.
|
|
|
+*/
|
|
|
+QCPDataSelection QCPDataSelection::inverse(const QCPDataRange &outerRange) const
|
|
|
+{
|
|
|
+ if (isEmpty())
|
|
|
+ return QCPDataSelection(outerRange);
|
|
|
+ QCPDataRange fullRange = outerRange.expanded(span());
|
|
|
+
|
|
|
+ QCPDataSelection result;
|
|
|
+ // first unselected segment:
|
|
|
+ if (mDataRanges.first().begin() != fullRange.begin())
|
|
|
+ result.addDataRange(QCPDataRange(fullRange.begin(), mDataRanges.first().begin()), false);
|
|
|
+ // intermediate unselected segments:
|
|
|
+ for (int i=1; i<mDataRanges.size(); ++i)
|
|
|
+ result.addDataRange(QCPDataRange(mDataRanges.at(i-1).end(), mDataRanges.at(i).begin()), false);
|
|
|
+ // last unselected segment:
|
|
|
+ if (mDataRanges.last().end() != fullRange.end())
|
|
|
+ result.addDataRange(QCPDataRange(mDataRanges.last().end(), fullRange.end()), false);
|
|
|
+ result.simplify();
|
|
|
+ return result;
|
|
|
+}
|
|
|
+/* end of 'src/selection.cpp' */
|
|
|
+
|
|
|
+
|
|
|
+/* including file 'src/selectionrect.cpp', size 9224 */
|
|
|
+/* commit 9868e55d3b412f2f89766bb482fcf299e93a0988 2017-09-04 01:56:22 +0200 */
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPSelectionRect
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+/*! \class QCPSelectionRect
|
|
|
+ \brief Provides rect/rubber-band data selection and range zoom interaction
|
|
|
+
|
|
|
+ QCPSelectionRect is used by QCustomPlot when the \ref QCustomPlot::setSelectionRectMode is not
|
|
|
+ \ref QCP::srmNone. When the user drags the mouse across the plot, the current selection rect
|
|
|
+ instance (\ref QCustomPlot::setSelectionRect) is forwarded these events and makes sure an
|
|
|
+ according rect shape is drawn. At the begin, during, and after completion of the interaction, it
|
|
|
+ emits the corresponding signals \ref started, \ref changed, \ref canceled, and \ref accepted.
|
|
|
+
|
|
|
+ The QCustomPlot instance connects own slots to the current selection rect instance, in order to
|
|
|
+ react to an accepted selection rect interaction accordingly.
|
|
|
+
|
|
|
+ \ref isActive can be used to check whether the selection rect is currently active. An ongoing
|
|
|
+ selection interaction can be cancelled programmatically via calling \ref cancel at any time.
|
|
|
+
|
|
|
+ The appearance of the selection rect can be controlled via \ref setPen and \ref setBrush.
|
|
|
+
|
|
|
+ If you wish to provide custom behaviour, e.g. a different visual representation of the selection
|
|
|
+ rect (\ref QCPSelectionRect::draw), you can subclass QCPSelectionRect and pass an instance of
|
|
|
+ your subclass to \ref QCustomPlot::setSelectionRect.
|
|
|
+*/
|
|
|
+
|
|
|
+/* start of documentation of inline functions */
|
|
|
+
|
|
|
+/*! \fn bool QCPSelectionRect::isActive() const
|
|
|
+
|
|
|
+ Returns true if there is currently a selection going on, i.e. the user has started dragging a
|
|
|
+ selection rect, but hasn't released the mouse button yet.
|
|
|
+
|
|
|
+ \see cancel
|
|
|
+*/
|
|
|
+
|
|
|
+/* end of documentation of inline functions */
|
|
|
+/* start documentation of signals */
|
|
|
+
|
|
|
+/*! \fn void QCPSelectionRect::started(QMouseEvent *event);
|
|
|
+
|
|
|
+ This signal is emitted when a selection rect interaction was initiated, i.e. the user just
|
|
|
+ started dragging the selection rect with the mouse.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn void QCPSelectionRect::changed(const QRect &rect, QMouseEvent *event);
|
|
|
+
|
|
|
+ This signal is emitted while the selection rect interaction is ongoing and the \a rect has
|
|
|
+ changed its size due to the user moving the mouse.
|
|
|
+
|
|
|
+ Note that \a rect may have a negative width or height, if the selection is being dragged to the
|
|
|
+ upper or left side of the selection rect origin.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn void QCPSelectionRect::canceled(const QRect &rect, QInputEvent *event);
|
|
|
+
|
|
|
+ This signal is emitted when the selection interaction was cancelled. Note that \a event is 0 if
|
|
|
+ the selection interaction was cancelled programmatically, by a call to \ref cancel.
|
|
|
+
|
|
|
+ The user may cancel the selection interaction by pressing the escape key. In this case, \a event
|
|
|
+ holds the respective input event.
|
|
|
+
|
|
|
+ Note that \a rect may have a negative width or height, if the selection is being dragged to the
|
|
|
+ upper or left side of the selection rect origin.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn void QCPSelectionRect::accepted(const QRect &rect, QMouseEvent *event);
|
|
|
+
|
|
|
+ This signal is emitted when the selection interaction was completed by the user releasing the
|
|
|
+ mouse button.
|
|
|
+
|
|
|
+ Note that \a rect may have a negative width or height, if the selection is being dragged to the
|
|
|
+ upper or left side of the selection rect origin.
|
|
|
+*/
|
|
|
+
|
|
|
+/* end documentation of signals */
|
|
|
+
|
|
|
+/*!
|
|
|
+ Creates a new QCPSelectionRect instance. To make QCustomPlot use the selection rect instance,
|
|
|
+ pass it to \ref QCustomPlot::setSelectionRect. \a parentPlot should be set to the same
|
|
|
+ QCustomPlot widget.
|
|
|
+*/
|
|
|
+QCPSelectionRect::QCPSelectionRect(QCustomPlot *parentPlot) :
|
|
|
+ QCPLayerable(parentPlot),
|
|
|
+ mPen(QBrush(Qt::gray), 0, Qt::DashLine),
|
|
|
+ mBrush(Qt::NoBrush),
|
|
|
+ mActive(false)
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+QCPSelectionRect::~QCPSelectionRect()
|
|
|
+{
|
|
|
+ cancel();
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ A convenience function which returns the coordinate range of the provided \a axis, that this
|
|
|
+ selection rect currently encompasses.
|
|
|
+*/
|
|
|
+QCPRange QCPSelectionRect::range(const QCPAxis *axis) const
|
|
|
+{
|
|
|
+ if (axis)
|
|
|
+ {
|
|
|
+ if (axis->orientation() == Qt::Horizontal)
|
|
|
+ return QCPRange(axis->pixelToCoord(mRect.left()), axis->pixelToCoord(mRect.left()+mRect.width()));
|
|
|
+ else
|
|
|
+ return QCPRange(axis->pixelToCoord(mRect.top()+mRect.height()), axis->pixelToCoord(mRect.top()));
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "called with axis zero";
|
|
|
+ return QCPRange();
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the pen that will be used to draw the selection rect outline.
|
|
|
+
|
|
|
+ \see setBrush
|
|
|
+*/
|
|
|
+void QCPSelectionRect::setPen(const QPen &pen)
|
|
|
+{
|
|
|
+ mPen = pen;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the brush that will be used to fill the selection rect. By default the selection rect is not
|
|
|
+ filled, i.e. \a brush is <tt>Qt::NoBrush</tt>.
|
|
|
+
|
|
|
+ \see setPen
|
|
|
+*/
|
|
|
+void QCPSelectionRect::setBrush(const QBrush &brush)
|
|
|
+{
|
|
|
+ mBrush = brush;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ If there is currently a selection interaction going on (\ref isActive), the interaction is
|
|
|
+ canceled. The selection rect will emit the \ref canceled signal.
|
|
|
+*/
|
|
|
+void QCPSelectionRect::cancel()
|
|
|
+{
|
|
|
+ if (mActive)
|
|
|
+ {
|
|
|
+ mActive = false;
|
|
|
+ emit canceled(mRect, 0);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ This method is called by QCustomPlot to indicate that a selection rect interaction was initiated.
|
|
|
+ The default implementation sets the selection rect to active, initializes the selection rect
|
|
|
+ geometry and emits the \ref started signal.
|
|
|
+*/
|
|
|
+void QCPSelectionRect::startSelection(QMouseEvent *event)
|
|
|
+{
|
|
|
+ mActive = true;
|
|
|
+ mRect = QRect(event->pos(), event->pos());
|
|
|
+ emit started(event);
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ This method is called by QCustomPlot to indicate that an ongoing selection rect interaction needs
|
|
|
+ to update its geometry. The default implementation updates the rect and emits the \ref changed
|
|
|
+ signal.
|
|
|
+*/
|
|
|
+void QCPSelectionRect::moveSelection(QMouseEvent *event)
|
|
|
+{
|
|
|
+ mRect.setBottomRight(event->pos());
|
|
|
+ emit changed(mRect, event);
|
|
|
+ layer()->replot();
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ This method is called by QCustomPlot to indicate that an ongoing selection rect interaction has
|
|
|
+ finished by the user releasing the mouse button. The default implementation deactivates the
|
|
|
+ selection rect and emits the \ref accepted signal.
|
|
|
+*/
|
|
|
+void QCPSelectionRect::endSelection(QMouseEvent *event)
|
|
|
+{
|
|
|
+ mRect.setBottomRight(event->pos());
|
|
|
+ mActive = false;
|
|
|
+ emit accepted(mRect, event);
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ This method is called by QCustomPlot when a key has been pressed by the user while the selection
|
|
|
+ rect interaction is active. The default implementation allows to \ref cancel the interaction by
|
|
|
+ hitting the escape key.
|
|
|
+*/
|
|
|
+void QCPSelectionRect::keyPressEvent(QKeyEvent *event)
|
|
|
+{
|
|
|
+ if (event->key() == Qt::Key_Escape && mActive)
|
|
|
+ {
|
|
|
+ mActive = false;
|
|
|
+ emit canceled(mRect, event);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPSelectionRect::applyDefaultAntialiasingHint(QCPPainter *painter) const
|
|
|
+{
|
|
|
+ applyAntialiasingHint(painter, mAntialiased, QCP::aeOther);
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ If the selection rect is active (\ref isActive), draws the selection rect defined by \a mRect.
|
|
|
+
|
|
|
+ \seebaseclassmethod
|
|
|
+*/
|
|
|
+void QCPSelectionRect::draw(QCPPainter *painter)
|
|
|
+{
|
|
|
+ if (mActive)
|
|
|
+ {
|
|
|
+ painter->setPen(mPen);
|
|
|
+ painter->setBrush(mBrush);
|
|
|
+ painter->drawRect(mRect);
|
|
|
+ }
|
|
|
+}
|
|
|
+/* end of 'src/selectionrect.cpp' */
|
|
|
+
|
|
|
+
|
|
|
+/* including file 'src/layout.cpp', size 79064 */
|
|
|
+/* commit 9868e55d3b412f2f89766bb482fcf299e93a0988 2017-09-04 01:56:22 +0200 */
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// 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 QCPTextElement 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 outerRect, \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.
|
|
|
+
|
|
|
+ \see outerRect
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn QRect QCPLayoutElement::outerRect() const
|
|
|
+
|
|
|
+ Returns the outer rect of this layout element. The outer rect is the inner rect expanded by the
|
|
|
+ margins (\ref setMargins, \ref setAutoMargins). The outer rect is used (and set via \ref
|
|
|
+ setOuterRect) by the parent \ref QCPLayout to control the size of this layout element.
|
|
|
+
|
|
|
+ \see rect
|
|
|
+*/
|
|
|
+
|
|
|
+/* 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),
|
|
|
+ mSizeConstraintRect(scrInnerRect),
|
|
|
+ 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, QCP::MarginSide
|
|
|
+*/
|
|
|
+void QCPLayoutElement::setAutoMargins(QCP::MarginSides sides)
|
|
|
+{
|
|
|
+ mAutoMargins = sides;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the minimum size 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.
|
|
|
+
|
|
|
+ Whether this constraint applies to the inner or the outer rect can be specified with \ref
|
|
|
+ setSizeConstraintRect (see \ref rect and \ref outerRect).
|
|
|
+*/
|
|
|
+void QCPLayoutElement::setMinimumSize(const QSize &size)
|
|
|
+{
|
|
|
+ if (mMinimumSize != size)
|
|
|
+ {
|
|
|
+ mMinimumSize = size;
|
|
|
+ if (mParentLayout)
|
|
|
+ mParentLayout->sizeConstraintsChanged();
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Sets the minimum size of this layout element.
|
|
|
+
|
|
|
+ Whether this constraint applies to the inner or the outer rect can be specified with \ref
|
|
|
+ setSizeConstraintRect (see \ref rect and \ref outerRect).
|
|
|
+*/
|
|
|
+void QCPLayoutElement::setMinimumSize(int width, int height)
|
|
|
+{
|
|
|
+ setMinimumSize(QSize(width, height));
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the maximum size of this layout element. A parent layout tries to respect the \a size here
|
|
|
+ by changing row/column sizes in the layout accordingly.
|
|
|
+
|
|
|
+ Whether this constraint applies to the inner or the outer rect can be specified with \ref
|
|
|
+ setSizeConstraintRect (see \ref rect and \ref outerRect).
|
|
|
+*/
|
|
|
+void QCPLayoutElement::setMaximumSize(const QSize &size)
|
|
|
+{
|
|
|
+ if (mMaximumSize != size)
|
|
|
+ {
|
|
|
+ mMaximumSize = size;
|
|
|
+ if (mParentLayout)
|
|
|
+ mParentLayout->sizeConstraintsChanged();
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Sets the maximum size of this layout element.
|
|
|
+
|
|
|
+ Whether this constraint applies to the inner or the outer rect can be specified with \ref
|
|
|
+ setSizeConstraintRect (see \ref rect and \ref outerRect).
|
|
|
+*/
|
|
|
+void QCPLayoutElement::setMaximumSize(int width, int height)
|
|
|
+{
|
|
|
+ setMaximumSize(QSize(width, height));
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets to which rect of a layout element the size constraints apply. Size constraints can be set
|
|
|
+ via \ref setMinimumSize and \ref setMaximumSize.
|
|
|
+
|
|
|
+ The outer rect (\ref outerRect) includes the margins (e.g. in the case of a QCPAxisRect the axis
|
|
|
+ labels), whereas the inner rect (\ref rect) does not.
|
|
|
+
|
|
|
+ \see setMinimumSize, setMaximumSize
|
|
|
+*/
|
|
|
+void QCPLayoutElement::setSizeConstraintRect(SizeConstraintRect constraintRect)
|
|
|
+{
|
|
|
+ if (mSizeConstraintRect != constraintRect)
|
|
|
+ {
|
|
|
+ mSizeConstraintRect = constraintRect;
|
|
|
+ if (mParentLayout)
|
|
|
+ mParentLayout->sizeConstraintsChanged();
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ 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).
|
|
|
+
|
|
|
+ \see QCP::MarginSide
|
|
|
+*/
|
|
|
+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 suggested minimum size this layout element (the \ref outerRect) may be compressed to,
|
|
|
+ if no manual minimum size is set.
|
|
|
+
|
|
|
+ if a minimum size (\ref setMinimumSize) was not set manually, parent layouts use the returned size
|
|
|
+ (usually indirectly through \ref QCPLayout::getFinalMinimumOuterSize) to determine the minimum
|
|
|
+ allowed size of this layout element.
|
|
|
+
|
|
|
+ A manual minimum size is considered set if it is non-zero.
|
|
|
+
|
|
|
+ The default implementation simply returns the sum of the horizontal margins for the width and the
|
|
|
+ sum of the vertical margins for the height. Reimplementations may use their detailed knowledge
|
|
|
+ about the layout element's content to provide size hints.
|
|
|
+*/
|
|
|
+QSize QCPLayoutElement::minimumOuterSizeHint() const
|
|
|
+{
|
|
|
+ return QSize(mMargins.left()+mMargins.right(), mMargins.top()+mMargins.bottom());
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns the suggested maximum size this layout element (the \ref outerRect) may be expanded to,
|
|
|
+ if no manual maximum size is set.
|
|
|
+
|
|
|
+ if a maximum size (\ref setMaximumSize) was not set manually, parent layouts use the returned
|
|
|
+ size (usually indirectly through \ref QCPLayout::getFinalMaximumOuterSize) to determine the
|
|
|
+ maximum allowed size of this layout element.
|
|
|
+
|
|
|
+ A manual maximum size is considered set if it is smaller than Qt's \c QWIDGETSIZE_MAX.
|
|
|
+
|
|
|
+ The default implementation simply returns \c QWIDGETSIZE_MAX for both width and height, implying
|
|
|
+ no suggested maximum size. Reimplementations may use their detailed knowledge about the layout
|
|
|
+ element's content to provide size hints.
|
|
|
+*/
|
|
|
+QSize QCPLayoutElement::maximumOuterSizeHint() const
|
|
|
+{
|
|
|
+ return QSize(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ 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));
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ This virtual method is called when this layout element was moved to a different QCPLayout, or
|
|
|
+ when this layout element has changed its logical position (e.g. row and/or column) within the
|
|
|
+ same QCPLayout. Subclasses may use this to react accordingly.
|
|
|
+
|
|
|
+ Since this method is called after the completion of the move, you can access the new parent
|
|
|
+ layout via \ref layout().
|
|
|
+
|
|
|
+ The default implementation does nothing.
|
|
|
+*/
|
|
|
+void QCPLayoutElement::layoutChanged()
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// 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()
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ If \a phase is \ref upLayout, calls \ref updateLayout, which subclasses may reimplement to
|
|
|
+ reposition and resize their cells.
|
|
|
+
|
|
|
+ Finally, the call is propagated down to all child \ref QCPLayoutElement "QCPLayoutElements".
|
|
|
+
|
|
|
+ For details about this method and the update phases, see the documentation of \ref
|
|
|
+ QCPLayoutElement::update.
|
|
|
+*/
|
|
|
+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);
|
|
|
+ el->layoutChanged();
|
|
|
+ } 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;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ This is a helper function for the implementation of subclasses.
|
|
|
+
|
|
|
+ It returns the minimum size that should finally be used for the outer rect of the passed layout
|
|
|
+ element \a el.
|
|
|
+
|
|
|
+ It takes into account whether a manual minimum size is set (\ref
|
|
|
+ QCPLayoutElement::setMinimumSize), which size constraint is set (\ref
|
|
|
+ QCPLayoutElement::setSizeConstraintRect), as well as the minimum size hint, if no manual minimum
|
|
|
+ size was set (\ref QCPLayoutElement::minimumOuterSizeHint).
|
|
|
+*/
|
|
|
+QSize QCPLayout::getFinalMinimumOuterSize(const QCPLayoutElement *el)
|
|
|
+{
|
|
|
+ QSize minOuterHint = el->minimumOuterSizeHint();
|
|
|
+ QSize minOuter = el->minimumSize(); // depending on sizeConstraitRect this might be with respect to inner rect, so possibly add margins in next four lines (preserving unset minimum of 0)
|
|
|
+ if (minOuter.width() > 0 && el->sizeConstraintRect() == QCPLayoutElement::scrInnerRect)
|
|
|
+ minOuter.rwidth() += el->margins().left() + el->margins().right();
|
|
|
+ if (minOuter.height() > 0 && el->sizeConstraintRect() == QCPLayoutElement::scrInnerRect)
|
|
|
+ minOuter.rheight() += el->margins().top() + el->margins().bottom();
|
|
|
+
|
|
|
+ return QSize(minOuter.width() > 0 ? minOuter.width() : minOuterHint.width(),
|
|
|
+ minOuter.height() > 0 ? minOuter.height() : minOuterHint.height());;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ This is a helper function for the implementation of subclasses.
|
|
|
+
|
|
|
+ It returns the maximum size that should finally be used for the outer rect of the passed layout
|
|
|
+ element \a el.
|
|
|
+
|
|
|
+ It takes into account whether a manual maximum size is set (\ref
|
|
|
+ QCPLayoutElement::setMaximumSize), which size constraint is set (\ref
|
|
|
+ QCPLayoutElement::setSizeConstraintRect), as well as the maximum size hint, if no manual maximum
|
|
|
+ size was set (\ref QCPLayoutElement::maximumOuterSizeHint).
|
|
|
+*/
|
|
|
+QSize QCPLayout::getFinalMaximumOuterSize(const QCPLayoutElement *el)
|
|
|
+{
|
|
|
+ QSize maxOuterHint = el->maximumOuterSizeHint();
|
|
|
+ QSize maxOuter = el->maximumSize(); // depending on sizeConstraitRect this might be with respect to inner rect, so possibly add margins in next four lines (preserving unset maximum of QWIDGETSIZE_MAX)
|
|
|
+ if (maxOuter.width() < QWIDGETSIZE_MAX && el->sizeConstraintRect() == QCPLayoutElement::scrInnerRect)
|
|
|
+ maxOuter.rwidth() += el->margins().left() + el->margins().right();
|
|
|
+ if (maxOuter.height() < QWIDGETSIZE_MAX && el->sizeConstraintRect() == QCPLayoutElement::scrInnerRect)
|
|
|
+ maxOuter.rheight() += el->margins().top() + el->margins().bottom();
|
|
|
+
|
|
|
+ return QSize(maxOuter.width() < QWIDGETSIZE_MAX ? maxOuter.width() : maxOuterHint.width(),
|
|
|
+ maxOuter.height() < QWIDGETSIZE_MAX ? maxOuter.height() : maxOuterHint.height());
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// 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.
|
|
|
+
|
|
|
+ If you use \ref addElement(QCPLayoutElement*) without explicit parameters for \a row and \a
|
|
|
+ column, the grid layout will choose the position according to the current \ref setFillOrder and
|
|
|
+ the wrapping (\ref setWrap).
|
|
|
+
|
|
|
+ Row and column insertion can be performed with \ref insertRow and \ref insertColumn.
|
|
|
+*/
|
|
|
+
|
|
|
+/* start documentation of inline functions */
|
|
|
+
|
|
|
+/*! \fn int QCPLayoutGrid::rowCount() const
|
|
|
+
|
|
|
+ Returns the number of rows in the layout.
|
|
|
+
|
|
|
+ \see columnCount
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn int QCPLayoutGrid::columnCount() const
|
|
|
+
|
|
|
+ Returns the number of columns in the layout.
|
|
|
+
|
|
|
+ \see rowCount
|
|
|
+*/
|
|
|
+
|
|
|
+/* end documentation of inline functions */
|
|
|
+
|
|
|
+/*!
|
|
|
+ Creates an instance of QCPLayoutGrid and sets default values.
|
|
|
+*/
|
|
|
+QCPLayoutGrid::QCPLayoutGrid() :
|
|
|
+ mColumnSpacing(5),
|
|
|
+ mRowSpacing(5),
|
|
|
+ mWrap(0),
|
|
|
+ mFillOrder(foRowsFirst)
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+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;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ 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.
|
|
|
+
|
|
|
+ Use the overload of this method without explicit row/column index to place the element according
|
|
|
+ to the configured fill order and wrapping settings.
|
|
|
+
|
|
|
+ \see element, hasElement, take, remove
|
|
|
+*/
|
|
|
+bool QCPLayoutGrid::addElement(int row, int column, QCPLayoutElement *element)
|
|
|
+{
|
|
|
+ if (!hasElement(row, column))
|
|
|
+ {
|
|
|
+ if (element && element->layout()) // remove from old layout first
|
|
|
+ element->layout()->take(element);
|
|
|
+ expandTo(row+1, column+1);
|
|
|
+ mElements[row][column] = element;
|
|
|
+ if (element)
|
|
|
+ adoptElement(element);
|
|
|
+ return true;
|
|
|
+ } else
|
|
|
+ qDebug() << Q_FUNC_INFO << "There is already an element in the specified row/column:" << row << column;
|
|
|
+ return false;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Adds the \a element to the next empty cell according to the current fill order (\ref
|
|
|
+ setFillOrder) and wrapping (\ref setWrap). If \a element is already in a layout, it is first
|
|
|
+ removed from there. If necessary, the layout is expanded to hold the new element.
|
|
|
+
|
|
|
+ Returns true if the element was added successfully.
|
|
|
+
|
|
|
+ \see setFillOrder, setWrap, element, hasElement, take, remove
|
|
|
+*/
|
|
|
+bool QCPLayoutGrid::addElement(QCPLayoutElement *element)
|
|
|
+{
|
|
|
+ int rowIndex = 0;
|
|
|
+ int colIndex = 0;
|
|
|
+ if (mFillOrder == foColumnsFirst)
|
|
|
+ {
|
|
|
+ while (hasElement(rowIndex, colIndex))
|
|
|
+ {
|
|
|
+ ++colIndex;
|
|
|
+ if (colIndex >= mWrap && mWrap > 0)
|
|
|
+ {
|
|
|
+ colIndex = 0;
|
|
|
+ ++rowIndex;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ while (hasElement(rowIndex, colIndex))
|
|
|
+ {
|
|
|
+ ++rowIndex;
|
|
|
+ if (rowIndex >= mWrap && mWrap > 0)
|
|
|
+ {
|
|
|
+ rowIndex = 0;
|
|
|
+ ++colIndex;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return addElement(rowIndex, colIndex, element);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ 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, regardless of the stretch factor. (see \ref
|
|
|
+ QCPLayoutElement::setMinimumSize, \ref QCPLayoutElement::setMaximumSize, \ref
|
|
|
+ QCPLayoutElement::setSizeConstraintRect.)
|
|
|
+
|
|
|
+ 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, regardless of the stretch factor. (see \ref
|
|
|
+ QCPLayoutElement::setMinimumSize, \ref QCPLayoutElement::setMaximumSize, \ref
|
|
|
+ QCPLayoutElement::setSizeConstraintRect.)
|
|
|
+
|
|
|
+ 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, regardless of the stretch factor. (see \ref
|
|
|
+ QCPLayoutElement::setMinimumSize, \ref QCPLayoutElement::setMaximumSize, \ref
|
|
|
+ QCPLayoutElement::setSizeConstraintRect.)
|
|
|
+
|
|
|
+ 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, regardless of the stretch factor. (see \ref
|
|
|
+ QCPLayoutElement::setMinimumSize, \ref QCPLayoutElement::setMaximumSize, \ref
|
|
|
+ QCPLayoutElement::setSizeConstraintRect.)
|
|
|
+
|
|
|
+ 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;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the maximum number of columns or rows that are used, before new elements added with \ref
|
|
|
+ addElement(QCPLayoutElement*) will start to fill the next row or column, respectively. It depends
|
|
|
+ on \ref setFillOrder, whether rows or columns are wrapped.
|
|
|
+
|
|
|
+ If \a count is set to zero, no wrapping will ever occur.
|
|
|
+
|
|
|
+ If you wish to re-wrap the elements currently in the layout, call \ref setFillOrder with \a
|
|
|
+ rearrange set to true (the actual fill order doesn't need to be changed for the rearranging to be
|
|
|
+ done).
|
|
|
+
|
|
|
+ Note that the method \ref addElement(int row, int column, QCPLayoutElement *element) with
|
|
|
+ explicitly stated row and column is not subject to wrapping and can place elements even beyond
|
|
|
+ the specified wrapping point.
|
|
|
+
|
|
|
+ \see setFillOrder
|
|
|
+*/
|
|
|
+void QCPLayoutGrid::setWrap(int count)
|
|
|
+{
|
|
|
+ mWrap = qMax(0, count);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the filling order and wrapping behaviour that is used when adding new elements with the
|
|
|
+ method \ref addElement(QCPLayoutElement*).
|
|
|
+
|
|
|
+ The specified \a order defines whether rows or columns are filled first. Using \ref setWrap, you
|
|
|
+ can control at which row/column count wrapping into the next column/row will occur. If you set it
|
|
|
+ to zero, no wrapping will ever occur. Changing the fill order also changes the meaning of the
|
|
|
+ linear index used e.g. in \ref elementAt and \ref takeAt.
|
|
|
+
|
|
|
+ If you want to have all current elements arranged in the new order, set \a rearrange to true. The
|
|
|
+ elements will be rearranged in a way that tries to preserve their linear index. However, empty
|
|
|
+ cells are skipped during build-up of the new cell order, which shifts the succeeding element's
|
|
|
+ index. The rearranging is performed even if the specified \a order is already the current fill
|
|
|
+ order. Thus this method can be used to re-wrap the current elements.
|
|
|
+
|
|
|
+ If \a rearrange is false, the current element arrangement is not changed, which means the
|
|
|
+ linear indexes change (because the linear index is dependent on the fill order).
|
|
|
+
|
|
|
+ Note that the method \ref addElement(int row, int column, QCPLayoutElement *element) with
|
|
|
+ explicitly stated row and column is not subject to wrapping and can place elements even beyond
|
|
|
+ the specified wrapping point.
|
|
|
+
|
|
|
+ \see setWrap, addElement(QCPLayoutElement*)
|
|
|
+*/
|
|
|
+void QCPLayoutGrid::setFillOrder(FillOrder order, bool rearrange)
|
|
|
+{
|
|
|
+ // if rearranging, take all elements via linear index of old fill order:
|
|
|
+ const int elCount = elementCount();
|
|
|
+ QVector<QCPLayoutElement*> tempElements;
|
|
|
+ if (rearrange)
|
|
|
+ {
|
|
|
+ tempElements.reserve(elCount);
|
|
|
+ for (int i=0; i<elCount; ++i)
|
|
|
+ {
|
|
|
+ if (elementAt(i))
|
|
|
+ tempElements.append(takeAt(i));
|
|
|
+ }
|
|
|
+ simplify();
|
|
|
+ }
|
|
|
+ // change fill order as requested:
|
|
|
+ mFillOrder = order;
|
|
|
+ // if rearranging, re-insert via linear index according to new fill order:
|
|
|
+ if (rearrange)
|
|
|
+ {
|
|
|
+ for (int i=0; i<tempElements.size(); ++i)
|
|
|
+ addElement(tempElements.at(i));
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ 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 column at the left) to \a columnCount (appends a column 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);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Converts the given \a row and \a column to the linear index used by some methods of \ref
|
|
|
+ QCPLayoutGrid and \ref QCPLayout.
|
|
|
+
|
|
|
+ The way the cells are indexed depends on \ref setFillOrder. If it is \ref foRowsFirst, the
|
|
|
+ indices increase left to right and then top to bottom. If it is \ref foColumnsFirst, the indices
|
|
|
+ increase top to bottom and then left to right.
|
|
|
+
|
|
|
+ For the returned index to be valid, \a row and \a column must be valid indices themselves, i.e.
|
|
|
+ greater or equal to zero and smaller than the current \ref rowCount/\ref columnCount.
|
|
|
+
|
|
|
+ \see indexToRowCol
|
|
|
+*/
|
|
|
+int QCPLayoutGrid::rowColToIndex(int row, int column) const
|
|
|
+{
|
|
|
+ if (row >= 0 && row < rowCount())
|
|
|
+ {
|
|
|
+ if (column >= 0 && column < columnCount())
|
|
|
+ {
|
|
|
+ switch (mFillOrder)
|
|
|
+ {
|
|
|
+ case foRowsFirst: return column*rowCount() + row;
|
|
|
+ case foColumnsFirst: return row*columnCount() + column;
|
|
|
+ }
|
|
|
+ } else
|
|
|
+ qDebug() << Q_FUNC_INFO << "row index out of bounds:" << row;
|
|
|
+ } else
|
|
|
+ qDebug() << Q_FUNC_INFO << "column index out of bounds:" << column;
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Converts the linear index to row and column indices and writes the result to \a row and \a
|
|
|
+ column.
|
|
|
+
|
|
|
+ The way the cells are indexed depends on \ref setFillOrder. If it is \ref foRowsFirst, the
|
|
|
+ indices increase left to right and then top to bottom. If it is \ref foColumnsFirst, the indices
|
|
|
+ increase top to bottom and then left to right.
|
|
|
+
|
|
|
+ If there are no cells (i.e. column or row count is zero), sets \a row and \a column to -1.
|
|
|
+
|
|
|
+ For the retrieved \a row and \a column to be valid, the passed \a index must be valid itself,
|
|
|
+ i.e. greater or equal to zero and smaller than the current \ref elementCount.
|
|
|
+
|
|
|
+ \see rowColToIndex
|
|
|
+*/
|
|
|
+void QCPLayoutGrid::indexToRowCol(int index, int &row, int &column) const
|
|
|
+{
|
|
|
+ row = -1;
|
|
|
+ column = -1;
|
|
|
+ const int nCols = columnCount();
|
|
|
+ const int nRows = rowCount();
|
|
|
+ if (nCols == 0 || nRows == 0)
|
|
|
+ return;
|
|
|
+ if (index < 0 || index >= elementCount())
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "index out of bounds:" << index;
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ switch (mFillOrder)
|
|
|
+ {
|
|
|
+ case foRowsFirst:
|
|
|
+ {
|
|
|
+ column = index / nRows;
|
|
|
+ row = index % nRows;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case foColumnsFirst:
|
|
|
+ {
|
|
|
+ row = index / nCols;
|
|
|
+ column = index % nCols;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/* 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)));
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ \seebaseclassmethod
|
|
|
+
|
|
|
+ Note that the association of the linear \a index to the row/column based cells depends on the
|
|
|
+ current setting of \ref setFillOrder.
|
|
|
+
|
|
|
+ \see rowColToIndex
|
|
|
+*/
|
|
|
+QCPLayoutElement *QCPLayoutGrid::elementAt(int index) const
|
|
|
+{
|
|
|
+ if (index >= 0 && index < elementCount())
|
|
|
+ {
|
|
|
+ int row, col;
|
|
|
+ indexToRowCol(index, row, col);
|
|
|
+ return mElements.at(row).at(col);
|
|
|
+ } else
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ \seebaseclassmethod
|
|
|
+
|
|
|
+ Note that the association of the linear \a index to the row/column based cells depends on the
|
|
|
+ current setting of \ref setFillOrder.
|
|
|
+
|
|
|
+ \see rowColToIndex
|
|
|
+*/
|
|
|
+QCPLayoutElement *QCPLayoutGrid::takeAt(int index)
|
|
|
+{
|
|
|
+ if (QCPLayoutElement *el = elementAt(index))
|
|
|
+ {
|
|
|
+ releaseElement(el);
|
|
|
+ int row, col;
|
|
|
+ indexToRowCol(index, row, col);
|
|
|
+ mElements[row][col] = 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;
|
|
|
+ const int elCount = elementCount();
|
|
|
+#if QT_VERSION >= QT_VERSION_CHECK(4, 7, 0)
|
|
|
+ result.reserve(elCount);
|
|
|
+#endif
|
|
|
+ for (int i=0; i<elCount; ++i)
|
|
|
+ result.append(elementAt(i));
|
|
|
+ if (recursive)
|
|
|
+ {
|
|
|
+ for (int i=0; i<elCount; ++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::minimumOuterSizeHint() 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;
|
|
|
+ result.rheight() += qMax(0, rowCount()-1) * mRowSpacing;
|
|
|
+ result.rwidth() += mMargins.left()+mMargins.right();
|
|
|
+ result.rheight() += mMargins.top()+mMargins.bottom();
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+QSize QCPLayoutGrid::maximumOuterSizeHint() 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;
|
|
|
+ result.rheight() += qMax(0, rowCount()-1) * mRowSpacing;
|
|
|
+ result.rwidth() += mMargins.left()+mMargins.right();
|
|
|
+ result.rheight() += mMargins.top()+mMargins.bottom();
|
|
|
+ if (result.height() > QWIDGETSIZE_MAX)
|
|
|
+ result.setHeight(QWIDGETSIZE_MAX);
|
|
|
+ if (result.width() > QWIDGETSIZE_MAX)
|
|
|
+ result.setWidth(QWIDGETSIZE_MAX);
|
|
|
+ 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's outer rect in that
|
|
|
+ row. The minimum width of a column is the largest minimum width of any element's outer rect 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 (QCPLayoutElement *el = mElements.at(row).at(col))
|
|
|
+ {
|
|
|
+ QSize minSize = getFinalMinimumOuterSize(el);
|
|
|
+ if (minColWidths->at(col) < minSize.width())
|
|
|
+ (*minColWidths)[col] = minSize.width();
|
|
|
+ if (minRowHeights->at(row) < minSize.height())
|
|
|
+ (*minRowHeights)[row] = minSize.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's outer rect in that
|
|
|
+ row. The maximum width of a column is the smallest maximum width of any element's outer rect 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 (QCPLayoutElement *el = mElements.at(row).at(col))
|
|
|
+ {
|
|
|
+ QSize maxSize = getFinalMaximumOuterSize(el);
|
|
|
+ if (maxColWidths->at(col) > maxSize.width())
|
|
|
+ (*maxColWidths)[col] = maxSize.width();
|
|
|
+ if (maxRowHeights->at(row) > maxSize.height())
|
|
|
+ (*maxRowHeights)[row] = maxSize.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)
|
|
|
+ {
|
|
|
+ QCPLayoutElement *el = mElements.at(i);
|
|
|
+ QRect insetRect;
|
|
|
+ QSize finalMinSize = getFinalMinimumOuterSize(el);
|
|
|
+ QSize finalMaxSize = getFinalMaximumOuterSize(el);
|
|
|
+ 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";
|
|
|
+}
|
|
|
+/* end of 'src/layout.cpp' */
|
|
|
+
|
|
|
+
|
|
|
+/* including file 'src/lineending.cpp', size 11536 */
|
|
|
+/* commit 9868e55d3b412f2f89766bb482fcf299e93a0988 2017-09-04 01:56:22 +0200 */
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// 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 QCPVector2D &pos, const QCPVector2D &dir) const
|
|
|
+{
|
|
|
+ if (mStyle == esNone)
|
|
|
+ return;
|
|
|
+
|
|
|
+ QCPVector2D lengthVec = dir.normalized() * mLength*(mInverted ? -1 : 1);
|
|
|
+ if (lengthVec.isNull())
|
|
|
+ lengthVec = QCPVector2D(1, 0);
|
|
|
+ QCPVector2D widthVec = dir.normalized().perpendicular() * 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.8).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:
|
|
|
+ {
|
|
|
+ QCPVector2D widthVecPerp = widthVec.perpendicular();
|
|
|
+ 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:
|
|
|
+ {
|
|
|
+ QCPVector2D widthVecPerp = widthVec.perpendicular();
|
|
|
+ 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.2*(mInverted?-1:1)).toPointF(),
|
|
|
+ (pos-widthVec-lengthVec*0.2*(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.2*(mInverted?-1:1)+dir.normalized()*qMax(1.0f, (float)painter->pen().widthF())*0.5f).toPointF(),
|
|
|
+ (pos-widthVec-lengthVec*0.2*(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 QCPVector2D &pos, double angle) const
|
|
|
+{
|
|
|
+ draw(painter, pos, QCPVector2D(qCos(angle), qSin(angle)));
|
|
|
+}
|
|
|
+/* end of 'src/lineending.cpp' */
|
|
|
+
|
|
|
+
|
|
|
+/* including file 'src/axis/axisticker.cpp', size 18664 */
|
|
|
+/* commit 9868e55d3b412f2f89766bb482fcf299e93a0988 2017-09-04 01:56:22 +0200 */
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPAxisTicker
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+/*! \class QCPAxisTicker
|
|
|
+ \brief The base class tick generator used by QCPAxis to create tick positions and tick labels
|
|
|
+
|
|
|
+ Each QCPAxis has an internal QCPAxisTicker (or a subclass) in order to generate tick positions
|
|
|
+ and tick labels for the current axis range. The ticker of an axis can be set via \ref
|
|
|
+ QCPAxis::setTicker. Since that method takes a <tt>QSharedPointer<QCPAxisTicker></tt>, multiple
|
|
|
+ axes can share the same ticker instance.
|
|
|
+
|
|
|
+ This base class generates normal tick coordinates and numeric labels for linear axes. It picks a
|
|
|
+ reasonable tick step (the separation between ticks) which results in readable tick labels. The
|
|
|
+ number of ticks that should be approximately generated can be set via \ref setTickCount.
|
|
|
+ Depending on the current tick step strategy (\ref setTickStepStrategy), the algorithm either
|
|
|
+ sacrifices readability to better match the specified tick count (\ref
|
|
|
+ QCPAxisTicker::tssMeetTickCount) or relaxes the tick count in favor of better tick steps (\ref
|
|
|
+ QCPAxisTicker::tssReadability), which is the default.
|
|
|
+
|
|
|
+ The following more specialized axis ticker subclasses are available, see details in the
|
|
|
+ respective class documentation:
|
|
|
+
|
|
|
+ <center>
|
|
|
+ <table>
|
|
|
+ <tr><td style="text-align:right; padding: 0 1em">QCPAxisTickerFixed</td><td>\image html axisticker-fixed.png</td></tr>
|
|
|
+ <tr><td style="text-align:right; padding: 0 1em">QCPAxisTickerLog</td><td>\image html axisticker-log.png</td></tr>
|
|
|
+ <tr><td style="text-align:right; padding: 0 1em">QCPAxisTickerPi</td><td>\image html axisticker-pi.png</td></tr>
|
|
|
+ <tr><td style="text-align:right; padding: 0 1em">QCPAxisTickerText</td><td>\image html axisticker-text.png</td></tr>
|
|
|
+ <tr><td style="text-align:right; padding: 0 1em">QCPAxisTickerDateTime</td><td>\image html axisticker-datetime.png</td></tr>
|
|
|
+ <tr><td style="text-align:right; padding: 0 1em">QCPAxisTickerTime</td><td>\image html axisticker-time.png
|
|
|
+ \image html axisticker-time2.png</td></tr>
|
|
|
+ </table>
|
|
|
+ </center>
|
|
|
+
|
|
|
+ \section axisticker-subclassing Creating own axis tickers
|
|
|
+
|
|
|
+ Creating own axis tickers can be achieved very easily by sublassing QCPAxisTicker and
|
|
|
+ reimplementing some or all of the available virtual methods.
|
|
|
+
|
|
|
+ In the simplest case you might wish to just generate different tick steps than the other tickers,
|
|
|
+ so you only reimplement the method \ref getTickStep. If you additionally want control over the
|
|
|
+ string that will be shown as tick label, reimplement \ref getTickLabel.
|
|
|
+
|
|
|
+ If you wish to have complete control, you can generate the tick vectors and tick label vectors
|
|
|
+ yourself by reimplementing \ref createTickVector and \ref createLabelVector. The default
|
|
|
+ implementations use the previously mentioned virtual methods \ref getTickStep and \ref
|
|
|
+ getTickLabel, but your reimplementations don't necessarily need to do so. For example in the case
|
|
|
+ of unequal tick steps, the method \ref getTickStep loses its usefulness and can be ignored.
|
|
|
+
|
|
|
+ The sub tick count between major ticks can be controlled with \ref getSubTickCount. Full sub tick
|
|
|
+ placement control is obtained by reimplementing \ref createSubTickVector.
|
|
|
+
|
|
|
+ See the documentation of all these virtual methods in QCPAxisTicker for detailed information
|
|
|
+ about the parameters and expected return values.
|
|
|
+*/
|
|
|
+
|
|
|
+/*!
|
|
|
+ Constructs the ticker and sets reasonable default values. Axis tickers are commonly created
|
|
|
+ managed by a QSharedPointer, which then can be passed to QCPAxis::setTicker.
|
|
|
+*/
|
|
|
+QCPAxisTicker::QCPAxisTicker() :
|
|
|
+ mTickStepStrategy(tssReadability),
|
|
|
+ mTickCount(5),
|
|
|
+ mTickOrigin(0)
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+QCPAxisTicker::~QCPAxisTicker()
|
|
|
+{
|
|
|
+
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets which strategy the axis ticker follows when choosing the size of the tick step. For the
|
|
|
+ available strategies, see \ref TickStepStrategy.
|
|
|
+*/
|
|
|
+void QCPAxisTicker::setTickStepStrategy(QCPAxisTicker::TickStepStrategy strategy)
|
|
|
+{
|
|
|
+ mTickStepStrategy = strategy;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets how many ticks this ticker shall aim to generate across the axis range. Note that \a count
|
|
|
+ is not guaranteed to be matched exactly, as generating readable tick intervals may conflict with
|
|
|
+ the requested number of ticks.
|
|
|
+
|
|
|
+ Whether the readability has priority over meeting the requested \a count can be specified with
|
|
|
+ \ref setTickStepStrategy.
|
|
|
+*/
|
|
|
+void QCPAxisTicker::setTickCount(int count)
|
|
|
+{
|
|
|
+ if (count > 0)
|
|
|
+ mTickCount = count;
|
|
|
+ else
|
|
|
+ qDebug() << Q_FUNC_INFO << "tick count must be greater than zero:" << count;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the mathematical coordinate (or "offset") of the zeroth tick. This tick coordinate is just a
|
|
|
+ concept and doesn't need to be inside the currently visible axis range.
|
|
|
+
|
|
|
+ By default \a origin is zero, which for example yields ticks {-5, 0, 5, 10, 15,...} when the tick
|
|
|
+ step is five. If \a origin is now set to 1 instead, the correspondingly generated ticks would be
|
|
|
+ {-4, 1, 6, 11, 16,...}.
|
|
|
+*/
|
|
|
+void QCPAxisTicker::setTickOrigin(double origin)
|
|
|
+{
|
|
|
+ mTickOrigin = origin;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ This is the method called by QCPAxis in order to actually generate tick coordinates (\a ticks),
|
|
|
+ tick label strings (\a tickLabels) and sub tick coordinates (\a subTicks).
|
|
|
+
|
|
|
+ The ticks are generated for the specified \a range. The generated labels typically follow the
|
|
|
+ specified \a locale, \a formatChar and number \a precision, however this might be different (or
|
|
|
+ even irrelevant) for certain QCPAxisTicker subclasses.
|
|
|
+
|
|
|
+ The output parameter \a ticks is filled with the generated tick positions in axis coordinates.
|
|
|
+ The output parameters \a subTicks and \a tickLabels are optional (set them to 0 if not needed)
|
|
|
+ and are respectively filled with sub tick coordinates, and tick label strings belonging to \a
|
|
|
+ ticks by index.
|
|
|
+*/
|
|
|
+void QCPAxisTicker::generate(const QCPRange &range, const QLocale &locale, QChar formatChar, int precision, QVector<double> &ticks, QVector<double> *subTicks, QVector<QString> *tickLabels)
|
|
|
+{
|
|
|
+ // generate (major) ticks:
|
|
|
+ double tickStep = getTickStep(range);
|
|
|
+ ticks = createTickVector(tickStep, range);
|
|
|
+ trimTicks(range, ticks, true); // trim ticks to visible range plus one outer tick on each side (incase a subclass createTickVector creates more)
|
|
|
+
|
|
|
+ // generate sub ticks between major ticks:
|
|
|
+ if (subTicks)
|
|
|
+ {
|
|
|
+ if (ticks.size() > 0)
|
|
|
+ {
|
|
|
+ *subTicks = createSubTickVector(getSubTickCount(tickStep), ticks);
|
|
|
+ trimTicks(range, *subTicks, false);
|
|
|
+ } else
|
|
|
+ *subTicks = QVector<double>();
|
|
|
+ }
|
|
|
+
|
|
|
+ // finally trim also outliers (no further clipping happens in axis drawing):
|
|
|
+ trimTicks(range, ticks, false);
|
|
|
+ // generate labels for visible ticks if requested:
|
|
|
+ if (tickLabels)
|
|
|
+ *tickLabels = createLabelVector(ticks, locale, formatChar, precision);
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Takes the entire currently visible axis range and returns a sensible tick step in
|
|
|
+ order to provide readable tick labels as well as a reasonable number of tick counts (see \ref
|
|
|
+ setTickCount, \ref setTickStepStrategy).
|
|
|
+
|
|
|
+ If a QCPAxisTicker subclass only wants a different tick step behaviour than the default
|
|
|
+ implementation, it should reimplement this method. See \ref cleanMantissa for a possible helper
|
|
|
+ function.
|
|
|
+*/
|
|
|
+double QCPAxisTicker::getTickStep(const QCPRange &range)
|
|
|
+{
|
|
|
+ double exactStep = range.size()/(double)(mTickCount+1e-10); // mTickCount ticks on average, the small addition is to prevent jitter on exact integers
|
|
|
+ return cleanMantissa(exactStep);
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Takes the \a tickStep, i.e. the distance between two consecutive ticks, and returns
|
|
|
+ an appropriate number of sub ticks for that specific tick step.
|
|
|
+
|
|
|
+ Note that a returned sub tick count of e.g. 4 will split each tick interval into 5 sections.
|
|
|
+*/
|
|
|
+int QCPAxisTicker::getSubTickCount(double tickStep)
|
|
|
+{
|
|
|
+ int result = 1; // default to 1, if no proper value can be found
|
|
|
+
|
|
|
+ // separate integer and fractional part of mantissa:
|
|
|
+ double epsilon = 0.01;
|
|
|
+ double intPartf;
|
|
|
+ int intPart;
|
|
|
+ double fracPart = modf(getMantissa(tickStep), &intPartf);
|
|
|
+ intPart = intPartf;
|
|
|
+
|
|
|
+ // handle cases with (almost) integer mantissa:
|
|
|
+ if (fracPart < epsilon || 1.0-fracPart < epsilon)
|
|
|
+ {
|
|
|
+ if (1.0-fracPart < epsilon)
|
|
|
+ ++intPart;
|
|
|
+ switch (intPart)
|
|
|
+ {
|
|
|
+ case 1: result = 4; break; // 1.0 -> 0.2 substep
|
|
|
+ case 2: result = 3; break; // 2.0 -> 0.5 substep
|
|
|
+ case 3: result = 2; break; // 3.0 -> 1.0 substep
|
|
|
+ case 4: result = 3; break; // 4.0 -> 1.0 substep
|
|
|
+ case 5: result = 4; break; // 5.0 -> 1.0 substep
|
|
|
+ case 6: result = 2; break; // 6.0 -> 2.0 substep
|
|
|
+ case 7: result = 6; break; // 7.0 -> 1.0 substep
|
|
|
+ case 8: result = 3; break; // 8.0 -> 2.0 substep
|
|
|
+ case 9: result = 2; break; // 9.0 -> 3.0 substep
|
|
|
+ }
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ // handle cases with significantly fractional mantissa:
|
|
|
+ if (qAbs(fracPart-0.5) < epsilon) // *.5 mantissa
|
|
|
+ {
|
|
|
+ switch (intPart)
|
|
|
+ {
|
|
|
+ case 1: result = 2; break; // 1.5 -> 0.5 substep
|
|
|
+ case 2: result = 4; break; // 2.5 -> 0.5 substep
|
|
|
+ case 3: result = 4; break; // 3.5 -> 0.7 substep
|
|
|
+ case 4: result = 2; break; // 4.5 -> 1.5 substep
|
|
|
+ case 5: result = 4; break; // 5.5 -> 1.1 substep (won't occur with default getTickStep from here on)
|
|
|
+ case 6: result = 4; break; // 6.5 -> 1.3 substep
|
|
|
+ case 7: result = 2; break; // 7.5 -> 2.5 substep
|
|
|
+ case 8: result = 4; break; // 8.5 -> 1.7 substep
|
|
|
+ case 9: result = 4; break; // 9.5 -> 1.9 substep
|
|
|
+ }
|
|
|
+ }
|
|
|
+ // if mantissa fraction isn't 0.0 or 0.5, don't bother finding good sub tick marks, leave default
|
|
|
+ }
|
|
|
+
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ This method returns the tick label string as it should be printed under the \a tick coordinate.
|
|
|
+ If a textual number is returned, it should respect the provided \a locale, \a formatChar and \a
|
|
|
+ precision.
|
|
|
+
|
|
|
+ If the returned value contains exponentials of the form "2e5" and beautifully typeset powers is
|
|
|
+ enabled in the QCPAxis number format (\ref QCPAxis::setNumberFormat), the exponential part will
|
|
|
+ be formatted accordingly using multiplication symbol and superscript during rendering of the
|
|
|
+ label automatically.
|
|
|
+*/
|
|
|
+QString QCPAxisTicker::getTickLabel(double tick, const QLocale &locale, QChar formatChar, int precision)
|
|
|
+{
|
|
|
+ return locale.toString(tick, formatChar.toLatin1(), precision);
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns a vector containing all coordinates of sub ticks that should be drawn. It generates \a
|
|
|
+ subTickCount sub ticks between each tick pair given in \a ticks.
|
|
|
+
|
|
|
+ If a QCPAxisTicker subclass needs maximal control over the generated sub ticks, it should
|
|
|
+ reimplement this method. Depending on the purpose of the subclass it doesn't necessarily need to
|
|
|
+ base its result on \a subTickCount or \a ticks.
|
|
|
+*/
|
|
|
+QVector<double> QCPAxisTicker::createSubTickVector(int subTickCount, const QVector<double> &ticks)
|
|
|
+{
|
|
|
+ QVector<double> result;
|
|
|
+ if (subTickCount <= 0 || ticks.size() < 2)
|
|
|
+ return result;
|
|
|
+
|
|
|
+ result.reserve((ticks.size()-1)*subTickCount);
|
|
|
+ for (int i=1; i<ticks.size(); ++i)
|
|
|
+ {
|
|
|
+ double subTickStep = (ticks.at(i)-ticks.at(i-1))/(double)(subTickCount+1);
|
|
|
+ for (int k=1; k<=subTickCount; ++k)
|
|
|
+ result.append(ticks.at(i-1) + k*subTickStep);
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns a vector containing all coordinates of ticks that should be drawn. The default
|
|
|
+ implementation generates ticks with a spacing of \a tickStep (mathematically starting at the tick
|
|
|
+ step origin, see \ref setTickOrigin) distributed over the passed \a range.
|
|
|
+
|
|
|
+ In order for the axis ticker to generate proper sub ticks, it is necessary that the first and
|
|
|
+ last tick coordinates returned by this method are just below/above the provided \a range.
|
|
|
+ Otherwise the outer intervals won't contain any sub ticks.
|
|
|
+
|
|
|
+ If a QCPAxisTicker subclass needs maximal control over the generated ticks, it should reimplement
|
|
|
+ this method. Depending on the purpose of the subclass it doesn't necessarily need to base its
|
|
|
+ result on \a tickStep, e.g. when the ticks are spaced unequally like in the case of
|
|
|
+ QCPAxisTickerLog.
|
|
|
+*/
|
|
|
+QVector<double> QCPAxisTicker::createTickVector(double tickStep, const QCPRange &range)
|
|
|
+{
|
|
|
+ QVector<double> result;
|
|
|
+ // Generate tick positions according to tickStep:
|
|
|
+ qint64 firstStep = floor((range.lower-mTickOrigin)/tickStep); // do not use qFloor here, or we'll lose 64 bit precision
|
|
|
+ qint64 lastStep = ceil((range.upper-mTickOrigin)/tickStep); // do not use qCeil here, or we'll lose 64 bit precision
|
|
|
+ int tickcount = lastStep-firstStep+1;
|
|
|
+ if (tickcount < 0) tickcount = 0;
|
|
|
+ result.resize(tickcount);
|
|
|
+ for (int i=0; i<tickcount; ++i)
|
|
|
+ result[i] = mTickOrigin + (firstStep+i)*tickStep;
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns a vector containing all tick label strings corresponding to the tick coordinates provided
|
|
|
+ in \a ticks. The default implementation calls \ref getTickLabel to generate the respective
|
|
|
+ strings.
|
|
|
+
|
|
|
+ It is possible but uncommon for QCPAxisTicker subclasses to reimplement this method, as
|
|
|
+ reimplementing \ref getTickLabel often achieves the intended result easier.
|
|
|
+*/
|
|
|
+QVector<QString> QCPAxisTicker::createLabelVector(const QVector<double> &ticks, const QLocale &locale, QChar formatChar, int precision)
|
|
|
+{
|
|
|
+ QVector<QString> result;
|
|
|
+ result.reserve(ticks.size());
|
|
|
+ for (int i=0; i<ticks.size(); ++i)
|
|
|
+ result.append(getTickLabel(ticks.at(i), locale, formatChar, precision));
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Removes tick coordinates from \a ticks which lie outside the specified \a range. If \a
|
|
|
+ keepOneOutlier is true, it preserves one tick just outside the range on both sides, if present.
|
|
|
+
|
|
|
+ The passed \a ticks must be sorted in ascending order.
|
|
|
+*/
|
|
|
+void QCPAxisTicker::trimTicks(const QCPRange &range, QVector<double> &ticks, bool keepOneOutlier) const
|
|
|
+{
|
|
|
+ bool lowFound = false;
|
|
|
+ bool highFound = false;
|
|
|
+ int lowIndex = 0;
|
|
|
+ int highIndex = -1;
|
|
|
+
|
|
|
+ for (int i=0; i < ticks.size(); ++i)
|
|
|
+ {
|
|
|
+ if (ticks.at(i) >= range.lower)
|
|
|
+ {
|
|
|
+ lowFound = true;
|
|
|
+ lowIndex = i;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ for (int i=ticks.size()-1; i >= 0; --i)
|
|
|
+ {
|
|
|
+ if (ticks.at(i) <= range.upper)
|
|
|
+ {
|
|
|
+ highFound = true;
|
|
|
+ highIndex = i;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (highFound && lowFound)
|
|
|
+ {
|
|
|
+ int trimFront = qMax(0, lowIndex-(keepOneOutlier ? 1 : 0));
|
|
|
+ int trimBack = qMax(0, ticks.size()-(keepOneOutlier ? 2 : 1)-highIndex);
|
|
|
+ if (trimFront > 0 || trimBack > 0)
|
|
|
+ ticks = ticks.mid(trimFront, ticks.size()-trimFront-trimBack);
|
|
|
+ } else // all ticks are either all below or all above the range
|
|
|
+ ticks.clear();
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the coordinate contained in \a candidates which is closest to the provided \a target.
|
|
|
+
|
|
|
+ This method assumes \a candidates is not empty and sorted in ascending order.
|
|
|
+*/
|
|
|
+double QCPAxisTicker::pickClosest(double target, const QVector<double> &candidates) const
|
|
|
+{
|
|
|
+ if (candidates.size() == 1)
|
|
|
+ return candidates.first();
|
|
|
+ QVector<double>::const_iterator it = std::lower_bound(candidates.constBegin(), candidates.constEnd(), target);
|
|
|
+ if (it == candidates.constEnd())
|
|
|
+ return *(it-1);
|
|
|
+ else if (it == candidates.constBegin())
|
|
|
+ return *it;
|
|
|
+ else
|
|
|
+ return target-*(it-1) < *it-target ? *(it-1) : *it;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the decimal mantissa of \a input. Optionally, if \a magnitude is not set to zero, it also
|
|
|
+ returns the magnitude of \a input as a power of 10.
|
|
|
+
|
|
|
+ For example, an input of 142.6 will return a mantissa of 1.426 and a magnitude of 100.
|
|
|
+*/
|
|
|
+double QCPAxisTicker::getMantissa(double input, double *magnitude) const
|
|
|
+{
|
|
|
+ const double mag = qPow(10.0, qFloor(qLn(input)/qLn(10.0)));
|
|
|
+ if (magnitude) *magnitude = mag;
|
|
|
+ return input/mag;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns a number that is close to \a input but has a clean, easier human readable mantissa. How
|
|
|
+ strongly the mantissa is altered, and thus how strong the result deviates from the original \a
|
|
|
+ input, depends on the current tick step strategy (see \ref setTickStepStrategy).
|
|
|
+*/
|
|
|
+double QCPAxisTicker::cleanMantissa(double input) const
|
|
|
+{
|
|
|
+ double magnitude;
|
|
|
+ const double mantissa = getMantissa(input, &magnitude);
|
|
|
+ switch (mTickStepStrategy)
|
|
|
+ {
|
|
|
+ case tssReadability:
|
|
|
+ {
|
|
|
+ return pickClosest(mantissa, QVector<double>() << 1.0 << 2.0 << 2.5 << 5.0 << 10.0)*magnitude;
|
|
|
+ }
|
|
|
+ case tssMeetTickCount:
|
|
|
+ {
|
|
|
+ // this gives effectively a mantissa of 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0, 6.0, 8.0, 10.0
|
|
|
+ if (mantissa <= 5.0)
|
|
|
+ return (int)(mantissa*2)/2.0*magnitude; // round digit after decimal point to 0.5
|
|
|
+ else
|
|
|
+ return (int)(mantissa/2.0)*2.0*magnitude; // round to first digit in multiples of 2
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return input;
|
|
|
+}
|
|
|
+/* end of 'src/axis/axisticker.cpp' */
|
|
|
+
|
|
|
+
|
|
|
+/* including file 'src/axis/axistickerdatetime.cpp', size 14443 */
|
|
|
+/* commit 9868e55d3b412f2f89766bb482fcf299e93a0988 2017-09-04 01:56:22 +0200 */
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPAxisTickerDateTime
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+/*! \class QCPAxisTickerDateTime
|
|
|
+ \brief Specialized axis ticker for calendar dates and times as axis ticks
|
|
|
+
|
|
|
+ \image html axisticker-datetime.png
|
|
|
+
|
|
|
+ This QCPAxisTicker subclass generates ticks that correspond to real calendar dates and times. The
|
|
|
+ plot axis coordinate is interpreted as Unix Time, so seconds since Epoch (January 1, 1970, 00:00
|
|
|
+ UTC). This is also used for example by QDateTime in the <tt>toTime_t()/setTime_t()</tt> methods
|
|
|
+ with a precision of one second. Since Qt 4.7, millisecond accuracy can be obtained from QDateTime
|
|
|
+ by using <tt>QDateTime::fromMSecsSinceEpoch()/1000.0</tt>. The static methods \ref dateTimeToKey
|
|
|
+ and \ref keyToDateTime conveniently perform this conversion achieving a precision of one
|
|
|
+ millisecond on all Qt versions.
|
|
|
+
|
|
|
+ The format of the date/time display in the tick labels is controlled with \ref setDateTimeFormat.
|
|
|
+ If a different time spec (time zone) shall be used, see \ref setDateTimeSpec.
|
|
|
+
|
|
|
+ This ticker produces unequal tick spacing in order to provide intuitive date and time-of-day
|
|
|
+ ticks. For example, if the axis range spans a few years such that there is one tick per year,
|
|
|
+ ticks will be positioned on 1. January of every year. This is intuitive but, due to leap years,
|
|
|
+ will result in slightly unequal tick intervals (visually unnoticeable). The same can be seen in
|
|
|
+ the image above: even though the number of days varies month by month, this ticker generates
|
|
|
+ ticks on the same day of each month.
|
|
|
+
|
|
|
+ If you would like to change the date/time that is used as a (mathematical) starting date for the
|
|
|
+ ticks, use the \ref setTickOrigin(const QDateTime &origin) method overload, which takes a
|
|
|
+ QDateTime. If you pass 15. July, 9:45 to this method, the yearly ticks will end up on 15. July at
|
|
|
+ 9:45 of every year.
|
|
|
+
|
|
|
+ The ticker can be created and assigned to an axis like this:
|
|
|
+ \snippet documentation/doc-image-generator/mainwindow.cpp axistickerdatetime-creation
|
|
|
+
|
|
|
+ \note If you rather wish to display relative times in terms of days, hours, minutes, seconds and
|
|
|
+ milliseconds, and are not interested in the intricacies of real calendar dates with months and
|
|
|
+ (leap) years, have a look at QCPAxisTickerTime instead.
|
|
|
+*/
|
|
|
+
|
|
|
+/*!
|
|
|
+ Constructs the ticker and sets reasonable default values. Axis tickers are commonly created
|
|
|
+ managed by a QSharedPointer, which then can be passed to QCPAxis::setTicker.
|
|
|
+*/
|
|
|
+QCPAxisTickerDateTime::QCPAxisTickerDateTime() :
|
|
|
+ mDateTimeFormat(QLatin1String("hh:mm:ss\ndd.MM.yy")),
|
|
|
+ mDateTimeSpec(Qt::LocalTime),
|
|
|
+ mDateStrategy(dsNone)
|
|
|
+{
|
|
|
+ setTickCount(4);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the format in which dates and times are displayed as tick labels. For details about the \a
|
|
|
+ format string, see the documentation of QDateTime::toString().
|
|
|
+
|
|
|
+ Newlines can be inserted with "\n".
|
|
|
+
|
|
|
+ \see setDateTimeSpec
|
|
|
+*/
|
|
|
+void QCPAxisTickerDateTime::setDateTimeFormat(const QString &format)
|
|
|
+{
|
|
|
+ mDateTimeFormat = format;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the time spec that is used for creating the tick labels from corresponding dates/times.
|
|
|
+
|
|
|
+ The default value of QDateTime objects (and also QCPAxisTickerDateTime) is
|
|
|
+ <tt>Qt::LocalTime</tt>. However, if the date time values passed to QCustomPlot (e.g. in the form
|
|
|
+ of axis ranges or keys of a plottable) are given in the UTC spec, set \a spec to <tt>Qt::UTC</tt>
|
|
|
+ to get the correct axis labels.
|
|
|
+
|
|
|
+ \see setDateTimeFormat
|
|
|
+*/
|
|
|
+void QCPAxisTickerDateTime::setDateTimeSpec(Qt::TimeSpec spec)
|
|
|
+{
|
|
|
+ mDateTimeSpec = spec;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the tick origin (see \ref QCPAxisTicker::setTickOrigin) in seconds since Epoch (1. Jan 1970,
|
|
|
+ 00:00 UTC). For the date time ticker it might be more intuitive to use the overload which
|
|
|
+ directly takes a QDateTime, see \ref setTickOrigin(const QDateTime &origin).
|
|
|
+
|
|
|
+ This is useful to define the month/day/time recurring at greater tick interval steps. For
|
|
|
+ example, If you pass 15. July, 9:45 to this method and the tick interval happens to be one tick
|
|
|
+ per year, the ticks will end up on 15. July at 9:45 of every year.
|
|
|
+*/
|
|
|
+void QCPAxisTickerDateTime::setTickOrigin(double origin)
|
|
|
+{
|
|
|
+ QCPAxisTicker::setTickOrigin(origin);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the tick origin (see \ref QCPAxisTicker::setTickOrigin) as a QDateTime \a origin.
|
|
|
+
|
|
|
+ This is useful to define the month/day/time recurring at greater tick interval steps. For
|
|
|
+ example, If you pass 15. July, 9:45 to this method and the tick interval happens to be one tick
|
|
|
+ per year, the ticks will end up on 15. July at 9:45 of every year.
|
|
|
+*/
|
|
|
+void QCPAxisTickerDateTime::setTickOrigin(const QDateTime &origin)
|
|
|
+{
|
|
|
+ setTickOrigin(dateTimeToKey(origin));
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns a sensible tick step with intervals appropriate for a date-time-display, such as weekly,
|
|
|
+ monthly, bi-monthly, etc.
|
|
|
+
|
|
|
+ Note that this tick step isn't used exactly when generating the tick vector in \ref
|
|
|
+ createTickVector, but only as a guiding value requiring some correction for each individual tick
|
|
|
+ interval. Otherwise this would lead to unintuitive date displays, e.g. jumping between first day
|
|
|
+ in the month to the last day in the previous month from tick to tick, due to the non-uniform
|
|
|
+ length of months. The same problem arises with leap years.
|
|
|
+
|
|
|
+ \seebaseclassmethod
|
|
|
+*/
|
|
|
+double QCPAxisTickerDateTime::getTickStep(const QCPRange &range)
|
|
|
+{
|
|
|
+ double result = range.size()/(double)(mTickCount+1e-10); // mTickCount ticks on average, the small addition is to prevent jitter on exact integers
|
|
|
+
|
|
|
+ mDateStrategy = dsNone;
|
|
|
+ if (result < 1) // ideal tick step is below 1 second -> use normal clean mantissa algorithm in units of seconds
|
|
|
+ {
|
|
|
+ result = cleanMantissa(result);
|
|
|
+ } else if (result < 86400*30.4375*12) // below a year
|
|
|
+ {
|
|
|
+ result = pickClosest(result, QVector<double>()
|
|
|
+ << 1 << 2.5 << 5 << 10 << 15 << 30 << 60 << 2.5*60 << 5*60 << 10*60 << 15*60 << 30*60 << 60*60 // second, minute, hour range
|
|
|
+ << 3600*2 << 3600*3 << 3600*6 << 3600*12 << 3600*24 // hour to day range
|
|
|
+ << 86400*2 << 86400*5 << 86400*7 << 86400*14 << 86400*30.4375 << 86400*30.4375*2 << 86400*30.4375*3 << 86400*30.4375*6 << 86400*30.4375*12); // day, week, month range (avg. days per month includes leap years)
|
|
|
+ if (result > 86400*30.4375-1) // month tick intervals or larger
|
|
|
+ mDateStrategy = dsUniformDayInMonth;
|
|
|
+ else if (result > 3600*24-1) // day tick intervals or larger
|
|
|
+ mDateStrategy = dsUniformTimeInDay;
|
|
|
+ } else // more than a year, go back to normal clean mantissa algorithm but in units of years
|
|
|
+ {
|
|
|
+ const double secondsPerYear = 86400*30.4375*12; // average including leap years
|
|
|
+ result = cleanMantissa(result/secondsPerYear)*secondsPerYear;
|
|
|
+ mDateStrategy = dsUniformDayInMonth;
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns a sensible sub tick count with intervals appropriate for a date-time-display, such as weekly,
|
|
|
+ monthly, bi-monthly, etc.
|
|
|
+
|
|
|
+ \seebaseclassmethod
|
|
|
+*/
|
|
|
+int QCPAxisTickerDateTime::getSubTickCount(double tickStep)
|
|
|
+{
|
|
|
+ int result = QCPAxisTicker::getSubTickCount(tickStep);
|
|
|
+ switch (qRound(tickStep)) // hand chosen subticks for specific minute/hour/day/week/month range (as specified in getTickStep)
|
|
|
+ {
|
|
|
+ case 5*60: result = 4; break;
|
|
|
+ case 10*60: result = 1; break;
|
|
|
+ case 15*60: result = 2; break;
|
|
|
+ case 30*60: result = 1; break;
|
|
|
+ case 60*60: result = 3; break;
|
|
|
+ case 3600*2: result = 3; break;
|
|
|
+ case 3600*3: result = 2; break;
|
|
|
+ case 3600*6: result = 1; break;
|
|
|
+ case 3600*12: result = 3; break;
|
|
|
+ case 3600*24: result = 3; break;
|
|
|
+ case 86400*2: result = 1; break;
|
|
|
+ case 86400*5: result = 4; break;
|
|
|
+ case 86400*7: result = 6; break;
|
|
|
+ case 86400*14: result = 1; break;
|
|
|
+ case (int)(86400*30.4375+0.5): result = 3; break;
|
|
|
+ case (int)(86400*30.4375*2+0.5): result = 1; break;
|
|
|
+ case (int)(86400*30.4375*3+0.5): result = 2; break;
|
|
|
+ case (int)(86400*30.4375*6+0.5): result = 5; break;
|
|
|
+ case (int)(86400*30.4375*12+0.5): result = 3; break;
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Generates a date/time tick label for tick coordinate \a tick, based on the currently set format
|
|
|
+ (\ref setDateTimeFormat) and time spec (\ref setDateTimeSpec).
|
|
|
+
|
|
|
+ \seebaseclassmethod
|
|
|
+*/
|
|
|
+QString QCPAxisTickerDateTime::getTickLabel(double tick, const QLocale &locale, QChar formatChar, int precision)
|
|
|
+{
|
|
|
+ Q_UNUSED(precision)
|
|
|
+ Q_UNUSED(formatChar)
|
|
|
+ return locale.toString(keyToDateTime(tick).toTimeSpec(mDateTimeSpec), mDateTimeFormat);
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Uses the passed \a tickStep as a guiding value and applies corrections in order to obtain
|
|
|
+ non-uniform tick intervals but intuitive tick labels, e.g. falling on the same day of each month.
|
|
|
+
|
|
|
+ \seebaseclassmethod
|
|
|
+*/
|
|
|
+QVector<double> QCPAxisTickerDateTime::createTickVector(double tickStep, const QCPRange &range)
|
|
|
+{
|
|
|
+ QVector<double> result = QCPAxisTicker::createTickVector(tickStep, range);
|
|
|
+ if (!result.isEmpty())
|
|
|
+ {
|
|
|
+ if (mDateStrategy == dsUniformTimeInDay)
|
|
|
+ {
|
|
|
+ QDateTime uniformDateTime = keyToDateTime(mTickOrigin); // the time of this datetime will be set for all other ticks, if possible
|
|
|
+ QDateTime tickDateTime;
|
|
|
+ for (int i=0; i<result.size(); ++i)
|
|
|
+ {
|
|
|
+ tickDateTime = keyToDateTime(result.at(i));
|
|
|
+ tickDateTime.setTime(uniformDateTime.time());
|
|
|
+ result[i] = dateTimeToKey(tickDateTime);
|
|
|
+ }
|
|
|
+ } else if (mDateStrategy == dsUniformDayInMonth)
|
|
|
+ {
|
|
|
+ QDateTime uniformDateTime = keyToDateTime(mTickOrigin); // this day (in month) and time will be set for all other ticks, if possible
|
|
|
+ QDateTime tickDateTime;
|
|
|
+ for (int i=0; i<result.size(); ++i)
|
|
|
+ {
|
|
|
+ tickDateTime = keyToDateTime(result.at(i));
|
|
|
+ tickDateTime.setTime(uniformDateTime.time());
|
|
|
+ int thisUniformDay = uniformDateTime.date().day() <= tickDateTime.date().daysInMonth() ? uniformDateTime.date().day() : tickDateTime.date().daysInMonth(); // don't exceed month (e.g. try to set day 31 in February)
|
|
|
+ if (thisUniformDay-tickDateTime.date().day() < -15) // with leap years involved, date month may jump backwards or forwards, and needs to be corrected before setting day
|
|
|
+ tickDateTime = tickDateTime.addMonths(1);
|
|
|
+ else if (thisUniformDay-tickDateTime.date().day() > 15) // with leap years involved, date month may jump backwards or forwards, and needs to be corrected before setting day
|
|
|
+ tickDateTime = tickDateTime.addMonths(-1);
|
|
|
+ tickDateTime.setDate(QDate(tickDateTime.date().year(), tickDateTime.date().month(), thisUniformDay));
|
|
|
+ result[i] = dateTimeToKey(tickDateTime);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ A convenience method which turns \a key (in seconds since Epoch 1. Jan 1970, 00:00 UTC) into a
|
|
|
+ QDateTime object. This can be used to turn axis coordinates to actual QDateTimes.
|
|
|
+
|
|
|
+ The accuracy achieved by this method is one millisecond, irrespective of the used Qt version (it
|
|
|
+ works around the lack of a QDateTime::fromMSecsSinceEpoch in Qt 4.6)
|
|
|
+
|
|
|
+ \see dateTimeToKey
|
|
|
+*/
|
|
|
+QDateTime QCPAxisTickerDateTime::keyToDateTime(double key)
|
|
|
+{
|
|
|
+# if QT_VERSION < QT_VERSION_CHECK(4, 7, 0)
|
|
|
+ return QDateTime::fromTime_t(key).addMSecs((key-(qint64)key)*1000);
|
|
|
+# else
|
|
|
+ return QDateTime::fromMSecsSinceEpoch(key*1000.0);
|
|
|
+# endif
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ A convenience method which turns a QDateTime object into a double value that corresponds to
|
|
|
+ seconds since Epoch (1. Jan 1970, 00:00 UTC). This is the format used as axis coordinates by
|
|
|
+ QCPAxisTickerDateTime.
|
|
|
+
|
|
|
+ The accuracy achieved by this method is one millisecond, irrespective of the used Qt version (it
|
|
|
+ works around the lack of a QDateTime::toMSecsSinceEpoch in Qt 4.6)
|
|
|
+
|
|
|
+ \see keyToDateTime
|
|
|
+*/
|
|
|
+double QCPAxisTickerDateTime::dateTimeToKey(const QDateTime dateTime)
|
|
|
+{
|
|
|
+# if QT_VERSION < QT_VERSION_CHECK(4, 7, 0)
|
|
|
+ return dateTime.toTime_t()+dateTime.time().msec()/1000.0;
|
|
|
+# else
|
|
|
+ return dateTime.toMSecsSinceEpoch()/1000.0;
|
|
|
+# endif
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ A convenience method which turns a QDate object into a double value that corresponds to
|
|
|
+ seconds since Epoch (1. Jan 1970, 00:00 UTC). This is the format used as axis coordinates by
|
|
|
+ QCPAxisTickerDateTime.
|
|
|
+
|
|
|
+ \see keyToDateTime
|
|
|
+*/
|
|
|
+double QCPAxisTickerDateTime::dateTimeToKey(const QDate date)
|
|
|
+{
|
|
|
+# if QT_VERSION < QT_VERSION_CHECK(4, 7, 0)
|
|
|
+ return QDateTime(date).toTime_t();
|
|
|
+# else
|
|
|
+ return QDateTime(date).toMSecsSinceEpoch()/1000.0;
|
|
|
+# endif
|
|
|
+}
|
|
|
+/* end of 'src/axis/axistickerdatetime.cpp' */
|
|
|
+
|
|
|
+
|
|
|
+/* including file 'src/axis/axistickertime.cpp', size 11747 */
|
|
|
+/* commit 9868e55d3b412f2f89766bb482fcf299e93a0988 2017-09-04 01:56:22 +0200 */
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPAxisTickerTime
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+/*! \class QCPAxisTickerTime
|
|
|
+ \brief Specialized axis ticker for time spans in units of milliseconds to days
|
|
|
+
|
|
|
+ \image html axisticker-time.png
|
|
|
+
|
|
|
+ This QCPAxisTicker subclass generates ticks that corresponds to time intervals.
|
|
|
+
|
|
|
+ The format of the time display in the tick labels is controlled with \ref setTimeFormat and \ref
|
|
|
+ setFieldWidth. The time coordinate is in the unit of seconds with respect to the time coordinate
|
|
|
+ zero. Unlike with QCPAxisTickerDateTime, the ticks don't correspond to a specific calendar date
|
|
|
+ and time.
|
|
|
+
|
|
|
+ The time can be displayed in milliseconds, seconds, minutes, hours and days. Depending on the
|
|
|
+ largest available unit in the format specified with \ref setTimeFormat, any time spans above will
|
|
|
+ be carried in that largest unit. So for example if the format string is "%m:%s" and a tick at
|
|
|
+ coordinate value 7815 (being 2 hours, 10 minutes and 15 seconds) is created, the resulting tick
|
|
|
+ label will show "130:15" (130 minutes, 15 seconds). If the format string is "%h:%m:%s", the hour
|
|
|
+ unit will be used and the label will thus be "02:10:15". Negative times with respect to the axis
|
|
|
+ zero will carry a leading minus sign.
|
|
|
+
|
|
|
+ The ticker can be created and assigned to an axis like this:
|
|
|
+ \snippet documentation/doc-image-generator/mainwindow.cpp axistickertime-creation
|
|
|
+
|
|
|
+ Here is an example of a time axis providing time information in days, hours and minutes. Due to
|
|
|
+ the axis range spanning a few days and the wanted tick count (\ref setTickCount), the ticker
|
|
|
+ decided to use tick steps of 12 hours:
|
|
|
+
|
|
|
+ \image html axisticker-time2.png
|
|
|
+
|
|
|
+ The format string for this example is
|
|
|
+ \snippet documentation/doc-image-generator/mainwindow.cpp axistickertime-creation-2
|
|
|
+
|
|
|
+ \note If you rather wish to display calendar dates and times, have a look at QCPAxisTickerDateTime
|
|
|
+ instead.
|
|
|
+*/
|
|
|
+
|
|
|
+/*!
|
|
|
+ Constructs the ticker and sets reasonable default values. Axis tickers are commonly created
|
|
|
+ managed by a QSharedPointer, which then can be passed to QCPAxis::setTicker.
|
|
|
+*/
|
|
|
+QCPAxisTickerTime::QCPAxisTickerTime() :
|
|
|
+ mTimeFormat(QLatin1String("%h:%m:%s")),
|
|
|
+ mSmallestUnit(tuSeconds),
|
|
|
+ mBiggestUnit(tuHours)
|
|
|
+{
|
|
|
+ setTickCount(4);
|
|
|
+ mFieldWidth[tuMilliseconds] = 3;
|
|
|
+ mFieldWidth[tuSeconds] = 2;
|
|
|
+ mFieldWidth[tuMinutes] = 2;
|
|
|
+ mFieldWidth[tuHours] = 2;
|
|
|
+ mFieldWidth[tuDays] = 1;
|
|
|
+
|
|
|
+ mFormatPattern[tuMilliseconds] = QLatin1String("%z");
|
|
|
+ mFormatPattern[tuSeconds] = QLatin1String("%s");
|
|
|
+ mFormatPattern[tuMinutes] = QLatin1String("%m");
|
|
|
+ mFormatPattern[tuHours] = QLatin1String("%h");
|
|
|
+ mFormatPattern[tuDays] = QLatin1String("%d");
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the format that will be used to display time in the tick labels.
|
|
|
+
|
|
|
+ The available patterns are:
|
|
|
+ - %%z for milliseconds
|
|
|
+ - %%s for seconds
|
|
|
+ - %%m for minutes
|
|
|
+ - %%h for hours
|
|
|
+ - %%d for days
|
|
|
+
|
|
|
+ The field width (zero padding) can be controlled for each unit with \ref setFieldWidth.
|
|
|
+
|
|
|
+ The largest unit that appears in \a format will carry all the remaining time of a certain tick
|
|
|
+ coordinate, even if it overflows the natural limit of the unit. For example, if %%m is the
|
|
|
+ largest unit it might become larger than 59 in order to consume larger time values. If on the
|
|
|
+ other hand %%h is available, the minutes will wrap around to zero after 59 and the time will
|
|
|
+ carry to the hour digit.
|
|
|
+*/
|
|
|
+void QCPAxisTickerTime::setTimeFormat(const QString &format)
|
|
|
+{
|
|
|
+ mTimeFormat = format;
|
|
|
+
|
|
|
+ // determine smallest and biggest unit in format, to optimize unit replacement and allow biggest
|
|
|
+ // unit to consume remaining time of a tick value and grow beyond its modulo (e.g. min > 59)
|
|
|
+ mSmallestUnit = tuMilliseconds;
|
|
|
+ mBiggestUnit = tuMilliseconds;
|
|
|
+ bool hasSmallest = false;
|
|
|
+ for (int i = tuMilliseconds; i <= tuDays; ++i)
|
|
|
+ {
|
|
|
+ TimeUnit unit = static_cast<TimeUnit>(i);
|
|
|
+ if (mTimeFormat.contains(mFormatPattern.value(unit)))
|
|
|
+ {
|
|
|
+ if (!hasSmallest)
|
|
|
+ {
|
|
|
+ mSmallestUnit = unit;
|
|
|
+ hasSmallest = true;
|
|
|
+ }
|
|
|
+ mBiggestUnit = unit;
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the field widh of the specified \a unit to be \a width digits, when displayed in the tick
|
|
|
+ label. If the number for the specific unit is shorter than \a width, it will be padded with an
|
|
|
+ according number of zeros to the left in order to reach the field width.
|
|
|
+
|
|
|
+ \see setTimeFormat
|
|
|
+*/
|
|
|
+void QCPAxisTickerTime::setFieldWidth(QCPAxisTickerTime::TimeUnit unit, int width)
|
|
|
+{
|
|
|
+ mFieldWidth[unit] = qMax(width, 1);
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the tick step appropriate for time displays, depending on the provided \a range and the
|
|
|
+ smallest available time unit in the current format (\ref setTimeFormat). For example if the unit
|
|
|
+ of seconds isn't available in the format, this method will not generate steps (like 2.5 minutes)
|
|
|
+ that require sub-minute precision to be displayed correctly.
|
|
|
+
|
|
|
+ \seebaseclassmethod
|
|
|
+*/
|
|
|
+double QCPAxisTickerTime::getTickStep(const QCPRange &range)
|
|
|
+{
|
|
|
+ double result = range.size()/(double)(mTickCount+1e-10); // mTickCount ticks on average, the small addition is to prevent jitter on exact integers
|
|
|
+
|
|
|
+ if (result < 1) // ideal tick step is below 1 second -> use normal clean mantissa algorithm in units of seconds
|
|
|
+ {
|
|
|
+ if (mSmallestUnit == tuMilliseconds)
|
|
|
+ result = qMax(cleanMantissa(result), 0.001); // smallest tick step is 1 millisecond
|
|
|
+ else // have no milliseconds available in format, so stick with 1 second tickstep
|
|
|
+ result = 1.0;
|
|
|
+ } else if (result < 3600*24) // below a day
|
|
|
+ {
|
|
|
+ // the filling of availableSteps seems a bit contorted but it fills in a sorted fashion and thus saves a post-fill sorting run
|
|
|
+ QVector<double> availableSteps;
|
|
|
+ // seconds range:
|
|
|
+ if (mSmallestUnit <= tuSeconds)
|
|
|
+ availableSteps << 1;
|
|
|
+ if (mSmallestUnit == tuMilliseconds)
|
|
|
+ availableSteps << 2.5; // only allow half second steps if milliseconds are there to display it
|
|
|
+ else if (mSmallestUnit == tuSeconds)
|
|
|
+ availableSteps << 2;
|
|
|
+ if (mSmallestUnit <= tuSeconds)
|
|
|
+ availableSteps << 5 << 10 << 15 << 30;
|
|
|
+ // minutes range:
|
|
|
+ if (mSmallestUnit <= tuMinutes)
|
|
|
+ availableSteps << 1*60;
|
|
|
+ if (mSmallestUnit <= tuSeconds)
|
|
|
+ availableSteps << 2.5*60; // only allow half minute steps if seconds are there to display it
|
|
|
+ else if (mSmallestUnit == tuMinutes)
|
|
|
+ availableSteps << 2*60;
|
|
|
+ if (mSmallestUnit <= tuMinutes)
|
|
|
+ availableSteps << 5*60 << 10*60 << 15*60 << 30*60;
|
|
|
+ // hours range:
|
|
|
+ if (mSmallestUnit <= tuHours)
|
|
|
+ availableSteps << 1*3600 << 2*3600 << 3*3600 << 6*3600 << 12*3600 << 24*3600;
|
|
|
+ // pick available step that is most appropriate to approximate ideal step:
|
|
|
+ result = pickClosest(result, availableSteps);
|
|
|
+ } else // more than a day, go back to normal clean mantissa algorithm but in units of days
|
|
|
+ {
|
|
|
+ const double secondsPerDay = 3600*24;
|
|
|
+ result = cleanMantissa(result/secondsPerDay)*secondsPerDay;
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the sub tick count appropriate for the provided \a tickStep and time displays.
|
|
|
+
|
|
|
+ \seebaseclassmethod
|
|
|
+*/
|
|
|
+int QCPAxisTickerTime::getSubTickCount(double tickStep)
|
|
|
+{
|
|
|
+ int result = QCPAxisTicker::getSubTickCount(tickStep);
|
|
|
+ switch (qRound(tickStep)) // hand chosen subticks for specific minute/hour/day range (as specified in getTickStep)
|
|
|
+ {
|
|
|
+ case 5*60: result = 4; break;
|
|
|
+ case 10*60: result = 1; break;
|
|
|
+ case 15*60: result = 2; break;
|
|
|
+ case 30*60: result = 1; break;
|
|
|
+ case 60*60: result = 3; break;
|
|
|
+ case 3600*2: result = 3; break;
|
|
|
+ case 3600*3: result = 2; break;
|
|
|
+ case 3600*6: result = 1; break;
|
|
|
+ case 3600*12: result = 3; break;
|
|
|
+ case 3600*24: result = 3; break;
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the tick label corresponding to the provided \a tick and the configured format and field
|
|
|
+ widths (\ref setTimeFormat, \ref setFieldWidth).
|
|
|
+
|
|
|
+ \seebaseclassmethod
|
|
|
+*/
|
|
|
+QString QCPAxisTickerTime::getTickLabel(double tick, const QLocale &locale, QChar formatChar, int precision)
|
|
|
+{
|
|
|
+ Q_UNUSED(precision)
|
|
|
+ Q_UNUSED(formatChar)
|
|
|
+ Q_UNUSED(locale)
|
|
|
+ bool negative = tick < 0;
|
|
|
+ if (negative) tick *= -1;
|
|
|
+ double values[tuDays+1]; // contains the msec/sec/min/... value with its respective modulo (e.g. minute 0..59)
|
|
|
+ double restValues[tuDays+1]; // contains the msec/sec/min/... value as if it's the largest available unit and thus consumes the remaining time
|
|
|
+
|
|
|
+ restValues[tuMilliseconds] = tick*1000;
|
|
|
+ values[tuMilliseconds] = modf(restValues[tuMilliseconds]/1000, &restValues[tuSeconds])*1000;
|
|
|
+ values[tuSeconds] = modf(restValues[tuSeconds]/60, &restValues[tuMinutes])*60;
|
|
|
+ values[tuMinutes] = modf(restValues[tuMinutes]/60, &restValues[tuHours])*60;
|
|
|
+ values[tuHours] = modf(restValues[tuHours]/24, &restValues[tuDays])*24;
|
|
|
+ // no need to set values[tuDays] because days are always a rest value (there is no higher unit so it consumes all remaining time)
|
|
|
+
|
|
|
+ QString result = mTimeFormat;
|
|
|
+ for (int i = mSmallestUnit; i <= mBiggestUnit; ++i)
|
|
|
+ {
|
|
|
+ TimeUnit iUnit = static_cast<TimeUnit>(i);
|
|
|
+ replaceUnit(result, iUnit, qRound(iUnit == mBiggestUnit ? restValues[iUnit] : values[iUnit]));
|
|
|
+ }
|
|
|
+ if (negative)
|
|
|
+ result.prepend(QLatin1Char('-'));
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Replaces all occurrences of the format pattern belonging to \a unit in \a text with the specified
|
|
|
+ \a value, using the field width as specified with \ref setFieldWidth for the \a unit.
|
|
|
+*/
|
|
|
+void QCPAxisTickerTime::replaceUnit(QString &text, QCPAxisTickerTime::TimeUnit unit, int value) const
|
|
|
+{
|
|
|
+ QString valueStr = QString::number(value);
|
|
|
+ while (valueStr.size() < mFieldWidth.value(unit))
|
|
|
+ valueStr.prepend(QLatin1Char('0'));
|
|
|
+
|
|
|
+ text.replace(mFormatPattern.value(unit), valueStr);
|
|
|
+}
|
|
|
+/* end of 'src/axis/axistickertime.cpp' */
|
|
|
+
|
|
|
+
|
|
|
+/* including file 'src/axis/axistickerfixed.cpp', size 5583 */
|
|
|
+/* commit 9868e55d3b412f2f89766bb482fcf299e93a0988 2017-09-04 01:56:22 +0200 */
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPAxisTickerFixed
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+/*! \class QCPAxisTickerFixed
|
|
|
+ \brief Specialized axis ticker with a fixed tick step
|
|
|
+
|
|
|
+ \image html axisticker-fixed.png
|
|
|
+
|
|
|
+ This QCPAxisTicker subclass generates ticks with a fixed tick step set with \ref setTickStep. It
|
|
|
+ is also possible to allow integer multiples and integer powers of the specified tick step with
|
|
|
+ \ref setScaleStrategy.
|
|
|
+
|
|
|
+ A typical application of this ticker is to make an axis only display integers, by setting the
|
|
|
+ tick step of the ticker to 1.0 and the scale strategy to \ref ssMultiples.
|
|
|
+
|
|
|
+ Another case is when a certain number has a special meaning and axis ticks should only appear at
|
|
|
+ multiples of that value. In this case you might also want to consider \ref QCPAxisTickerPi
|
|
|
+ because despite the name it is not limited to only pi symbols/values.
|
|
|
+
|
|
|
+ The ticker can be created and assigned to an axis like this:
|
|
|
+ \snippet documentation/doc-image-generator/mainwindow.cpp axistickerfixed-creation
|
|
|
+*/
|
|
|
+
|
|
|
+/*!
|
|
|
+ Constructs the ticker and sets reasonable default values. Axis tickers are commonly created
|
|
|
+ managed by a QSharedPointer, which then can be passed to QCPAxis::setTicker.
|
|
|
+*/
|
|
|
+QCPAxisTickerFixed::QCPAxisTickerFixed() :
|
|
|
+ mTickStep(1.0),
|
|
|
+ mScaleStrategy(ssNone)
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the fixed tick interval to \a step.
|
|
|
+
|
|
|
+ The axis ticker will only use this tick step when generating axis ticks. This might cause a very
|
|
|
+ high tick density and overlapping labels if the axis range is zoomed out. Using \ref
|
|
|
+ setScaleStrategy it is possible to relax the fixed step and also allow multiples or powers of \a
|
|
|
+ step. This will enable the ticker to reduce the number of ticks to a reasonable amount (see \ref
|
|
|
+ setTickCount).
|
|
|
+*/
|
|
|
+void QCPAxisTickerFixed::setTickStep(double step)
|
|
|
+{
|
|
|
+ if (step > 0)
|
|
|
+ mTickStep = step;
|
|
|
+ else
|
|
|
+ qDebug() << Q_FUNC_INFO << "tick step must be greater than zero:" << step;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets whether the specified tick step (\ref setTickStep) is absolutely fixed or whether
|
|
|
+ modifications may be applied to it before calculating the finally used tick step, such as
|
|
|
+ permitting multiples or powers. See \ref ScaleStrategy for details.
|
|
|
+
|
|
|
+ The default strategy is \ref ssNone, which means the tick step is absolutely fixed.
|
|
|
+*/
|
|
|
+void QCPAxisTickerFixed::setScaleStrategy(QCPAxisTickerFixed::ScaleStrategy strategy)
|
|
|
+{
|
|
|
+ mScaleStrategy = strategy;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Determines the actually used tick step from the specified tick step and scale strategy (\ref
|
|
|
+ setTickStep, \ref setScaleStrategy).
|
|
|
+
|
|
|
+ This method either returns the specified tick step exactly, or, if the scale strategy is not \ref
|
|
|
+ ssNone, a modification of it to allow varying the number of ticks in the current axis range.
|
|
|
+
|
|
|
+ \seebaseclassmethod
|
|
|
+*/
|
|
|
+double QCPAxisTickerFixed::getTickStep(const QCPRange &range)
|
|
|
+{
|
|
|
+ switch (mScaleStrategy)
|
|
|
+ {
|
|
|
+ case ssNone:
|
|
|
+ {
|
|
|
+ return mTickStep;
|
|
|
+ }
|
|
|
+ case ssMultiples:
|
|
|
+ {
|
|
|
+ double exactStep = range.size()/(double)(mTickCount+1e-10); // mTickCount ticks on average, the small addition is to prevent jitter on exact integers
|
|
|
+ if (exactStep < mTickStep)
|
|
|
+ return mTickStep;
|
|
|
+ else
|
|
|
+ return (qint64)(cleanMantissa(exactStep/mTickStep)+0.5)*mTickStep;
|
|
|
+ }
|
|
|
+ case ssPowers:
|
|
|
+ {
|
|
|
+ double exactStep = range.size()/(double)(mTickCount+1e-10); // mTickCount ticks on average, the small addition is to prevent jitter on exact integers
|
|
|
+ return qPow(mTickStep, (int)(qLn(exactStep)/qLn(mTickStep)+0.5));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return mTickStep;
|
|
|
+}
|
|
|
+/* end of 'src/axis/axistickerfixed.cpp' */
|
|
|
+
|
|
|
+
|
|
|
+/* including file 'src/axis/axistickertext.cpp', size 8653 */
|
|
|
+/* commit 9868e55d3b412f2f89766bb482fcf299e93a0988 2017-09-04 01:56:22 +0200 */
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPAxisTickerText
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+/*! \class QCPAxisTickerText
|
|
|
+ \brief Specialized axis ticker which allows arbitrary labels at specified coordinates
|
|
|
+
|
|
|
+ \image html axisticker-text.png
|
|
|
+
|
|
|
+ This QCPAxisTicker subclass generates ticks which can be directly specified by the user as
|
|
|
+ coordinates and associated strings. They can be passed as a whole with \ref setTicks or one at a
|
|
|
+ time with \ref addTick. Alternatively you can directly access the internal storage via \ref ticks
|
|
|
+ and modify the tick/label data there.
|
|
|
+
|
|
|
+ This is useful for cases where the axis represents categories rather than numerical values.
|
|
|
+
|
|
|
+ If you are updating the ticks of this ticker regularly and in a dynamic fasion (e.g. dependent on
|
|
|
+ the axis range), it is a sign that you should probably create an own ticker by subclassing
|
|
|
+ QCPAxisTicker, instead of using this one.
|
|
|
+
|
|
|
+ The ticker can be created and assigned to an axis like this:
|
|
|
+ \snippet documentation/doc-image-generator/mainwindow.cpp axistickertext-creation
|
|
|
+*/
|
|
|
+
|
|
|
+/* start of documentation of inline functions */
|
|
|
+
|
|
|
+/*! \fn QMap<double, QString> &QCPAxisTickerText::ticks()
|
|
|
+
|
|
|
+ Returns a non-const reference to the internal map which stores the tick coordinates and their
|
|
|
+ labels.
|
|
|
+
|
|
|
+ You can access the map directly in order to add, remove or manipulate ticks, as an alternative to
|
|
|
+ using the methods provided by QCPAxisTickerText, such as \ref setTicks and \ref addTick.
|
|
|
+*/
|
|
|
+
|
|
|
+/* end of documentation of inline functions */
|
|
|
+
|
|
|
+/*!
|
|
|
+ Constructs the ticker and sets reasonable default values. Axis tickers are commonly created
|
|
|
+ managed by a QSharedPointer, which then can be passed to QCPAxis::setTicker.
|
|
|
+*/
|
|
|
+QCPAxisTickerText::QCPAxisTickerText() :
|
|
|
+ mSubTickCount(0)
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Sets the ticks that shall appear on the axis. The map key of \a ticks corresponds to the axis
|
|
|
+ coordinate, and the map value is the string that will appear as tick label.
|
|
|
+
|
|
|
+ An alternative to manipulate ticks is to directly access the internal storage with the \ref ticks
|
|
|
+ getter.
|
|
|
+
|
|
|
+ \see addTicks, addTick, clear
|
|
|
+*/
|
|
|
+void QCPAxisTickerText::setTicks(const QMap<double, QString> &ticks)
|
|
|
+{
|
|
|
+ mTicks = ticks;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Sets the ticks that shall appear on the axis. The entries of \a positions correspond to the axis
|
|
|
+ coordinates, and the entries of \a labels are the respective strings that will appear as tick
|
|
|
+ labels.
|
|
|
+
|
|
|
+ \see addTicks, addTick, clear
|
|
|
+*/
|
|
|
+void QCPAxisTickerText::setTicks(const QVector<double> &positions, const QVector<QString> labels)
|
|
|
+{
|
|
|
+ clear();
|
|
|
+ addTicks(positions, labels);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the number of sub ticks that shall appear between ticks. For QCPAxisTickerText, there is no
|
|
|
+ automatic sub tick count calculation. So if sub ticks are needed, they must be configured with this
|
|
|
+ method.
|
|
|
+*/
|
|
|
+void QCPAxisTickerText::setSubTickCount(int subTicks)
|
|
|
+{
|
|
|
+ if (subTicks >= 0)
|
|
|
+ mSubTickCount = subTicks;
|
|
|
+ else
|
|
|
+ qDebug() << Q_FUNC_INFO << "sub tick count can't be negative:" << subTicks;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Clears all ticks.
|
|
|
+
|
|
|
+ An alternative to manipulate ticks is to directly access the internal storage with the \ref ticks
|
|
|
+ getter.
|
|
|
+
|
|
|
+ \see setTicks, addTicks, addTick
|
|
|
+*/
|
|
|
+void QCPAxisTickerText::clear()
|
|
|
+{
|
|
|
+ mTicks.clear();
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Adds a single tick to the axis at the given axis coordinate \a position, with the provided tick \a
|
|
|
+ label.
|
|
|
+
|
|
|
+ \see addTicks, setTicks, clear
|
|
|
+*/
|
|
|
+void QCPAxisTickerText::addTick(double position, QString label)
|
|
|
+{
|
|
|
+ mTicks.insert(position, label);
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Adds the provided \a ticks to the ones already existing. The map key of \a ticks corresponds to
|
|
|
+ the axis coordinate, and the map value is the string that will appear as tick label.
|
|
|
+
|
|
|
+ An alternative to manipulate ticks is to directly access the internal storage with the \ref ticks
|
|
|
+ getter.
|
|
|
+
|
|
|
+ \see addTick, setTicks, clear
|
|
|
+*/
|
|
|
+void QCPAxisTickerText::addTicks(const QMap<double, QString> &ticks)
|
|
|
+{
|
|
|
+ mTicks.unite(ticks);
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Adds the provided ticks to the ones already existing. The entries of \a positions correspond to
|
|
|
+ the axis coordinates, and the entries of \a labels are the respective strings that will appear as
|
|
|
+ tick labels.
|
|
|
+
|
|
|
+ An alternative to manipulate ticks is to directly access the internal storage with the \ref ticks
|
|
|
+ getter.
|
|
|
+
|
|
|
+ \see addTick, setTicks, clear
|
|
|
+*/
|
|
|
+void QCPAxisTickerText::addTicks(const QVector<double> &positions, const QVector<QString> &labels)
|
|
|
+{
|
|
|
+ if (positions.size() != labels.size())
|
|
|
+ qDebug() << Q_FUNC_INFO << "passed unequal length vectors for positions and labels:" << positions.size() << labels.size();
|
|
|
+ int n = qMin(positions.size(), labels.size());
|
|
|
+ for (int i=0; i<n; ++i)
|
|
|
+ mTicks.insert(positions.at(i), labels.at(i));
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Since the tick coordinates are provided externally, this method implementation does nothing.
|
|
|
+
|
|
|
+ \seebaseclassmethod
|
|
|
+*/
|
|
|
+double QCPAxisTickerText::getTickStep(const QCPRange &range)
|
|
|
+{
|
|
|
+ // text axis ticker has manual tick positions, so doesn't need this method
|
|
|
+ Q_UNUSED(range)
|
|
|
+ return 1.0;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns the sub tick count that was configured with \ref setSubTickCount.
|
|
|
+
|
|
|
+ \seebaseclassmethod
|
|
|
+*/
|
|
|
+int QCPAxisTickerText::getSubTickCount(double tickStep)
|
|
|
+{
|
|
|
+ Q_UNUSED(tickStep)
|
|
|
+ return mSubTickCount;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns the tick label which corresponds to the key \a tick in the internal tick storage. Since
|
|
|
+ the labels are provided externally, \a locale, \a formatChar, and \a precision are ignored.
|
|
|
+
|
|
|
+ \seebaseclassmethod
|
|
|
+*/
|
|
|
+QString QCPAxisTickerText::getTickLabel(double tick, const QLocale &locale, QChar formatChar, int precision)
|
|
|
+{
|
|
|
+ Q_UNUSED(locale)
|
|
|
+ Q_UNUSED(formatChar)
|
|
|
+ Q_UNUSED(precision)
|
|
|
+ return mTicks.value(tick);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns the externally provided tick coordinates which are in the specified \a range. If
|
|
|
+ available, one tick above and below the range is provided in addition, to allow possible sub tick
|
|
|
+ calculation. The parameter \a tickStep is ignored.
|
|
|
+
|
|
|
+ \seebaseclassmethod
|
|
|
+*/
|
|
|
+QVector<double> QCPAxisTickerText::createTickVector(double tickStep, const QCPRange &range)
|
|
|
+{
|
|
|
+ Q_UNUSED(tickStep)
|
|
|
+ QVector<double> result;
|
|
|
+ if (mTicks.isEmpty())
|
|
|
+ return result;
|
|
|
+
|
|
|
+ QMap<double, QString>::const_iterator start = mTicks.lowerBound(range.lower);
|
|
|
+ QMap<double, QString>::const_iterator end = mTicks.upperBound(range.upper);
|
|
|
+ // this method should try to give one tick outside of range so proper subticks can be generated:
|
|
|
+ if (start != mTicks.constBegin()) --start;
|
|
|
+ if (end != mTicks.constEnd()) ++end;
|
|
|
+ for (QMap<double, QString>::const_iterator it = start; it != end; ++it)
|
|
|
+ result.append(it.key());
|
|
|
+
|
|
|
+ return result;
|
|
|
+}
|
|
|
+/* end of 'src/axis/axistickertext.cpp' */
|
|
|
+
|
|
|
+
|
|
|
+/* including file 'src/axis/axistickerpi.cpp', size 11170 */
|
|
|
+/* commit 9868e55d3b412f2f89766bb482fcf299e93a0988 2017-09-04 01:56:22 +0200 */
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPAxisTickerPi
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+/*! \class QCPAxisTickerPi
|
|
|
+ \brief Specialized axis ticker to display ticks in units of an arbitrary constant, for example pi
|
|
|
+
|
|
|
+ \image html axisticker-pi.png
|
|
|
+
|
|
|
+ This QCPAxisTicker subclass generates ticks that are expressed with respect to a given symbolic
|
|
|
+ constant with a numerical value specified with \ref setPiValue and an appearance in the tick
|
|
|
+ labels specified with \ref setPiSymbol.
|
|
|
+
|
|
|
+ Ticks may be generated at fractions of the symbolic constant. How these fractions appear in the
|
|
|
+ tick label can be configured with \ref setFractionStyle.
|
|
|
+
|
|
|
+ The ticker can be created and assigned to an axis like this:
|
|
|
+ \snippet documentation/doc-image-generator/mainwindow.cpp axistickerpi-creation
|
|
|
+*/
|
|
|
+
|
|
|
+/*!
|
|
|
+ Constructs the ticker and sets reasonable default values. Axis tickers are commonly created
|
|
|
+ managed by a QSharedPointer, which then can be passed to QCPAxis::setTicker.
|
|
|
+*/
|
|
|
+QCPAxisTickerPi::QCPAxisTickerPi() :
|
|
|
+ mPiSymbol(QLatin1String(" ")+QChar(0x03C0)),
|
|
|
+ mPiValue(M_PI),
|
|
|
+ mPeriodicity(0),
|
|
|
+ mFractionStyle(fsUnicodeFractions),
|
|
|
+ mPiTickStep(0)
|
|
|
+{
|
|
|
+ setTickCount(4);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets how the symbol part (which is always a suffix to the number) shall appear in the axis tick
|
|
|
+ label.
|
|
|
+
|
|
|
+ If a space shall appear between the number and the symbol, make sure the space is contained in \a
|
|
|
+ symbol.
|
|
|
+*/
|
|
|
+void QCPAxisTickerPi::setPiSymbol(QString symbol)
|
|
|
+{
|
|
|
+ mPiSymbol = symbol;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the numerical value that the symbolic constant has.
|
|
|
+
|
|
|
+ This will be used to place the appropriate fractions of the symbol at the respective axis
|
|
|
+ coordinates.
|
|
|
+*/
|
|
|
+void QCPAxisTickerPi::setPiValue(double pi)
|
|
|
+{
|
|
|
+ mPiValue = pi;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets whether the axis labels shall appear periodicly and if so, at which multiplicity of the
|
|
|
+ symbolic constant.
|
|
|
+
|
|
|
+ To disable periodicity, set \a multiplesOfPi to zero.
|
|
|
+
|
|
|
+ For example, an axis that identifies 0 with 2pi would set \a multiplesOfPi to two.
|
|
|
+*/
|
|
|
+void QCPAxisTickerPi::setPeriodicity(int multiplesOfPi)
|
|
|
+{
|
|
|
+ mPeriodicity = qAbs(multiplesOfPi);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets how the numerical/fractional part preceding the symbolic constant is displayed in tick
|
|
|
+ labels. See \ref FractionStyle for the various options.
|
|
|
+*/
|
|
|
+void QCPAxisTickerPi::setFractionStyle(QCPAxisTickerPi::FractionStyle style)
|
|
|
+{
|
|
|
+ mFractionStyle = style;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the tick step, using the constant's value (\ref setPiValue) as base unit. In consequence
|
|
|
+ the numerical/fractional part preceding the symbolic constant is made to have a readable
|
|
|
+ mantissa.
|
|
|
+
|
|
|
+ \seebaseclassmethod
|
|
|
+*/
|
|
|
+double QCPAxisTickerPi::getTickStep(const QCPRange &range)
|
|
|
+{
|
|
|
+ mPiTickStep = range.size()/mPiValue/(double)(mTickCount+1e-10); // mTickCount ticks on average, the small addition is to prevent jitter on exact integers
|
|
|
+ mPiTickStep = cleanMantissa(mPiTickStep);
|
|
|
+ return mPiTickStep*mPiValue;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the sub tick count, using the constant's value (\ref setPiValue) as base unit. In
|
|
|
+ consequence the sub ticks divide the numerical/fractional part preceding the symbolic constant
|
|
|
+ reasonably, and not the total tick coordinate.
|
|
|
+
|
|
|
+ \seebaseclassmethod
|
|
|
+*/
|
|
|
+int QCPAxisTickerPi::getSubTickCount(double tickStep)
|
|
|
+{
|
|
|
+ return QCPAxisTicker::getSubTickCount(tickStep/mPiValue);
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the tick label as a fractional/numerical part and a symbolic string as suffix. The
|
|
|
+ formatting of the fraction is done according to the specified \ref setFractionStyle. The appended
|
|
|
+ symbol is specified with \ref setPiSymbol.
|
|
|
+
|
|
|
+ \seebaseclassmethod
|
|
|
+*/
|
|
|
+QString QCPAxisTickerPi::getTickLabel(double tick, const QLocale &locale, QChar formatChar, int precision)
|
|
|
+{
|
|
|
+ double tickInPis = tick/mPiValue;
|
|
|
+ if (mPeriodicity > 0)
|
|
|
+ tickInPis = fmod(tickInPis, mPeriodicity);
|
|
|
+
|
|
|
+ if (mFractionStyle != fsFloatingPoint && mPiTickStep > 0.09 && mPiTickStep < 50)
|
|
|
+ {
|
|
|
+ // simply construct fraction from decimal like 1.234 -> 1234/1000 and then simplify fraction, smaller digits are irrelevant due to mPiTickStep conditional above
|
|
|
+ int denominator = 1000;
|
|
|
+ int numerator = qRound(tickInPis*denominator);
|
|
|
+ simplifyFraction(numerator, denominator);
|
|
|
+ if (qAbs(numerator) == 1 && denominator == 1)
|
|
|
+ return (numerator < 0 ? QLatin1String("-") : QLatin1String("")) + mPiSymbol.trimmed();
|
|
|
+ else if (numerator == 0)
|
|
|
+ return QLatin1String("0");
|
|
|
+ else
|
|
|
+ return fractionToString(numerator, denominator) + mPiSymbol;
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ if (qFuzzyIsNull(tickInPis))
|
|
|
+ return QLatin1String("0");
|
|
|
+ else if (qFuzzyCompare(qAbs(tickInPis), 1.0))
|
|
|
+ return (tickInPis < 0 ? QLatin1String("-") : QLatin1String("")) + mPiSymbol.trimmed();
|
|
|
+ else
|
|
|
+ return QCPAxisTicker::getTickLabel(tickInPis, locale, formatChar, precision) + mPiSymbol;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Takes the fraction given by \a numerator and \a denominator and modifies the values to make sure
|
|
|
+ the fraction is in irreducible form, i.e. numerator and denominator don't share any common
|
|
|
+ factors which could be cancelled.
|
|
|
+*/
|
|
|
+void QCPAxisTickerPi::simplifyFraction(int &numerator, int &denominator) const
|
|
|
+{
|
|
|
+ if (numerator == 0 || denominator == 0)
|
|
|
+ return;
|
|
|
+
|
|
|
+ int num = numerator;
|
|
|
+ int denom = denominator;
|
|
|
+ while (denom != 0) // euclidean gcd algorithm
|
|
|
+ {
|
|
|
+ int oldDenom = denom;
|
|
|
+ denom = num % denom;
|
|
|
+ num = oldDenom;
|
|
|
+ }
|
|
|
+ // num is now gcd of numerator and denominator
|
|
|
+ numerator /= num;
|
|
|
+ denominator /= num;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Takes the fraction given by \a numerator and \a denominator and returns a string representation.
|
|
|
+ The result depends on the configured fraction style (\ref setFractionStyle).
|
|
|
+
|
|
|
+ This method is used to format the numerical/fractional part when generating tick labels. It
|
|
|
+ simplifies the passed fraction to an irreducible form using \ref simplifyFraction and factors out
|
|
|
+ any integer parts of the fraction (e.g. "10/4" becomes "2 1/2").
|
|
|
+*/
|
|
|
+QString QCPAxisTickerPi::fractionToString(int numerator, int denominator) const
|
|
|
+{
|
|
|
+ if (denominator == 0)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "called with zero denominator";
|
|
|
+ return QString();
|
|
|
+ }
|
|
|
+ if (mFractionStyle == fsFloatingPoint) // should never be the case when calling this function
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "shouldn't be called with fraction style fsDecimal";
|
|
|
+ return QString::number(numerator/(double)denominator); // failsafe
|
|
|
+ }
|
|
|
+ int sign = numerator*denominator < 0 ? -1 : 1;
|
|
|
+ numerator = qAbs(numerator);
|
|
|
+ denominator = qAbs(denominator);
|
|
|
+
|
|
|
+ if (denominator == 1)
|
|
|
+ {
|
|
|
+ return QString::number(sign*numerator);
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ int integerPart = numerator/denominator;
|
|
|
+ int remainder = numerator%denominator;
|
|
|
+ if (remainder == 0)
|
|
|
+ {
|
|
|
+ return QString::number(sign*integerPart);
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ if (mFractionStyle == fsAsciiFractions)
|
|
|
+ {
|
|
|
+ return QString(QLatin1String("%1%2%3/%4"))
|
|
|
+ .arg(sign == -1 ? QLatin1String("-") : QLatin1String(""))
|
|
|
+ .arg(integerPart > 0 ? QString::number(integerPart)+QLatin1String(" ") : QLatin1String(""))
|
|
|
+ .arg(remainder)
|
|
|
+ .arg(denominator);
|
|
|
+ } else if (mFractionStyle == fsUnicodeFractions)
|
|
|
+ {
|
|
|
+ return QString(QLatin1String("%1%2%3"))
|
|
|
+ .arg(sign == -1 ? QLatin1String("-") : QLatin1String(""))
|
|
|
+ .arg(integerPart > 0 ? QString::number(integerPart) : QLatin1String(""))
|
|
|
+ .arg(unicodeFraction(remainder, denominator));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return QString();
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the unicode string representation of the fraction given by \a numerator and \a
|
|
|
+ denominator. This is the representation used in \ref fractionToString when the fraction style
|
|
|
+ (\ref setFractionStyle) is \ref fsUnicodeFractions.
|
|
|
+
|
|
|
+ This method doesn't use the single-character common fractions but builds each fraction from a
|
|
|
+ superscript unicode number, the unicode fraction character, and a subscript unicode number.
|
|
|
+*/
|
|
|
+QString QCPAxisTickerPi::unicodeFraction(int numerator, int denominator) const
|
|
|
+{
|
|
|
+ return unicodeSuperscript(numerator)+QChar(0x2044)+unicodeSubscript(denominator);
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the unicode string representing \a number as superscript. This is used to build
|
|
|
+ unicode fractions in \ref unicodeFraction.
|
|
|
+*/
|
|
|
+QString QCPAxisTickerPi::unicodeSuperscript(int number) const
|
|
|
+{
|
|
|
+ if (number == 0)
|
|
|
+ return QString(QChar(0x2070));
|
|
|
+
|
|
|
+ QString result;
|
|
|
+ while (number > 0)
|
|
|
+ {
|
|
|
+ const int digit = number%10;
|
|
|
+ switch (digit)
|
|
|
+ {
|
|
|
+ case 1: { result.prepend(QChar(0x00B9)); break; }
|
|
|
+ case 2: { result.prepend(QChar(0x00B2)); break; }
|
|
|
+ case 3: { result.prepend(QChar(0x00B3)); break; }
|
|
|
+ default: { result.prepend(QChar(0x2070+digit)); break; }
|
|
|
+ }
|
|
|
+ number /= 10;
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the unicode string representing \a number as subscript. This is used to build unicode
|
|
|
+ fractions in \ref unicodeFraction.
|
|
|
+*/
|
|
|
+QString QCPAxisTickerPi::unicodeSubscript(int number) const
|
|
|
+{
|
|
|
+ if (number == 0)
|
|
|
+ return QString(QChar(0x2080));
|
|
|
+
|
|
|
+ QString result;
|
|
|
+ while (number > 0)
|
|
|
+ {
|
|
|
+ result.prepend(QChar(0x2080+number%10));
|
|
|
+ number /= 10;
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+/* end of 'src/axis/axistickerpi.cpp' */
|
|
|
+
|
|
|
+
|
|
|
+/* including file 'src/axis/axistickerlog.cpp', size 7106 */
|
|
|
+/* commit 9868e55d3b412f2f89766bb482fcf299e93a0988 2017-09-04 01:56:22 +0200 */
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPAxisTickerLog
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+/*! \class QCPAxisTickerLog
|
|
|
+ \brief Specialized axis ticker suited for logarithmic axes
|
|
|
+
|
|
|
+ \image html axisticker-log.png
|
|
|
+
|
|
|
+ This QCPAxisTicker subclass generates ticks with unequal tick intervals suited for logarithmic
|
|
|
+ axis scales. The ticks are placed at powers of the specified log base (\ref setLogBase).
|
|
|
+
|
|
|
+ Especially in the case of a log base equal to 10 (the default), it might be desirable to have
|
|
|
+ tick labels in the form of powers of ten without mantissa display. To achieve this, set the
|
|
|
+ number precision (\ref QCPAxis::setNumberPrecision) to zero and the number format (\ref
|
|
|
+ QCPAxis::setNumberFormat) to scientific (exponential) display with beautifully typeset decimal
|
|
|
+ powers, so a format string of <tt>"eb"</tt>. This will result in the following axis tick labels:
|
|
|
+
|
|
|
+ \image html axisticker-log-powers.png
|
|
|
+
|
|
|
+ The ticker can be created and assigned to an axis like this:
|
|
|
+ \snippet documentation/doc-image-generator/mainwindow.cpp axistickerlog-creation
|
|
|
+*/
|
|
|
+
|
|
|
+/*!
|
|
|
+ Constructs the ticker and sets reasonable default values. Axis tickers are commonly created
|
|
|
+ managed by a QSharedPointer, which then can be passed to QCPAxis::setTicker.
|
|
|
+*/
|
|
|
+QCPAxisTickerLog::QCPAxisTickerLog() :
|
|
|
+ mLogBase(10.0),
|
|
|
+ mSubTickCount(8), // generates 10 intervals
|
|
|
+ mLogBaseLnInv(1.0/qLn(mLogBase))
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the logarithm base used for tick coordinate generation. The ticks will be placed at integer
|
|
|
+ powers of \a base.
|
|
|
+*/
|
|
|
+void QCPAxisTickerLog::setLogBase(double base)
|
|
|
+{
|
|
|
+ if (base > 0)
|
|
|
+ {
|
|
|
+ mLogBase = base;
|
|
|
+ mLogBaseLnInv = 1.0/qLn(mLogBase);
|
|
|
+ } else
|
|
|
+ qDebug() << Q_FUNC_INFO << "log base has to be greater than zero:" << base;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the number of sub ticks in a tick interval. Within each interval, the sub ticks are spaced
|
|
|
+ linearly to provide a better visual guide, so the sub tick density increases toward the higher
|
|
|
+ tick.
|
|
|
+
|
|
|
+ Note that \a subTicks is the number of sub ticks (not sub intervals) in one tick interval. So in
|
|
|
+ the case of logarithm base 10 an intuitive sub tick spacing would be achieved with eight sub
|
|
|
+ ticks (the default). This means e.g. between the ticks 10 and 100 there will be eight ticks,
|
|
|
+ namely at 20, 30, 40, 50, 60, 70, 80 and 90.
|
|
|
+*/
|
|
|
+void QCPAxisTickerLog::setSubTickCount(int subTicks)
|
|
|
+{
|
|
|
+ if (subTicks >= 0)
|
|
|
+ mSubTickCount = subTicks;
|
|
|
+ else
|
|
|
+ qDebug() << Q_FUNC_INFO << "sub tick count can't be negative:" << subTicks;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Since logarithmic tick steps are necessarily different for each tick interval, this method does
|
|
|
+ nothing in the case of QCPAxisTickerLog
|
|
|
+
|
|
|
+ \seebaseclassmethod
|
|
|
+*/
|
|
|
+double QCPAxisTickerLog::getTickStep(const QCPRange &range)
|
|
|
+{
|
|
|
+ // Logarithmic axis ticker has unequal tick spacing, so doesn't need this method
|
|
|
+ Q_UNUSED(range)
|
|
|
+ return 1.0;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the sub tick count specified in \ref setSubTickCount. For QCPAxisTickerLog, there is no
|
|
|
+ automatic sub tick count calculation necessary.
|
|
|
+
|
|
|
+ \seebaseclassmethod
|
|
|
+*/
|
|
|
+int QCPAxisTickerLog::getSubTickCount(double tickStep)
|
|
|
+{
|
|
|
+ Q_UNUSED(tickStep)
|
|
|
+ return mSubTickCount;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Creates ticks with a spacing given by the logarithm base and an increasing integer power in the
|
|
|
+ provided \a range. The step in which the power increases tick by tick is chosen in order to keep
|
|
|
+ the total number of ticks as close as possible to the tick count (\ref setTickCount). The
|
|
|
+ parameter \a tickStep is ignored for QCPAxisTickerLog
|
|
|
+
|
|
|
+ \seebaseclassmethod
|
|
|
+*/
|
|
|
+QVector<double> QCPAxisTickerLog::createTickVector(double tickStep, const QCPRange &range)
|
|
|
+{
|
|
|
+ Q_UNUSED(tickStep)
|
|
|
+ QVector<double> result;
|
|
|
+ if (range.lower > 0 && range.upper > 0) // positive range
|
|
|
+ {
|
|
|
+ double exactPowerStep = qLn(range.upper/range.lower)*mLogBaseLnInv/(double)(mTickCount+1e-10);
|
|
|
+ double newLogBase = qPow(mLogBase, qMax((int)cleanMantissa(exactPowerStep), 1));
|
|
|
+ double currentTick = qPow(newLogBase, qFloor(qLn(range.lower)/qLn(newLogBase)));
|
|
|
+ result.append(currentTick);
|
|
|
+ while (currentTick < range.upper && currentTick > 0) // currentMag might be zero for ranges ~1e-300, just cancel in that case
|
|
|
+ {
|
|
|
+ currentTick *= newLogBase;
|
|
|
+ result.append(currentTick);
|
|
|
+ }
|
|
|
+ } else if (range.lower < 0 && range.upper < 0) // negative range
|
|
|
+ {
|
|
|
+ double exactPowerStep = qLn(range.lower/range.upper)*mLogBaseLnInv/(double)(mTickCount+1e-10);
|
|
|
+ double newLogBase = qPow(mLogBase, qMax((int)cleanMantissa(exactPowerStep), 1));
|
|
|
+ double currentTick = -qPow(newLogBase, qCeil(qLn(-range.lower)/qLn(newLogBase)));
|
|
|
+ result.append(currentTick);
|
|
|
+ while (currentTick < range.upper && currentTick < 0) // currentMag might be zero for ranges ~1e-300, just cancel in that case
|
|
|
+ {
|
|
|
+ currentTick /= newLogBase;
|
|
|
+ result.append(currentTick);
|
|
|
+ }
|
|
|
+ } else // invalid range for logarithmic scale, because lower and upper have different sign
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "Invalid range for logarithmic plot: " << range.lower << ".." << range.upper;
|
|
|
+ }
|
|
|
+
|
|
|
+ return result;
|
|
|
+}
|
|
|
+/* end of 'src/axis/axistickerlog.cpp' */
|
|
|
+
|
|
|
+
|
|
|
+/* including file 'src/axis/axis.cpp', size 99397 */
|
|
|
+/* commit 9868e55d3b412f2f89766bb482fcf299e93a0988 2017-09-04 01:56:22 +0200 */
|
|
|
+
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// 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 (mParentAxis->subTicks() && 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; }
|
|
|
+
|
|
|
+ const int tickCount = mParentAxis->mTickVector.size();
|
|
|
+ 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=0; i<tickCount; ++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=0; i<tickCount; ++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);
|
|
|
+ painter->setPen(mZeroLinePen);
|
|
|
+ double epsilon = mParentAxis->mRange.size()*1E-6; // for comparing double to zero
|
|
|
+ for (int i=0; i<tickCount; ++i)
|
|
|
+ {
|
|
|
+ if (qAbs(mParentAxis->mTickVector.at(i)) < epsilon)
|
|
|
+ {
|
|
|
+ zeroLineIndex = i;
|
|
|
+ t = mParentAxis->coordToPixel(mParentAxis->mTickVector.at(i)); // y
|
|
|
+ painter->drawLine(QLineF(mParentAxis->mAxisRect->left(), t, mParentAxis->mAxisRect->right(), t));
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ // draw grid lines:
|
|
|
+ applyDefaultAntialiasingHint(painter);
|
|
|
+ painter->setPen(mPen);
|
|
|
+ for (int i=0; i<tickCount; ++i)
|
|
|
+ {
|
|
|
+ if (i == zeroLineIndex) continue; // don't draw a gridline on top of the zeroline
|
|
|
+ t = mParentAxis->coordToPixel(mParentAxis->mTickVector.at(i)); // y
|
|
|
+ painter->drawLine(QLineF(mParentAxis->mAxisRect->left(), t, mParentAxis->mAxisRect->right(), t));
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Draws the sub grid lines with the specified painter.
|
|
|
+
|
|
|
+ This is a helper function called by \ref draw.
|
|
|
+*/
|
|
|
+void QCPGrid::drawSubGridLines(QCPPainter *painter) const
|
|
|
+{
|
|
|
+ if (!mParentAxis) { qDebug() << Q_FUNC_INFO << "invalid parent axis"; return; }
|
|
|
+
|
|
|
+ applyAntialiasingHint(painter, mAntialiasedSubGrid, QCP::aeSubGrid);
|
|
|
+ double t; // helper variable, result of coordinate-to-pixel transforms
|
|
|
+ painter->setPen(mSubGridPen);
|
|
|
+ if (mParentAxis->orientation() == Qt::Horizontal)
|
|
|
+ {
|
|
|
+ for (int i=0; i<mParentAxis->mSubTickVector.size(); ++i)
|
|
|
+ {
|
|
|
+ t = mParentAxis->coordToPixel(mParentAxis->mSubTickVector.at(i)); // x
|
|
|
+ painter->drawLine(QLineF(t, mParentAxis->mAxisRect->bottom(), t, mParentAxis->mAxisRect->top()));
|
|
|
+ }
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ for (int i=0; i<mParentAxis->mSubTickVector.size(); ++i)
|
|
|
+ {
|
|
|
+ t = mParentAxis->coordToPixel(mParentAxis->mSubTickVector.at(i)); // y
|
|
|
+ painter->drawLine(QLineF(mParentAxis->mAxisRect->left(), t, mParentAxis->mAxisRect->right(), t));
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPAxis
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+/*! \class QCPAxis
|
|
|
+ \brief Manages a single axis inside a QCustomPlot.
|
|
|
+
|
|
|
+ Usually doesn't need to be instantiated externally. Access %QCustomPlot's default four axes via
|
|
|
+ QCustomPlot::xAxis (bottom), QCustomPlot::yAxis (left), QCustomPlot::xAxis2 (top) and
|
|
|
+ QCustomPlot::yAxis2 (right).
|
|
|
+
|
|
|
+ Axes are always part of an axis rect, see QCPAxisRect.
|
|
|
+ \image html AxisNamesOverview.png
|
|
|
+ <center>Naming convention of axis parts</center>
|
|
|
+ \n
|
|
|
+
|
|
|
+ \image html AxisRectSpacingOverview.png
|
|
|
+ <center>Overview of the spacings and paddings that define the geometry of an axis. The dashed gray line
|
|
|
+ on the left represents the QCustomPlot widget border.</center>
|
|
|
+
|
|
|
+ Each axis holds an instance of QCPAxisTicker which is used to generate the tick coordinates and
|
|
|
+ tick labels. You can access the currently installed \ref ticker or set a new one (possibly one of
|
|
|
+ the specialized subclasses, or your own subclass) via \ref setTicker. For details, see the
|
|
|
+ documentation of QCPAxisTicker.
|
|
|
+*/
|
|
|
+
|
|
|
+/* start of documentation of inline functions */
|
|
|
+
|
|
|
+/*! \fn Qt::Orientation QCPAxis::orientation() const
|
|
|
+
|
|
|
+ Returns the orientation of this axis. The axis orientation (horizontal or vertical) is deduced
|
|
|
+ from the axis type (left, top, right or bottom).
|
|
|
+
|
|
|
+ \see orientation(AxisType type), pixelOrientation
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn QCPGrid *QCPAxis::grid() const
|
|
|
+
|
|
|
+ Returns the \ref QCPGrid instance belonging to this axis. Access it to set details about the way the
|
|
|
+ grid is displayed.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn static Qt::Orientation QCPAxis::orientation(AxisType type)
|
|
|
+
|
|
|
+ Returns the orientation of the specified axis type
|
|
|
+
|
|
|
+ \see orientation(), pixelOrientation
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn int QCPAxis::pixelOrientation() const
|
|
|
+
|
|
|
+ Returns which direction points towards higher coordinate values/keys, in pixel space.
|
|
|
+
|
|
|
+ This method returns either 1 or -1. If it returns 1, then going in the positive direction along
|
|
|
+ the orientation of the axis in pixels corresponds to going from lower to higher axis coordinates.
|
|
|
+ On the other hand, if this method returns -1, going to smaller pixel values corresponds to going
|
|
|
+ from lower to higher axis coordinates.
|
|
|
+
|
|
|
+ For example, this is useful to easily shift axis coordinates by a certain amount given in pixels,
|
|
|
+ without having to care about reversed or vertically aligned axes:
|
|
|
+
|
|
|
+ \code
|
|
|
+ double newKey = keyAxis->pixelToCoord(keyAxis->coordToPixel(oldKey)+10*keyAxis->pixelOrientation());
|
|
|
+ \endcode
|
|
|
+
|
|
|
+ \a newKey will then contain a key that is ten pixels towards higher keys, starting from \a oldKey.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn QSharedPointer<QCPAxisTicker> QCPAxis::ticker() const
|
|
|
+
|
|
|
+ Returns a modifiable shared pointer to the currently installed axis ticker. The axis ticker is
|
|
|
+ responsible for generating the tick positions and tick labels of this axis. You can access the
|
|
|
+ \ref QCPAxisTicker with this method and modify basic properties such as the approximate tick count
|
|
|
+ (\ref QCPAxisTicker::setTickCount).
|
|
|
+
|
|
|
+ You can gain more control over the axis ticks by setting a different \ref QCPAxisTicker subclass, see
|
|
|
+ the documentation there. A new axis ticker can be set with \ref setTicker.
|
|
|
+
|
|
|
+ Since the ticker is stored in the axis as a shared pointer, multiple axes may share the same axis
|
|
|
+ ticker simply by passing the same shared pointer to multiple axes.
|
|
|
+
|
|
|
+ \see setTicker
|
|
|
+*/
|
|
|
+
|
|
|
+/* end of documentation of inline functions */
|
|
|
+/* start of documentation of signals */
|
|
|
+
|
|
|
+/*! \fn void QCPAxis::rangeChanged(const QCPRange &newRange)
|
|
|
+
|
|
|
+ This signal is emitted when the range of this axis has changed. You can connect it to the \ref
|
|
|
+ setRange slot of another axis to communicate the new range to the other axis, in order for it to
|
|
|
+ be synchronized.
|
|
|
+
|
|
|
+ You may also manipulate/correct the range with \ref setRange in a slot connected to this signal.
|
|
|
+ This is useful if for example a maximum range span shall not be exceeded, or if the lower/upper
|
|
|
+ range shouldn't go beyond certain values (see \ref QCPRange::bounded). For example, the following
|
|
|
+ slot would limit the x axis to ranges between 0 and 10:
|
|
|
+ \code
|
|
|
+ customPlot->xAxis->setRange(newRange.bounded(0, 10))
|
|
|
+ \endcode
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn void QCPAxis::rangeChanged(const QCPRange &newRange, const QCPRange &oldRange)
|
|
|
+ \overload
|
|
|
+
|
|
|
+ Additionally to the new range, this signal also provides the previous range held by the axis as
|
|
|
+ \a oldRange.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn void QCPAxis::scaleTypeChanged(QCPAxis::ScaleType scaleType);
|
|
|
+
|
|
|
+ This signal is emitted when the scale type changes, by calls to \ref setScaleType
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn void QCPAxis::selectionChanged(QCPAxis::SelectableParts selection)
|
|
|
+
|
|
|
+ This signal is emitted when the selection state of this axis has changed, either by user interaction
|
|
|
+ or by a direct call to \ref setSelectedParts.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn void QCPAxis::selectableChanged(const QCPAxis::SelectableParts &parts);
|
|
|
+
|
|
|
+ This signal is emitted when the selectability changes, by calls to \ref setSelectableParts
|
|
|
+*/
|
|
|
+
|
|
|
+/* end of documentation of signals */
|
|
|
+
|
|
|
+/*!
|
|
|
+ Constructs an Axis instance of Type \a type for the axis rect \a parent.
|
|
|
+
|
|
|
+ Usually it isn't necessary to instantiate axes directly, because you can let QCustomPlot create
|
|
|
+ them for you with \ref QCPAxisRect::addAxis. If you want to use own QCPAxis-subclasses however,
|
|
|
+ create them manually and then inject them also via \ref QCPAxisRect::addAxis.
|
|
|
+*/
|
|
|
+QCPAxis::QCPAxis(QCPAxisRect *parent, AxisType type) :
|
|
|
+ QCPLayerable(parent->parentPlot(), QString(), parent),
|
|
|
+ // axis base:
|
|
|
+ mAxisType(type),
|
|
|
+ mAxisRect(parent),
|
|
|
+ mPadding(5),
|
|
|
+ mOrientation(orientation(type)),
|
|
|
+ mSelectableParts(spAxis | spTickLabels | spAxisLabel),
|
|
|
+ mSelectedParts(spNone),
|
|
|
+ mBasePen(QPen(Qt::black, 0, Qt::SolidLine, Qt::SquareCap)),
|
|
|
+ mSelectedBasePen(QPen(Qt::blue, 2)),
|
|
|
+ // axis label:
|
|
|
+ mLabel(),
|
|
|
+ mLabelFont(mParentPlot->font()),
|
|
|
+ mSelectedLabelFont(QFont(mLabelFont.family(), mLabelFont.pointSize(), QFont::Bold)),
|
|
|
+ mLabelColor(Qt::black),
|
|
|
+ mSelectedLabelColor(Qt::blue),
|
|
|
+ // tick labels:
|
|
|
+ mTickLabels(true),
|
|
|
+ mTickLabelFont(mParentPlot->font()),
|
|
|
+ mSelectedTickLabelFont(QFont(mTickLabelFont.family(), mTickLabelFont.pointSize(), QFont::Bold)),
|
|
|
+ mTickLabelColor(Qt::black),
|
|
|
+ mSelectedTickLabelColor(Qt::blue),
|
|
|
+ mNumberPrecision(6),
|
|
|
+ mNumberFormatChar('g'),
|
|
|
+ mNumberBeautifulPowers(true),
|
|
|
+ // ticks and subticks:
|
|
|
+ mTicks(true),
|
|
|
+ mSubTicks(true),
|
|
|
+ mTickPen(QPen(Qt::black, 0, Qt::SolidLine, Qt::SquareCap)),
|
|
|
+ mSelectedTickPen(QPen(Qt::blue, 2)),
|
|
|
+ mSubTickPen(QPen(Qt::black, 0, Qt::SolidLine, Qt::SquareCap)),
|
|
|
+ mSelectedSubTickPen(QPen(Qt::blue, 2)),
|
|
|
+ // scale and range:
|
|
|
+ mRange(0, 5),
|
|
|
+ mRangeReversed(false),
|
|
|
+ mScaleType(stLinear),
|
|
|
+ // internal members:
|
|
|
+ mGrid(new QCPGrid(this)),
|
|
|
+ mAxisPainter(new QCPAxisPainterPrivate(parent->parentPlot())),
|
|
|
+ mTicker(new QCPAxisTicker),
|
|
|
+ mCachedMarginValid(false),
|
|
|
+ mCachedMargin(0)
|
|
|
+{
|
|
|
+ setParent(parent);
|
|
|
+ mGrid->setVisible(false);
|
|
|
+ setAntialiased(false);
|
|
|
+ setLayer(mParentPlot->currentLayer()); // it's actually on that layer already, but we want it in front of the grid, so we place it on there again
|
|
|
+
|
|
|
+ if (type == atTop)
|
|
|
+ {
|
|
|
+ setTickLabelPadding(3);
|
|
|
+ setLabelPadding(6);
|
|
|
+ } else if (type == atRight)
|
|
|
+ {
|
|
|
+ setTickLabelPadding(7);
|
|
|
+ setLabelPadding(12);
|
|
|
+ } else if (type == atBottom)
|
|
|
+ {
|
|
|
+ setTickLabelPadding(3);
|
|
|
+ setLabelPadding(3);
|
|
|
+ } else if (type == atLeft)
|
|
|
+ {
|
|
|
+ setTickLabelPadding(5);
|
|
|
+ setLabelPadding(10);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+QCPAxis::~QCPAxis()
|
|
|
+{
|
|
|
+ delete mAxisPainter;
|
|
|
+ delete mGrid; // delete grid here instead of via parent ~QObject for better defined deletion order
|
|
|
+}
|
|
|
+
|
|
|
+/* No documentation as it is a property getter */
|
|
|
+int QCPAxis::tickLabelPadding() const
|
|
|
+{
|
|
|
+ return mAxisPainter->tickLabelPadding;
|
|
|
+}
|
|
|
+
|
|
|
+/* No documentation as it is a property getter */
|
|
|
+double QCPAxis::tickLabelRotation() const
|
|
|
+{
|
|
|
+ return mAxisPainter->tickLabelRotation;
|
|
|
+}
|
|
|
+
|
|
|
+/* No documentation as it is a property getter */
|
|
|
+QCPAxis::LabelSide QCPAxis::tickLabelSide() const
|
|
|
+{
|
|
|
+ return mAxisPainter->tickLabelSide;
|
|
|
+}
|
|
|
+
|
|
|
+/* No documentation as it is a property getter */
|
|
|
+QString QCPAxis::numberFormat() const
|
|
|
+{
|
|
|
+ QString result;
|
|
|
+ result.append(mNumberFormatChar);
|
|
|
+ if (mNumberBeautifulPowers)
|
|
|
+ {
|
|
|
+ result.append(QLatin1Char('b'));
|
|
|
+ if (mAxisPainter->numberMultiplyCross)
|
|
|
+ result.append(QLatin1Char('c'));
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/* No documentation as it is a property getter */
|
|
|
+int QCPAxis::tickLengthIn() const
|
|
|
+{
|
|
|
+ return mAxisPainter->tickLengthIn;
|
|
|
+}
|
|
|
+
|
|
|
+/* No documentation as it is a property getter */
|
|
|
+int QCPAxis::tickLengthOut() const
|
|
|
+{
|
|
|
+ return mAxisPainter->tickLengthOut;
|
|
|
+}
|
|
|
+
|
|
|
+/* No documentation as it is a property getter */
|
|
|
+int QCPAxis::subTickLengthIn() const
|
|
|
+{
|
|
|
+ return mAxisPainter->subTickLengthIn;
|
|
|
+}
|
|
|
+
|
|
|
+/* No documentation as it is a property getter */
|
|
|
+int QCPAxis::subTickLengthOut() const
|
|
|
+{
|
|
|
+ return mAxisPainter->subTickLengthOut;
|
|
|
+}
|
|
|
+
|
|
|
+/* No documentation as it is a property getter */
|
|
|
+int QCPAxis::labelPadding() const
|
|
|
+{
|
|
|
+ return mAxisPainter->labelPadding;
|
|
|
+}
|
|
|
+
|
|
|
+/* No documentation as it is a property getter */
|
|
|
+int QCPAxis::offset() const
|
|
|
+{
|
|
|
+ return mAxisPainter->offset;
|
|
|
+}
|
|
|
+
|
|
|
+/* No documentation as it is a property getter */
|
|
|
+QCPLineEnding QCPAxis::lowerEnding() const
|
|
|
+{
|
|
|
+ return mAxisPainter->lowerEnding;
|
|
|
+}
|
|
|
+
|
|
|
+/* No documentation as it is a property getter */
|
|
|
+QCPLineEnding QCPAxis::upperEnding() const
|
|
|
+{
|
|
|
+ return mAxisPainter->upperEnding;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets whether the axis uses a linear scale or a logarithmic scale.
|
|
|
+
|
|
|
+ Note that this method controls the coordinate transformation. You will likely also want to use a
|
|
|
+ logarithmic tick spacing and labeling, which can be achieved by setting an instance of \ref
|
|
|
+ QCPAxisTickerLog via \ref setTicker. See the documentation of \ref QCPAxisTickerLog about the
|
|
|
+ details of logarithmic axis tick creation.
|
|
|
+
|
|
|
+ \ref setNumberPrecision
|
|
|
+*/
|
|
|
+void QCPAxis::setScaleType(QCPAxis::ScaleType type)
|
|
|
+{
|
|
|
+ if (mScaleType != type)
|
|
|
+ {
|
|
|
+ mScaleType = type;
|
|
|
+ if (mScaleType == stLogarithmic)
|
|
|
+ setRange(mRange.sanitizedForLogScale());
|
|
|
+ mCachedMarginValid = false;
|
|
|
+ emit scaleTypeChanged(mScaleType);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the range of the axis.
|
|
|
+
|
|
|
+ This slot may be connected with the \ref rangeChanged signal of another axis so this axis
|
|
|
+ is always synchronized with the other axis range, when it changes.
|
|
|
+
|
|
|
+ To invert the direction of an axis, use \ref setRangeReversed.
|
|
|
+*/
|
|
|
+void QCPAxis::setRange(const QCPRange &range)
|
|
|
+{
|
|
|
+ if (range.lower == mRange.lower && range.upper == mRange.upper)
|
|
|
+ return;
|
|
|
+
|
|
|
+ if (!QCPRange::validRange(range)) return;
|
|
|
+ QCPRange oldRange = mRange;
|
|
|
+ if (mScaleType == stLogarithmic)
|
|
|
+ {
|
|
|
+ mRange = range.sanitizedForLogScale();
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ mRange = range.sanitizedForLinScale();
|
|
|
+ }
|
|
|
+ emit rangeChanged(mRange);
|
|
|
+ emit rangeChanged(mRange, oldRange);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets whether the user can (de-)select the parts in \a selectable by clicking on the QCustomPlot surface.
|
|
|
+ (When \ref QCustomPlot::setInteractions contains iSelectAxes.)
|
|
|
+
|
|
|
+ However, even when \a selectable is set to a value not allowing the selection of a specific part,
|
|
|
+ it is still possible to set the selection of this part manually, by calling \ref setSelectedParts
|
|
|
+ directly.
|
|
|
+
|
|
|
+ \see SelectablePart, setSelectedParts
|
|
|
+*/
|
|
|
+void QCPAxis::setSelectableParts(const SelectableParts &selectable)
|
|
|
+{
|
|
|
+ if (mSelectableParts != selectable)
|
|
|
+ {
|
|
|
+ mSelectableParts = selectable;
|
|
|
+ emit selectableChanged(mSelectableParts);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the selected state of the respective axis parts described by \ref SelectablePart. When a part
|
|
|
+ is selected, it uses a different pen/font.
|
|
|
+
|
|
|
+ The entire selection mechanism for axes is handled automatically when \ref
|
|
|
+ QCustomPlot::setInteractions contains iSelectAxes. You only need to call this function when you
|
|
|
+ wish to change the selection state manually.
|
|
|
+
|
|
|
+ This function can change the selection state of a part, independent of the \ref setSelectableParts setting.
|
|
|
+
|
|
|
+ emits the \ref selectionChanged signal when \a selected is different from the previous selection state.
|
|
|
+
|
|
|
+ \see SelectablePart, setSelectableParts, selectTest, setSelectedBasePen, setSelectedTickPen, setSelectedSubTickPen,
|
|
|
+ setSelectedTickLabelFont, setSelectedLabelFont, setSelectedTickLabelColor, setSelectedLabelColor
|
|
|
+*/
|
|
|
+void QCPAxis::setSelectedParts(const SelectableParts &selected)
|
|
|
+{
|
|
|
+ if (mSelectedParts != selected)
|
|
|
+ {
|
|
|
+ mSelectedParts = selected;
|
|
|
+ emit selectionChanged(mSelectedParts);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ \overload
|
|
|
+
|
|
|
+ Sets the lower and upper bound of the axis range.
|
|
|
+
|
|
|
+ To invert the direction of an axis, use \ref setRangeReversed.
|
|
|
+
|
|
|
+ There is also a slot to set a range, see \ref setRange(const QCPRange &range).
|
|
|
+*/
|
|
|
+void QCPAxis::setRange(double lower, double upper)
|
|
|
+{
|
|
|
+ if (lower == mRange.lower && upper == mRange.upper)
|
|
|
+ return;
|
|
|
+
|
|
|
+ if (!QCPRange::validRange(lower, upper)) return;
|
|
|
+ QCPRange oldRange = mRange;
|
|
|
+ mRange.lower = lower;
|
|
|
+ mRange.upper = upper;
|
|
|
+ if (mScaleType == stLogarithmic)
|
|
|
+ {
|
|
|
+ mRange = mRange.sanitizedForLogScale();
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ mRange = mRange.sanitizedForLinScale();
|
|
|
+ }
|
|
|
+ emit rangeChanged(mRange);
|
|
|
+ emit rangeChanged(mRange, oldRange);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ \overload
|
|
|
+
|
|
|
+ Sets the range of the axis.
|
|
|
+
|
|
|
+ The \a position coordinate indicates together with the \a alignment parameter, where the new
|
|
|
+ range will be positioned. \a size defines the size of the new axis range. \a alignment may be
|
|
|
+ Qt::AlignLeft, Qt::AlignRight or Qt::AlignCenter. This will cause the left border, right border,
|
|
|
+ or center of the range to be aligned with \a position. Any other values of \a alignment will
|
|
|
+ default to Qt::AlignCenter.
|
|
|
+*/
|
|
|
+void QCPAxis::setRange(double position, double size, Qt::AlignmentFlag alignment)
|
|
|
+{
|
|
|
+ if (alignment == Qt::AlignLeft)
|
|
|
+ setRange(position, position+size);
|
|
|
+ else if (alignment == Qt::AlignRight)
|
|
|
+ setRange(position-size, position);
|
|
|
+ else // alignment == Qt::AlignCenter
|
|
|
+ setRange(position-size/2.0, position+size/2.0);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the lower bound of the axis range. The upper bound is not changed.
|
|
|
+ \see setRange
|
|
|
+*/
|
|
|
+void QCPAxis::setRangeLower(double lower)
|
|
|
+{
|
|
|
+ if (mRange.lower == lower)
|
|
|
+ return;
|
|
|
+
|
|
|
+ QCPRange oldRange = mRange;
|
|
|
+ mRange.lower = lower;
|
|
|
+ if (mScaleType == stLogarithmic)
|
|
|
+ {
|
|
|
+ mRange = mRange.sanitizedForLogScale();
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ mRange = mRange.sanitizedForLinScale();
|
|
|
+ }
|
|
|
+ emit rangeChanged(mRange);
|
|
|
+ emit rangeChanged(mRange, oldRange);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the upper bound of the axis range. The lower bound is not changed.
|
|
|
+ \see setRange
|
|
|
+*/
|
|
|
+void QCPAxis::setRangeUpper(double upper)
|
|
|
+{
|
|
|
+ if (mRange.upper == upper)
|
|
|
+ return;
|
|
|
+
|
|
|
+ QCPRange oldRange = mRange;
|
|
|
+ mRange.upper = upper;
|
|
|
+ if (mScaleType == stLogarithmic)
|
|
|
+ {
|
|
|
+ mRange = mRange.sanitizedForLogScale();
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ mRange = mRange.sanitizedForLinScale();
|
|
|
+ }
|
|
|
+ emit rangeChanged(mRange);
|
|
|
+ emit rangeChanged(mRange, oldRange);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets whether the axis range (direction) is displayed reversed. Normally, the values on horizontal
|
|
|
+ axes increase left to right, on vertical axes bottom to top. When \a reversed is set to true, the
|
|
|
+ direction of increasing values is inverted.
|
|
|
+
|
|
|
+ Note that the range and data interface stays the same for reversed axes, e.g. the \a lower part
|
|
|
+ of the \ref setRange interface will still reference the mathematically smaller number than the \a
|
|
|
+ upper part.
|
|
|
+*/
|
|
|
+void QCPAxis::setRangeReversed(bool reversed)
|
|
|
+{
|
|
|
+ mRangeReversed = reversed;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ The axis ticker is responsible for generating the tick positions and tick labels. See the
|
|
|
+ documentation of QCPAxisTicker for details on how to work with axis tickers.
|
|
|
+
|
|
|
+ You can change the tick positioning/labeling behaviour of this axis by setting a different
|
|
|
+ QCPAxisTicker subclass using this method. If you only wish to modify the currently installed axis
|
|
|
+ ticker, access it via \ref ticker.
|
|
|
+
|
|
|
+ Since the ticker is stored in the axis as a shared pointer, multiple axes may share the same axis
|
|
|
+ ticker simply by passing the same shared pointer to multiple axes.
|
|
|
+
|
|
|
+ \see ticker
|
|
|
+*/
|
|
|
+void QCPAxis::setTicker(QSharedPointer<QCPAxisTicker> ticker)
|
|
|
+{
|
|
|
+ if (ticker)
|
|
|
+ mTicker = ticker;
|
|
|
+ else
|
|
|
+ qDebug() << Q_FUNC_INFO << "can not set 0 as axis ticker";
|
|
|
+ // no need to invalidate margin cache here because produced tick labels are checked for changes in setupTickVector
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets whether tick marks are displayed.
|
|
|
+
|
|
|
+ Note that setting \a show to false does not imply that tick labels are invisible, too. To achieve
|
|
|
+ that, see \ref setTickLabels.
|
|
|
+
|
|
|
+ \see setSubTicks
|
|
|
+*/
|
|
|
+void QCPAxis::setTicks(bool show)
|
|
|
+{
|
|
|
+ if (mTicks != show)
|
|
|
+ {
|
|
|
+ mTicks = show;
|
|
|
+ mCachedMarginValid = false;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets whether tick labels are displayed. Tick labels are the numbers drawn next to tick marks.
|
|
|
+*/
|
|
|
+void QCPAxis::setTickLabels(bool show)
|
|
|
+{
|
|
|
+ if (mTickLabels != show)
|
|
|
+ {
|
|
|
+ mTickLabels = show;
|
|
|
+ mCachedMarginValid = false;
|
|
|
+ if (!mTickLabels)
|
|
|
+ mTickVectorLabels.clear();
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the distance between the axis base line (including any outward ticks) and the tick labels.
|
|
|
+ \see setLabelPadding, setPadding
|
|
|
+*/
|
|
|
+void QCPAxis::setTickLabelPadding(int padding)
|
|
|
+{
|
|
|
+ if (mAxisPainter->tickLabelPadding != padding)
|
|
|
+ {
|
|
|
+ mAxisPainter->tickLabelPadding = padding;
|
|
|
+ mCachedMarginValid = false;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the font of the tick labels.
|
|
|
+
|
|
|
+ \see setTickLabels, setTickLabelColor
|
|
|
+*/
|
|
|
+void QCPAxis::setTickLabelFont(const QFont &font)
|
|
|
+{
|
|
|
+ if (font != mTickLabelFont)
|
|
|
+ {
|
|
|
+ mTickLabelFont = font;
|
|
|
+ mCachedMarginValid = false;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the color of the tick labels.
|
|
|
+
|
|
|
+ \see setTickLabels, setTickLabelFont
|
|
|
+*/
|
|
|
+void QCPAxis::setTickLabelColor(const QColor &color)
|
|
|
+{
|
|
|
+ mTickLabelColor = color;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the rotation of the tick labels. If \a degrees is zero, the labels are drawn normally. Else,
|
|
|
+ the tick labels are drawn rotated by \a degrees clockwise. The specified angle is bound to values
|
|
|
+ from -90 to 90 degrees.
|
|
|
+
|
|
|
+ If \a degrees is exactly -90, 0 or 90, the tick labels are centered on the tick coordinate. For
|
|
|
+ other angles, the label is drawn with an offset such that it seems to point toward or away from
|
|
|
+ the tick mark.
|
|
|
+*/
|
|
|
+void QCPAxis::setTickLabelRotation(double degrees)
|
|
|
+{
|
|
|
+ if (!qFuzzyIsNull(degrees-mAxisPainter->tickLabelRotation))
|
|
|
+ {
|
|
|
+ mAxisPainter->tickLabelRotation = qBound(-90.0, degrees, 90.0);
|
|
|
+ mCachedMarginValid = false;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets whether the tick labels (numbers) shall appear inside or outside the axis rect.
|
|
|
+
|
|
|
+ The usual and default setting is \ref lsOutside. Very compact plots sometimes require tick labels
|
|
|
+ to be inside the axis rect, to save space. If \a side is set to \ref lsInside, the tick labels
|
|
|
+ appear on the inside are additionally clipped to the axis rect.
|
|
|
+*/
|
|
|
+void QCPAxis::setTickLabelSide(LabelSide side)
|
|
|
+{
|
|
|
+ mAxisPainter->tickLabelSide = side;
|
|
|
+ mCachedMarginValid = false;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the number format for the numbers in tick labels. This \a formatCode is an extended version
|
|
|
+ of the format code used e.g. by QString::number() and QLocale::toString(). For reference about
|
|
|
+ that, see the "Argument Formats" section in the detailed description of the QString class.
|
|
|
+
|
|
|
+ \a formatCode is a string of one, two or three characters. The first character is identical to
|
|
|
+ the normal format code used by Qt. In short, this means: 'e'/'E' scientific format, 'f' fixed
|
|
|
+ format, 'g'/'G' scientific or fixed, whichever is shorter.
|
|
|
+
|
|
|
+ The second and third characters are optional and specific to QCustomPlot:\n
|
|
|
+ If the first char was 'e' or 'g', numbers are/might be displayed in the scientific format, e.g.
|
|
|
+ "5.5e9", which is ugly in a plot. So when the second char of \a formatCode is set to 'b' (for
|
|
|
+ "beautiful"), those exponential numbers are formatted in a more natural way, i.e. "5.5
|
|
|
+ [multiplication sign] 10 [superscript] 9". By default, the multiplication sign is a centered dot.
|
|
|
+ If instead a cross should be shown (as is usual in the USA), the third char of \a formatCode can
|
|
|
+ be set to 'c'. The inserted multiplication signs are the UTF-8 characters 215 (0xD7) for the
|
|
|
+ cross and 183 (0xB7) for the dot.
|
|
|
+
|
|
|
+ Examples for \a formatCode:
|
|
|
+ \li \c g normal format code behaviour. If number is small, fixed format is used, if number is large,
|
|
|
+ normal scientific format is used
|
|
|
+ \li \c gb If number is small, fixed format is used, if number is large, scientific format is used with
|
|
|
+ beautifully typeset decimal powers and a dot as multiplication sign
|
|
|
+ \li \c ebc All numbers are in scientific format with beautifully typeset decimal power and a cross as
|
|
|
+ multiplication sign
|
|
|
+ \li \c fb illegal format code, since fixed format doesn't support (or need) beautifully typeset decimal
|
|
|
+ powers. Format code will be reduced to 'f'.
|
|
|
+ \li \c hello illegal format code, since first char is not 'e', 'E', 'f', 'g' or 'G'. Current format
|
|
|
+ code will not be changed.
|
|
|
+*/
|
|
|
+void QCPAxis::setNumberFormat(const QString &formatCode)
|
|
|
+{
|
|
|
+ if (formatCode.isEmpty())
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "Passed formatCode is empty";
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ mCachedMarginValid = false;
|
|
|
+
|
|
|
+ // interpret first char as number format char:
|
|
|
+ QString allowedFormatChars(QLatin1String("eEfgG"));
|
|
|
+ if (allowedFormatChars.contains(formatCode.at(0)))
|
|
|
+ {
|
|
|
+ mNumberFormatChar = QLatin1Char(formatCode.at(0).toLatin1());
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "Invalid number format code (first char not in 'eEfgG'):" << formatCode;
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ if (formatCode.length() < 2)
|
|
|
+ {
|
|
|
+ mNumberBeautifulPowers = false;
|
|
|
+ mAxisPainter->numberMultiplyCross = false;
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ // interpret second char as indicator for beautiful decimal powers:
|
|
|
+ if (formatCode.at(1) == QLatin1Char('b') && (mNumberFormatChar == QLatin1Char('e') || mNumberFormatChar == QLatin1Char('g')))
|
|
|
+ {
|
|
|
+ mNumberBeautifulPowers = true;
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "Invalid number format code (second char not 'b' or first char neither 'e' nor 'g'):" << formatCode;
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ if (formatCode.length() < 3)
|
|
|
+ {
|
|
|
+ mAxisPainter->numberMultiplyCross = false;
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ // interpret third char as indicator for dot or cross multiplication symbol:
|
|
|
+ if (formatCode.at(2) == QLatin1Char('c'))
|
|
|
+ {
|
|
|
+ mAxisPainter->numberMultiplyCross = true;
|
|
|
+ } else if (formatCode.at(2) == QLatin1Char('d'))
|
|
|
+ {
|
|
|
+ mAxisPainter->numberMultiplyCross = false;
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "Invalid number format code (third char neither 'c' nor 'd'):" << formatCode;
|
|
|
+ return;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the precision of the tick label numbers. See QLocale::toString(double i, char f, int prec)
|
|
|
+ for details. The effect of precisions are most notably for number Formats starting with 'e', see
|
|
|
+ \ref setNumberFormat
|
|
|
+*/
|
|
|
+void QCPAxis::setNumberPrecision(int precision)
|
|
|
+{
|
|
|
+ if (mNumberPrecision != precision)
|
|
|
+ {
|
|
|
+ mNumberPrecision = precision;
|
|
|
+ mCachedMarginValid = false;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the length of the ticks in pixels. \a inside is the length the ticks will reach inside the
|
|
|
+ plot and \a outside is the length they will reach outside the plot. If \a outside is greater than
|
|
|
+ zero, the tick labels and axis label will increase their distance to the axis accordingly, so
|
|
|
+ they won't collide with the ticks.
|
|
|
+
|
|
|
+ \see setSubTickLength, setTickLengthIn, setTickLengthOut
|
|
|
+*/
|
|
|
+void QCPAxis::setTickLength(int inside, int outside)
|
|
|
+{
|
|
|
+ setTickLengthIn(inside);
|
|
|
+ setTickLengthOut(outside);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the length of the inward ticks in pixels. \a inside is the length the ticks will reach
|
|
|
+ inside the plot.
|
|
|
+
|
|
|
+ \see setTickLengthOut, setTickLength, setSubTickLength
|
|
|
+*/
|
|
|
+void QCPAxis::setTickLengthIn(int inside)
|
|
|
+{
|
|
|
+ if (mAxisPainter->tickLengthIn != inside)
|
|
|
+ {
|
|
|
+ mAxisPainter->tickLengthIn = inside;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the length of the outward ticks in pixels. \a outside is the length the ticks will reach
|
|
|
+ outside the plot. If \a outside is greater than zero, the tick labels and axis label will
|
|
|
+ increase their distance to the axis accordingly, so they won't collide with the ticks.
|
|
|
+
|
|
|
+ \see setTickLengthIn, setTickLength, setSubTickLength
|
|
|
+*/
|
|
|
+void QCPAxis::setTickLengthOut(int outside)
|
|
|
+{
|
|
|
+ if (mAxisPainter->tickLengthOut != outside)
|
|
|
+ {
|
|
|
+ mAxisPainter->tickLengthOut = outside;
|
|
|
+ mCachedMarginValid = false; // only outside tick length can change margin
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets whether sub tick marks are displayed.
|
|
|
+
|
|
|
+ Sub ticks are only potentially visible if (major) ticks are also visible (see \ref setTicks)
|
|
|
+
|
|
|
+ \see setTicks
|
|
|
+*/
|
|
|
+void QCPAxis::setSubTicks(bool show)
|
|
|
+{
|
|
|
+ if (mSubTicks != show)
|
|
|
+ {
|
|
|
+ mSubTicks = show;
|
|
|
+ mCachedMarginValid = false;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the length of the subticks in pixels. \a inside is the length the subticks will reach inside
|
|
|
+ the plot and \a outside is the length they will reach outside the plot. If \a outside is greater
|
|
|
+ than zero, the tick labels and axis label will increase their distance to the axis accordingly,
|
|
|
+ so they won't collide with the ticks.
|
|
|
+
|
|
|
+ \see setTickLength, setSubTickLengthIn, setSubTickLengthOut
|
|
|
+*/
|
|
|
+void QCPAxis::setSubTickLength(int inside, int outside)
|
|
|
+{
|
|
|
+ setSubTickLengthIn(inside);
|
|
|
+ setSubTickLengthOut(outside);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the length of the inward subticks in pixels. \a inside is the length the subticks will reach inside
|
|
|
+ the plot.
|
|
|
+
|
|
|
+ \see setSubTickLengthOut, setSubTickLength, setTickLength
|
|
|
+*/
|
|
|
+void QCPAxis::setSubTickLengthIn(int inside)
|
|
|
+{
|
|
|
+ if (mAxisPainter->subTickLengthIn != inside)
|
|
|
+ {
|
|
|
+ mAxisPainter->subTickLengthIn = inside;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the length of the outward subticks in pixels. \a outside is the length the subticks will reach
|
|
|
+ outside the plot. If \a outside is greater than zero, the tick labels will increase their
|
|
|
+ distance to the axis accordingly, so they won't collide with the ticks.
|
|
|
+
|
|
|
+ \see setSubTickLengthIn, setSubTickLength, setTickLength
|
|
|
+*/
|
|
|
+void QCPAxis::setSubTickLengthOut(int outside)
|
|
|
+{
|
|
|
+ if (mAxisPainter->subTickLengthOut != outside)
|
|
|
+ {
|
|
|
+ mAxisPainter->subTickLengthOut = outside;
|
|
|
+ mCachedMarginValid = false; // only outside tick length can change margin
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the pen, the axis base line is drawn with.
|
|
|
+
|
|
|
+ \see setTickPen, setSubTickPen
|
|
|
+*/
|
|
|
+void QCPAxis::setBasePen(const QPen &pen)
|
|
|
+{
|
|
|
+ mBasePen = pen;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the pen, tick marks will be drawn with.
|
|
|
+
|
|
|
+ \see setTickLength, setBasePen
|
|
|
+*/
|
|
|
+void QCPAxis::setTickPen(const QPen &pen)
|
|
|
+{
|
|
|
+ mTickPen = pen;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the pen, subtick marks will be drawn with.
|
|
|
+
|
|
|
+ \see setSubTickCount, setSubTickLength, setBasePen
|
|
|
+*/
|
|
|
+void QCPAxis::setSubTickPen(const QPen &pen)
|
|
|
+{
|
|
|
+ mSubTickPen = pen;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the font of the axis label.
|
|
|
+
|
|
|
+ \see setLabelColor
|
|
|
+*/
|
|
|
+void QCPAxis::setLabelFont(const QFont &font)
|
|
|
+{
|
|
|
+ if (mLabelFont != font)
|
|
|
+ {
|
|
|
+ mLabelFont = font;
|
|
|
+ mCachedMarginValid = false;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the color of the axis label.
|
|
|
+
|
|
|
+ \see setLabelFont
|
|
|
+*/
|
|
|
+void QCPAxis::setLabelColor(const QColor &color)
|
|
|
+{
|
|
|
+ mLabelColor = color;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the text of the axis label that will be shown below/above or next to the axis, depending on
|
|
|
+ its orientation. To disable axis labels, pass an empty string as \a str.
|
|
|
+*/
|
|
|
+void QCPAxis::setLabel(const QString &str)
|
|
|
+{
|
|
|
+ if (mLabel != str)
|
|
|
+ {
|
|
|
+ mLabel = str;
|
|
|
+ mCachedMarginValid = false;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the distance between the tick labels and the axis label.
|
|
|
+
|
|
|
+ \see setTickLabelPadding, setPadding
|
|
|
+*/
|
|
|
+void QCPAxis::setLabelPadding(int padding)
|
|
|
+{
|
|
|
+ if (mAxisPainter->labelPadding != padding)
|
|
|
+ {
|
|
|
+ mAxisPainter->labelPadding = padding;
|
|
|
+ mCachedMarginValid = false;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the padding of the axis.
|
|
|
+
|
|
|
+ When \ref QCPAxisRect::setAutoMargins is enabled, the padding is the additional outer most space,
|
|
|
+ that is left blank.
|
|
|
+
|
|
|
+ The axis padding has no meaning if \ref QCPAxisRect::setAutoMargins is disabled.
|
|
|
+
|
|
|
+ \see setLabelPadding, setTickLabelPadding
|
|
|
+*/
|
|
|
+void QCPAxis::setPadding(int padding)
|
|
|
+{
|
|
|
+ if (mPadding != padding)
|
|
|
+ {
|
|
|
+ mPadding = padding;
|
|
|
+ mCachedMarginValid = false;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the offset the axis has to its axis rect side.
|
|
|
+
|
|
|
+ If an axis rect side has multiple axes and automatic margin calculation is enabled for that side,
|
|
|
+ only the offset of the inner most axis has meaning (even if it is set to be invisible). The
|
|
|
+ offset of the other, outer axes is controlled automatically, to place them at appropriate
|
|
|
+ positions.
|
|
|
+*/
|
|
|
+void QCPAxis::setOffset(int offset)
|
|
|
+{
|
|
|
+ mAxisPainter->offset = offset;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the font that is used for tick labels when they are selected.
|
|
|
+
|
|
|
+ \see setTickLabelFont, setSelectableParts, setSelectedParts, QCustomPlot::setInteractions
|
|
|
+*/
|
|
|
+void QCPAxis::setSelectedTickLabelFont(const QFont &font)
|
|
|
+{
|
|
|
+ if (font != mSelectedTickLabelFont)
|
|
|
+ {
|
|
|
+ mSelectedTickLabelFont = font;
|
|
|
+ // don't set mCachedMarginValid to false here because margin calculation is always done with non-selected fonts
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the font that is used for the axis label when it is selected.
|
|
|
+
|
|
|
+ \see setLabelFont, setSelectableParts, setSelectedParts, QCustomPlot::setInteractions
|
|
|
+*/
|
|
|
+void QCPAxis::setSelectedLabelFont(const QFont &font)
|
|
|
+{
|
|
|
+ mSelectedLabelFont = font;
|
|
|
+ // don't set mCachedMarginValid to false here because margin calculation is always done with non-selected fonts
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the color that is used for tick labels when they are selected.
|
|
|
+
|
|
|
+ \see setTickLabelColor, setSelectableParts, setSelectedParts, QCustomPlot::setInteractions
|
|
|
+*/
|
|
|
+void QCPAxis::setSelectedTickLabelColor(const QColor &color)
|
|
|
+{
|
|
|
+ if (color != mSelectedTickLabelColor)
|
|
|
+ {
|
|
|
+ mSelectedTickLabelColor = color;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the color that is used for the axis label when it is selected.
|
|
|
+
|
|
|
+ \see setLabelColor, setSelectableParts, setSelectedParts, QCustomPlot::setInteractions
|
|
|
+*/
|
|
|
+void QCPAxis::setSelectedLabelColor(const QColor &color)
|
|
|
+{
|
|
|
+ mSelectedLabelColor = color;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the pen that is used to draw the axis base line when selected.
|
|
|
+
|
|
|
+ \see setBasePen, setSelectableParts, setSelectedParts, QCustomPlot::setInteractions
|
|
|
+*/
|
|
|
+void QCPAxis::setSelectedBasePen(const QPen &pen)
|
|
|
+{
|
|
|
+ mSelectedBasePen = pen;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the pen that is used to draw the (major) ticks when selected.
|
|
|
+
|
|
|
+ \see setTickPen, setSelectableParts, setSelectedParts, QCustomPlot::setInteractions
|
|
|
+*/
|
|
|
+void QCPAxis::setSelectedTickPen(const QPen &pen)
|
|
|
+{
|
|
|
+ mSelectedTickPen = pen;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the pen that is used to draw the subticks when selected.
|
|
|
+
|
|
|
+ \see setSubTickPen, setSelectableParts, setSelectedParts, QCustomPlot::setInteractions
|
|
|
+*/
|
|
|
+void QCPAxis::setSelectedSubTickPen(const QPen &pen)
|
|
|
+{
|
|
|
+ mSelectedSubTickPen = pen;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the style for the lower axis ending. See the documentation of QCPLineEnding for available
|
|
|
+ styles.
|
|
|
+
|
|
|
+ For horizontal axes, this method refers to the left ending, for vertical axes the bottom ending.
|
|
|
+ Note that this meaning does not change when the axis range is reversed with \ref
|
|
|
+ setRangeReversed.
|
|
|
+
|
|
|
+ \see setUpperEnding
|
|
|
+*/
|
|
|
+void QCPAxis::setLowerEnding(const QCPLineEnding &ending)
|
|
|
+{
|
|
|
+ mAxisPainter->lowerEnding = ending;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the style for the upper axis ending. See the documentation of QCPLineEnding for available
|
|
|
+ styles.
|
|
|
+
|
|
|
+ For horizontal axes, this method refers to the right ending, for vertical axes the top ending.
|
|
|
+ Note that this meaning does not change when the axis range is reversed with \ref
|
|
|
+ setRangeReversed.
|
|
|
+
|
|
|
+ \see setLowerEnding
|
|
|
+*/
|
|
|
+void QCPAxis::setUpperEnding(const QCPLineEnding &ending)
|
|
|
+{
|
|
|
+ mAxisPainter->upperEnding = ending;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ If the scale type (\ref setScaleType) is \ref stLinear, \a diff is added to the lower and upper
|
|
|
+ bounds of the range. The range is simply moved by \a diff.
|
|
|
+
|
|
|
+ If the scale type is \ref stLogarithmic, the range bounds are multiplied by \a diff. This
|
|
|
+ corresponds to an apparent "linear" move in logarithmic scaling by a distance of log(diff).
|
|
|
+*/
|
|
|
+void QCPAxis::moveRange(double diff)
|
|
|
+{
|
|
|
+ QCPRange oldRange = mRange;
|
|
|
+ if (mScaleType == stLinear)
|
|
|
+ {
|
|
|
+ mRange.lower += diff;
|
|
|
+ mRange.upper += diff;
|
|
|
+ } else // mScaleType == stLogarithmic
|
|
|
+ {
|
|
|
+ mRange.lower *= diff;
|
|
|
+ mRange.upper *= diff;
|
|
|
+ }
|
|
|
+ emit rangeChanged(mRange);
|
|
|
+ emit rangeChanged(mRange, oldRange);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Scales the range of this axis by \a factor around the center of the current axis range. For
|
|
|
+ example, if \a factor is 2.0, then the axis range will double its size, and the point at the axis
|
|
|
+ range center won't have changed its position in the QCustomPlot widget (i.e. coordinates around
|
|
|
+ the center will have moved symmetrically closer).
|
|
|
+
|
|
|
+ If you wish to scale around a different coordinate than the current axis range center, use the
|
|
|
+ overload \ref scaleRange(double factor, double center).
|
|
|
+*/
|
|
|
+void QCPAxis::scaleRange(double factor)
|
|
|
+{
|
|
|
+ scaleRange(factor, range().center());
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Scales the range of this axis by \a factor around the coordinate \a center. For example, if \a
|
|
|
+ factor is 2.0, \a center is 1.0, then the axis range will double its size, and the point at
|
|
|
+ coordinate 1.0 won't have changed its position in the QCustomPlot widget (i.e. coordinates
|
|
|
+ around 1.0 will have moved symmetrically closer to 1.0).
|
|
|
+
|
|
|
+ \see scaleRange(double factor)
|
|
|
+*/
|
|
|
+void QCPAxis::scaleRange(double factor, double center)
|
|
|
+{
|
|
|
+ QCPRange oldRange = mRange;
|
|
|
+ if (mScaleType == stLinear)
|
|
|
+ {
|
|
|
+ QCPRange newRange;
|
|
|
+ newRange.lower = (mRange.lower-center)*factor + center;
|
|
|
+ newRange.upper = (mRange.upper-center)*factor + center;
|
|
|
+ if (QCPRange::validRange(newRange))
|
|
|
+ mRange = newRange.sanitizedForLinScale();
|
|
|
+ } else // mScaleType == stLogarithmic
|
|
|
+ {
|
|
|
+ if ((mRange.upper < 0 && center < 0) || (mRange.upper > 0 && center > 0)) // make sure center has same sign as range
|
|
|
+ {
|
|
|
+ QCPRange newRange;
|
|
|
+ newRange.lower = qPow(mRange.lower/center, factor)*center;
|
|
|
+ newRange.upper = qPow(mRange.upper/center, factor)*center;
|
|
|
+ if (QCPRange::validRange(newRange))
|
|
|
+ mRange = newRange.sanitizedForLogScale();
|
|
|
+ } else
|
|
|
+ qDebug() << Q_FUNC_INFO << "Center of scaling operation doesn't lie in same logarithmic sign domain as range:" << center;
|
|
|
+ }
|
|
|
+ emit rangeChanged(mRange);
|
|
|
+ emit rangeChanged(mRange, oldRange);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Scales the range of this axis to have a certain scale \a ratio to \a otherAxis. The scaling will
|
|
|
+ be done around the center of the current axis range.
|
|
|
+
|
|
|
+ For example, if \a ratio is 1, this axis is the \a yAxis and \a otherAxis is \a xAxis, graphs
|
|
|
+ plotted with those axes will appear in a 1:1 aspect ratio, independent of the aspect ratio the
|
|
|
+ axis rect has.
|
|
|
+
|
|
|
+ This is an operation that changes the range of this axis once, it doesn't fix the scale ratio
|
|
|
+ indefinitely. Note that calling this function in the constructor of the QCustomPlot's parent
|
|
|
+ won't have the desired effect, since the widget dimensions aren't defined yet, and a resizeEvent
|
|
|
+ will follow.
|
|
|
+*/
|
|
|
+void QCPAxis::setScaleRatio(const QCPAxis *otherAxis, double ratio)
|
|
|
+{
|
|
|
+ int otherPixelSize, ownPixelSize;
|
|
|
+
|
|
|
+ if (otherAxis->orientation() == Qt::Horizontal)
|
|
|
+ otherPixelSize = otherAxis->axisRect()->width();
|
|
|
+ else
|
|
|
+ otherPixelSize = otherAxis->axisRect()->height();
|
|
|
+
|
|
|
+ if (orientation() == Qt::Horizontal)
|
|
|
+ ownPixelSize = axisRect()->width();
|
|
|
+ else
|
|
|
+ ownPixelSize = axisRect()->height();
|
|
|
+
|
|
|
+ double newRangeSize = ratio*otherAxis->range().size()*ownPixelSize/(double)otherPixelSize;
|
|
|
+ setRange(range().center(), newRangeSize, Qt::AlignCenter);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Changes the axis range such that all plottables associated with this axis are fully visible in
|
|
|
+ that dimension.
|
|
|
+
|
|
|
+ \see QCPAbstractPlottable::rescaleAxes, QCustomPlot::rescaleAxes
|
|
|
+*/
|
|
|
+void QCPAxis::rescale(bool onlyVisiblePlottables)
|
|
|
+{
|
|
|
+ QList<QCPAbstractPlottable*> p = plottables();
|
|
|
+ QCPRange newRange;
|
|
|
+ bool haveRange = false;
|
|
|
+ for (int i=0; i<p.size(); ++i)
|
|
|
+ {
|
|
|
+ if (!p.at(i)->realVisibility() && onlyVisiblePlottables)
|
|
|
+ continue;
|
|
|
+ QCPRange plottableRange;
|
|
|
+ bool currentFoundRange;
|
|
|
+ QCP::SignDomain signDomain = QCP::sdBoth;
|
|
|
+ if (mScaleType == stLogarithmic)
|
|
|
+ signDomain = (mRange.upper < 0 ? QCP::sdNegative : QCP::sdPositive);
|
|
|
+ if (p.at(i)->keyAxis() == this)
|
|
|
+ plottableRange = p.at(i)->getKeyRange(currentFoundRange, signDomain);
|
|
|
+ else
|
|
|
+ plottableRange = p.at(i)->getValueRange(currentFoundRange, signDomain);
|
|
|
+ if (currentFoundRange)
|
|
|
+ {
|
|
|
+ if (!haveRange)
|
|
|
+ newRange = plottableRange;
|
|
|
+ else
|
|
|
+ newRange.expand(plottableRange);
|
|
|
+ haveRange = true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (haveRange)
|
|
|
+ {
|
|
|
+ if (!QCPRange::validRange(newRange)) // likely due to range being zero (plottable has only constant data in this axis dimension), shift current range to at least center the plottable
|
|
|
+ {
|
|
|
+ double center = (newRange.lower+newRange.upper)*0.5; // upper and lower should be equal anyway, but just to make sure, incase validRange returned false for other reason
|
|
|
+ if (mScaleType == stLinear)
|
|
|
+ {
|
|
|
+ newRange.lower = center-mRange.size()/2.0;
|
|
|
+ newRange.upper = center+mRange.size()/2.0;
|
|
|
+ } else // mScaleType == stLogarithmic
|
|
|
+ {
|
|
|
+ newRange.lower = center/qSqrt(mRange.upper/mRange.lower);
|
|
|
+ newRange.upper = center*qSqrt(mRange.upper/mRange.lower);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ setRange(newRange);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Transforms \a value, in pixel coordinates of the QCustomPlot widget, to axis coordinates.
|
|
|
+*/
|
|
|
+double QCPAxis::pixelToCoord(double value) const
|
|
|
+{
|
|
|
+ if (orientation() == Qt::Horizontal)
|
|
|
+ {
|
|
|
+ if (mScaleType == stLinear)
|
|
|
+ {
|
|
|
+ if (!mRangeReversed)
|
|
|
+ return (value-mAxisRect->left())/(double)mAxisRect->width()*mRange.size()+mRange.lower;
|
|
|
+ else
|
|
|
+ return -(value-mAxisRect->left())/(double)mAxisRect->width()*mRange.size()+mRange.upper;
|
|
|
+ } else // mScaleType == stLogarithmic
|
|
|
+ {
|
|
|
+ if (!mRangeReversed)
|
|
|
+ return qPow(mRange.upper/mRange.lower, (value-mAxisRect->left())/(double)mAxisRect->width())*mRange.lower;
|
|
|
+ else
|
|
|
+ return qPow(mRange.upper/mRange.lower, (mAxisRect->left()-value)/(double)mAxisRect->width())*mRange.upper;
|
|
|
+ }
|
|
|
+ } else // orientation() == Qt::Vertical
|
|
|
+ {
|
|
|
+ if (mScaleType == stLinear)
|
|
|
+ {
|
|
|
+ if (!mRangeReversed)
|
|
|
+ return (mAxisRect->bottom()-value)/(double)mAxisRect->height()*mRange.size()+mRange.lower;
|
|
|
+ else
|
|
|
+ return -(mAxisRect->bottom()-value)/(double)mAxisRect->height()*mRange.size()+mRange.upper;
|
|
|
+ } else // mScaleType == stLogarithmic
|
|
|
+ {
|
|
|
+ if (!mRangeReversed)
|
|
|
+ return qPow(mRange.upper/mRange.lower, (mAxisRect->bottom()-value)/(double)mAxisRect->height())*mRange.lower;
|
|
|
+ else
|
|
|
+ return qPow(mRange.upper/mRange.lower, (value-mAxisRect->bottom())/(double)mAxisRect->height())*mRange.upper;
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Transforms \a value, in coordinates of the axis, to pixel coordinates of the QCustomPlot widget.
|
|
|
+*/
|
|
|
+double QCPAxis::coordToPixel(double value) const
|
|
|
+{
|
|
|
+ if (orientation() == Qt::Horizontal)
|
|
|
+ {
|
|
|
+ if (mScaleType == stLinear)
|
|
|
+ {
|
|
|
+ if (!mRangeReversed)
|
|
|
+ return (value-mRange.lower)/mRange.size()*mAxisRect->width()+mAxisRect->left();
|
|
|
+ else
|
|
|
+ return (mRange.upper-value)/mRange.size()*mAxisRect->width()+mAxisRect->left();
|
|
|
+ } else // mScaleType == stLogarithmic
|
|
|
+ {
|
|
|
+ if (value >= 0.0 && mRange.upper < 0.0) // invalid value for logarithmic scale, just draw it outside visible range
|
|
|
+ return !mRangeReversed ? mAxisRect->right()+200 : mAxisRect->left()-200;
|
|
|
+ else if (value <= 0.0 && mRange.upper >= 0.0) // invalid value for logarithmic scale, just draw it outside visible range
|
|
|
+ return !mRangeReversed ? mAxisRect->left()-200 : mAxisRect->right()+200;
|
|
|
+ else
|
|
|
+ {
|
|
|
+ if (!mRangeReversed)
|
|
|
+ return qLn(value/mRange.lower)/qLn(mRange.upper/mRange.lower)*mAxisRect->width()+mAxisRect->left();
|
|
|
+ else
|
|
|
+ return qLn(mRange.upper/value)/qLn(mRange.upper/mRange.lower)*mAxisRect->width()+mAxisRect->left();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } else // orientation() == Qt::Vertical
|
|
|
+ {
|
|
|
+ if (mScaleType == stLinear)
|
|
|
+ {
|
|
|
+ if (!mRangeReversed)
|
|
|
+ return mAxisRect->bottom()-(value-mRange.lower)/mRange.size()*mAxisRect->height();
|
|
|
+ else
|
|
|
+ return mAxisRect->bottom()-(mRange.upper-value)/mRange.size()*mAxisRect->height();
|
|
|
+ } else // mScaleType == stLogarithmic
|
|
|
+ {
|
|
|
+ if (value >= 0.0 && mRange.upper < 0.0) // invalid value for logarithmic scale, just draw it outside visible range
|
|
|
+ return !mRangeReversed ? mAxisRect->top()-200 : mAxisRect->bottom()+200;
|
|
|
+ else if (value <= 0.0 && mRange.upper >= 0.0) // invalid value for logarithmic scale, just draw it outside visible range
|
|
|
+ return !mRangeReversed ? mAxisRect->bottom()+200 : mAxisRect->top()-200;
|
|
|
+ else
|
|
|
+ {
|
|
|
+ if (!mRangeReversed)
|
|
|
+ return mAxisRect->bottom()-qLn(value/mRange.lower)/qLn(mRange.upper/mRange.lower)*mAxisRect->height();
|
|
|
+ else
|
|
|
+ return mAxisRect->bottom()-qLn(mRange.upper/value)/qLn(mRange.upper/mRange.lower)*mAxisRect->height();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns the part of the axis that is hit by \a pos (in pixels). The return value of this function
|
|
|
+ is independent of the user-selectable parts defined with \ref setSelectableParts. Further, this
|
|
|
+ function does not change the current selection state of the axis.
|
|
|
+
|
|
|
+ If the axis is not visible (\ref setVisible), this function always returns \ref spNone.
|
|
|
+
|
|
|
+ \see setSelectedParts, setSelectableParts, QCustomPlot::setInteractions
|
|
|
+*/
|
|
|
+QCPAxis::SelectablePart QCPAxis::getPartAt(const QPointF &pos) const
|
|
|
+{
|
|
|
+ if (!mVisible)
|
|
|
+ return spNone;
|
|
|
+
|
|
|
+ if (mAxisPainter->axisSelectionBox().contains(pos.toPoint()))
|
|
|
+ return spAxis;
|
|
|
+ else if (mAxisPainter->tickLabelsSelectionBox().contains(pos.toPoint()))
|
|
|
+ return spTickLabels;
|
|
|
+ else if (mAxisPainter->labelSelectionBox().contains(pos.toPoint()))
|
|
|
+ return spAxisLabel;
|
|
|
+ else
|
|
|
+ return spNone;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+double QCPAxis::selectTest(const QPointF &pos, bool onlySelectable, QVariant *details) const
|
|
|
+{
|
|
|
+ if (!mParentPlot) return -1;
|
|
|
+ SelectablePart part = getPartAt(pos);
|
|
|
+ if ((onlySelectable && !mSelectableParts.testFlag(part)) || part == spNone)
|
|
|
+ return -1;
|
|
|
+
|
|
|
+ if (details)
|
|
|
+ details->setValue(part);
|
|
|
+ return mParentPlot->selectionTolerance()*0.99;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns a list of all the plottables that have this axis as key or value axis.
|
|
|
+
|
|
|
+ If you are only interested in plottables of type QCPGraph, see \ref graphs.
|
|
|
+
|
|
|
+ \see graphs, items
|
|
|
+*/
|
|
|
+QList<QCPAbstractPlottable*> QCPAxis::plottables() const
|
|
|
+{
|
|
|
+ QList<QCPAbstractPlottable*> result;
|
|
|
+ if (!mParentPlot) return result;
|
|
|
+
|
|
|
+ for (int i=0; i<mParentPlot->mPlottables.size(); ++i)
|
|
|
+ {
|
|
|
+ if (mParentPlot->mPlottables.at(i)->keyAxis() == this ||mParentPlot->mPlottables.at(i)->valueAxis() == this)
|
|
|
+ result.append(mParentPlot->mPlottables.at(i));
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns a list of all the graphs that have this axis as key or value axis.
|
|
|
+
|
|
|
+ \see plottables, items
|
|
|
+*/
|
|
|
+QList<QCPGraph*> QCPAxis::graphs() const
|
|
|
+{
|
|
|
+ QList<QCPGraph*> result;
|
|
|
+ if (!mParentPlot) return result;
|
|
|
+
|
|
|
+ for (int i=0; i<mParentPlot->mGraphs.size(); ++i)
|
|
|
+ {
|
|
|
+ if (mParentPlot->mGraphs.at(i)->keyAxis() == this || mParentPlot->mGraphs.at(i)->valueAxis() == this)
|
|
|
+ result.append(mParentPlot->mGraphs.at(i));
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns a list of all the items that are associated with this axis. An item is considered
|
|
|
+ associated with an axis if at least one of its positions uses the axis as key or value axis.
|
|
|
+
|
|
|
+ \see plottables, graphs
|
|
|
+*/
|
|
|
+QList<QCPAbstractItem*> QCPAxis::items() const
|
|
|
+{
|
|
|
+ QList<QCPAbstractItem*> result;
|
|
|
+ if (!mParentPlot) return result;
|
|
|
+
|
|
|
+ for (int itemId=0; itemId<mParentPlot->mItems.size(); ++itemId)
|
|
|
+ {
|
|
|
+ QList<QCPItemPosition*> positions = mParentPlot->mItems.at(itemId)->positions();
|
|
|
+ for (int posId=0; posId<positions.size(); ++posId)
|
|
|
+ {
|
|
|
+ if (positions.at(posId)->keyAxis() == this || positions.at(posId)->valueAxis() == this)
|
|
|
+ {
|
|
|
+ result.append(mParentPlot->mItems.at(itemId));
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Transforms a margin side to the logically corresponding axis type. (QCP::msLeft to
|
|
|
+ QCPAxis::atLeft, QCP::msRight to QCPAxis::atRight, etc.)
|
|
|
+*/
|
|
|
+QCPAxis::AxisType QCPAxis::marginSideToAxisType(QCP::MarginSide side)
|
|
|
+{
|
|
|
+ switch (side)
|
|
|
+ {
|
|
|
+ case QCP::msLeft: return atLeft;
|
|
|
+ case QCP::msRight: return atRight;
|
|
|
+ case QCP::msTop: return atTop;
|
|
|
+ case QCP::msBottom: return atBottom;
|
|
|
+ default: break;
|
|
|
+ }
|
|
|
+ qDebug() << Q_FUNC_INFO << "Invalid margin side passed:" << (int)side;
|
|
|
+ return atLeft;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns the axis type that describes the opposite axis of an axis with the specified \a type.
|
|
|
+*/
|
|
|
+QCPAxis::AxisType QCPAxis::opposite(QCPAxis::AxisType type)
|
|
|
+{
|
|
|
+ switch (type)
|
|
|
+ {
|
|
|
+ case atLeft: return atRight; break;
|
|
|
+ case atRight: return atLeft; break;
|
|
|
+ case atBottom: return atTop; break;
|
|
|
+ case atTop: return atBottom; break;
|
|
|
+ default: qDebug() << Q_FUNC_INFO << "invalid axis type"; return atLeft; break;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPAxis::selectEvent(QMouseEvent *event, bool additive, const QVariant &details, bool *selectionStateChanged)
|
|
|
+{
|
|
|
+ Q_UNUSED(event)
|
|
|
+ SelectablePart part = details.value<SelectablePart>();
|
|
|
+ if (mSelectableParts.testFlag(part))
|
|
|
+ {
|
|
|
+ SelectableParts selBefore = mSelectedParts;
|
|
|
+ setSelectedParts(additive ? mSelectedParts^part : part);
|
|
|
+ if (selectionStateChanged)
|
|
|
+ *selectionStateChanged = mSelectedParts != selBefore;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPAxis::deselectEvent(bool *selectionStateChanged)
|
|
|
+{
|
|
|
+ SelectableParts selBefore = mSelectedParts;
|
|
|
+ setSelectedParts(mSelectedParts & ~mSelectableParts);
|
|
|
+ if (selectionStateChanged)
|
|
|
+ *selectionStateChanged = mSelectedParts != selBefore;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ This mouse event reimplementation provides the functionality to let the user drag individual axes
|
|
|
+ exclusively, by startig the drag on top of the axis.
|
|
|
+
|
|
|
+ For the axis to accept this event and perform the single axis drag, the parent \ref QCPAxisRect
|
|
|
+ must be configured accordingly, i.e. it must allow range dragging in the orientation of this axis
|
|
|
+ (\ref QCPAxisRect::setRangeDrag) and this axis must be a draggable axis (\ref
|
|
|
+ QCPAxisRect::setRangeDragAxes)
|
|
|
+
|
|
|
+ \seebaseclassmethod
|
|
|
+
|
|
|
+ \note The dragging of possibly multiple axes at once by starting the drag anywhere in the axis
|
|
|
+ rect is handled by the axis rect's mouse event, e.g. \ref QCPAxisRect::mousePressEvent.
|
|
|
+*/
|
|
|
+void QCPAxis::mousePressEvent(QMouseEvent *event, const QVariant &details)
|
|
|
+{
|
|
|
+ Q_UNUSED(details)
|
|
|
+ if (!mParentPlot->interactions().testFlag(QCP::iRangeDrag) ||
|
|
|
+ !mAxisRect->rangeDrag().testFlag(orientation()) ||
|
|
|
+ !mAxisRect->rangeDragAxes(orientation()).contains(this))
|
|
|
+ {
|
|
|
+ event->ignore();
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (event->buttons() & Qt::LeftButton)
|
|
|
+ {
|
|
|
+ mDragging = true;
|
|
|
+ // initialize antialiasing backup in case we start dragging:
|
|
|
+ if (mParentPlot->noAntialiasingOnDrag())
|
|
|
+ {
|
|
|
+ mAADragBackup = mParentPlot->antialiasedElements();
|
|
|
+ mNotAADragBackup = mParentPlot->notAntialiasedElements();
|
|
|
+ }
|
|
|
+ // Mouse range dragging interaction:
|
|
|
+ if (mParentPlot->interactions().testFlag(QCP::iRangeDrag))
|
|
|
+ mDragStartRange = mRange;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ This mouse event reimplementation provides the functionality to let the user drag individual axes
|
|
|
+ exclusively, by startig the drag on top of the axis.
|
|
|
+
|
|
|
+ \seebaseclassmethod
|
|
|
+
|
|
|
+ \note The dragging of possibly multiple axes at once by starting the drag anywhere in the axis
|
|
|
+ rect is handled by the axis rect's mouse event, e.g. \ref QCPAxisRect::mousePressEvent.
|
|
|
+
|
|
|
+ \see QCPAxis::mousePressEvent
|
|
|
+*/
|
|
|
+void QCPAxis::mouseMoveEvent(QMouseEvent *event, const QPointF &startPos)
|
|
|
+{
|
|
|
+ if (mDragging)
|
|
|
+ {
|
|
|
+ const double startPixel = orientation() == Qt::Horizontal ? startPos.x() : startPos.y();
|
|
|
+ const double currentPixel = orientation() == Qt::Horizontal ? event->pos().x() : event->pos().y();
|
|
|
+ if (mScaleType == QCPAxis::stLinear)
|
|
|
+ {
|
|
|
+ const double diff = pixelToCoord(startPixel) - pixelToCoord(currentPixel);
|
|
|
+ setRange(mDragStartRange.lower+diff, mDragStartRange.upper+diff);
|
|
|
+ } else if (mScaleType == QCPAxis::stLogarithmic)
|
|
|
+ {
|
|
|
+ const double diff = pixelToCoord(startPixel) / pixelToCoord(currentPixel);
|
|
|
+ setRange(mDragStartRange.lower*diff, mDragStartRange.upper*diff);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (mParentPlot->noAntialiasingOnDrag())
|
|
|
+ mParentPlot->setNotAntialiasedElements(QCP::aeAll);
|
|
|
+ mParentPlot->replot(QCustomPlot::rpQueuedReplot);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ This mouse event reimplementation provides the functionality to let the user drag individual axes
|
|
|
+ exclusively, by startig the drag on top of the axis.
|
|
|
+
|
|
|
+ \seebaseclassmethod
|
|
|
+
|
|
|
+ \note The dragging of possibly multiple axes at once by starting the drag anywhere in the axis
|
|
|
+ rect is handled by the axis rect's mouse event, e.g. \ref QCPAxisRect::mousePressEvent.
|
|
|
+
|
|
|
+ \see QCPAxis::mousePressEvent
|
|
|
+*/
|
|
|
+void QCPAxis::mouseReleaseEvent(QMouseEvent *event, const QPointF &startPos)
|
|
|
+{
|
|
|
+ Q_UNUSED(event)
|
|
|
+ Q_UNUSED(startPos)
|
|
|
+ mDragging = false;
|
|
|
+ if (mParentPlot->noAntialiasingOnDrag())
|
|
|
+ {
|
|
|
+ mParentPlot->setAntialiasedElements(mAADragBackup);
|
|
|
+ mParentPlot->setNotAntialiasedElements(mNotAADragBackup);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ This mouse event reimplementation provides the functionality to let the user zoom individual axes
|
|
|
+ exclusively, by performing the wheel event on top of the axis.
|
|
|
+
|
|
|
+ For the axis to accept this event and perform the single axis zoom, the parent \ref QCPAxisRect
|
|
|
+ must be configured accordingly, i.e. it must allow range zooming in the orientation of this axis
|
|
|
+ (\ref QCPAxisRect::setRangeZoom) and this axis must be a zoomable axis (\ref
|
|
|
+ QCPAxisRect::setRangeZoomAxes)
|
|
|
+
|
|
|
+ \seebaseclassmethod
|
|
|
+
|
|
|
+ \note The zooming of possibly multiple axes at once by performing the wheel event anywhere in the
|
|
|
+ axis rect is handled by the axis rect's mouse event, e.g. \ref QCPAxisRect::wheelEvent.
|
|
|
+*/
|
|
|
+void QCPAxis::wheelEvent(QWheelEvent *event)
|
|
|
+{
|
|
|
+ // Mouse range zooming interaction:
|
|
|
+ if (!mParentPlot->interactions().testFlag(QCP::iRangeZoom) ||
|
|
|
+ !mAxisRect->rangeZoom().testFlag(orientation()) ||
|
|
|
+ !mAxisRect->rangeZoomAxes(orientation()).contains(this))
|
|
|
+ {
|
|
|
+ event->ignore();
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ const double wheelSteps = event->delta()/120.0; // a single step delta is +/-120 usually
|
|
|
+ const double factor = qPow(mAxisRect->rangeZoomFactor(orientation()), wheelSteps);
|
|
|
+ scaleRange(factor, pixelToCoord(orientation() == Qt::Horizontal ? event->pos().x() : event->pos().y()));
|
|
|
+ mParentPlot->replot();
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ A convenience function to easily set the QPainter::Antialiased hint on the provided \a painter
|
|
|
+ before drawing axis 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.
|
|
|
+
|
|
|
+ \seebaseclassmethod
|
|
|
+
|
|
|
+ \see setAntialiased
|
|
|
+*/
|
|
|
+void QCPAxis::applyDefaultAntialiasingHint(QCPPainter *painter) const
|
|
|
+{
|
|
|
+ applyAntialiasingHint(painter, mAntialiased, QCP::aeAxes);
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Draws the axis with the specified \a painter, using the internal QCPAxisPainterPrivate instance.
|
|
|
+
|
|
|
+ \seebaseclassmethod
|
|
|
+*/
|
|
|
+void QCPAxis::draw(QCPPainter *painter)
|
|
|
+{
|
|
|
+ QVector<double> subTickPositions; // the final coordToPixel transformed vector passed to QCPAxisPainter
|
|
|
+ QVector<double> tickPositions; // the final coordToPixel transformed vector passed to QCPAxisPainter
|
|
|
+ QVector<QString> tickLabels; // the final vector passed to QCPAxisPainter
|
|
|
+ tickPositions.reserve(mTickVector.size());
|
|
|
+ tickLabels.reserve(mTickVector.size());
|
|
|
+ subTickPositions.reserve(mSubTickVector.size());
|
|
|
+
|
|
|
+ if (mTicks)
|
|
|
+ {
|
|
|
+ for (int i=0; i<mTickVector.size(); ++i)
|
|
|
+ {
|
|
|
+ tickPositions.append(coordToPixel(mTickVector.at(i)));
|
|
|
+ if (mTickLabels)
|
|
|
+ tickLabels.append(mTickVectorLabels.at(i));
|
|
|
+ }
|
|
|
+
|
|
|
+ if (mSubTicks)
|
|
|
+ {
|
|
|
+ const int subTickCount = mSubTickVector.size();
|
|
|
+ for (int i=0; i<subTickCount; ++i)
|
|
|
+ subTickPositions.append(coordToPixel(mSubTickVector.at(i)));
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // transfer all properties of this axis to QCPAxisPainterPrivate which it needs to draw the axis.
|
|
|
+ // Note that some axis painter properties are already set by direct feed-through with QCPAxis setters
|
|
|
+ mAxisPainter->type = mAxisType;
|
|
|
+ mAxisPainter->basePen = getBasePen();
|
|
|
+ mAxisPainter->labelFont = getLabelFont();
|
|
|
+ mAxisPainter->labelColor = getLabelColor();
|
|
|
+ mAxisPainter->label = mLabel;
|
|
|
+ mAxisPainter->substituteExponent = mNumberBeautifulPowers;
|
|
|
+ mAxisPainter->tickPen = getTickPen();
|
|
|
+ mAxisPainter->subTickPen = getSubTickPen();
|
|
|
+ mAxisPainter->tickLabelFont = getTickLabelFont();
|
|
|
+ mAxisPainter->tickLabelColor = getTickLabelColor();
|
|
|
+ mAxisPainter->axisRect = mAxisRect->rect();
|
|
|
+ mAxisPainter->viewportRect = mParentPlot->viewport();
|
|
|
+ mAxisPainter->abbreviateDecimalPowers = mScaleType == stLogarithmic;
|
|
|
+ mAxisPainter->reversedEndings = mRangeReversed;
|
|
|
+ mAxisPainter->tickPositions = tickPositions;
|
|
|
+ mAxisPainter->tickLabels = tickLabels;
|
|
|
+ mAxisPainter->subTickPositions = subTickPositions;
|
|
|
+ mAxisPainter->draw(painter);
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Prepares the internal tick vector, sub tick vector and tick label vector. This is done by calling
|
|
|
+ QCPAxisTicker::generate on the currently installed ticker.
|
|
|
+
|
|
|
+ If a change in the label text/count is detected, the cached axis margin is invalidated to make
|
|
|
+ sure the next margin calculation recalculates the label sizes and returns an up-to-date value.
|
|
|
+*/
|
|
|
+void QCPAxis::setupTickVectors()
|
|
|
+{
|
|
|
+ if (!mParentPlot) return;
|
|
|
+ if ((!mTicks && !mTickLabels && !mGrid->visible()) || mRange.size() <= 0) return;
|
|
|
+
|
|
|
+ QVector<QString> oldLabels = mTickVectorLabels;
|
|
|
+ mTicker->generate(mRange, mParentPlot->locale(), mNumberFormatChar, mNumberPrecision, mTickVector, mSubTicks ? &mSubTickVector : 0, mTickLabels ? &mTickVectorLabels : 0);
|
|
|
+ mCachedMarginValid &= mTickVectorLabels == oldLabels; // if labels have changed, margin might have changed, too
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the pen that is used to draw the axis base line. Depending on the selection state, this
|
|
|
+ is either mSelectedBasePen or mBasePen.
|
|
|
+*/
|
|
|
+QPen QCPAxis::getBasePen() const
|
|
|
+{
|
|
|
+ return mSelectedParts.testFlag(spAxis) ? mSelectedBasePen : mBasePen;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the pen that is used to draw the (major) ticks. Depending on the selection state, this
|
|
|
+ is either mSelectedTickPen or mTickPen.
|
|
|
+*/
|
|
|
+QPen QCPAxis::getTickPen() const
|
|
|
+{
|
|
|
+ return mSelectedParts.testFlag(spAxis) ? mSelectedTickPen : mTickPen;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the pen that is used to draw the subticks. Depending on the selection state, this
|
|
|
+ is either mSelectedSubTickPen or mSubTickPen.
|
|
|
+*/
|
|
|
+QPen QCPAxis::getSubTickPen() const
|
|
|
+{
|
|
|
+ return mSelectedParts.testFlag(spAxis) ? mSelectedSubTickPen : mSubTickPen;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the font that is used to draw the tick labels. Depending on the selection state, this
|
|
|
+ is either mSelectedTickLabelFont or mTickLabelFont.
|
|
|
+*/
|
|
|
+QFont QCPAxis::getTickLabelFont() const
|
|
|
+{
|
|
|
+ return mSelectedParts.testFlag(spTickLabels) ? mSelectedTickLabelFont : mTickLabelFont;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the font that is used to draw the axis label. Depending on the selection state, this
|
|
|
+ is either mSelectedLabelFont or mLabelFont.
|
|
|
+*/
|
|
|
+QFont QCPAxis::getLabelFont() const
|
|
|
+{
|
|
|
+ return mSelectedParts.testFlag(spAxisLabel) ? mSelectedLabelFont : mLabelFont;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the color that is used to draw the tick labels. Depending on the selection state, this
|
|
|
+ is either mSelectedTickLabelColor or mTickLabelColor.
|
|
|
+*/
|
|
|
+QColor QCPAxis::getTickLabelColor() const
|
|
|
+{
|
|
|
+ return mSelectedParts.testFlag(spTickLabels) ? mSelectedTickLabelColor : mTickLabelColor;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the color that is used to draw the axis label. Depending on the selection state, this
|
|
|
+ is either mSelectedLabelColor or mLabelColor.
|
|
|
+*/
|
|
|
+QColor QCPAxis::getLabelColor() const
|
|
|
+{
|
|
|
+ return mSelectedParts.testFlag(spAxisLabel) ? mSelectedLabelColor : mLabelColor;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the appropriate outward margin for this axis. It is needed if \ref
|
|
|
+ QCPAxisRect::setAutoMargins is set to true on the parent axis rect. An axis with axis type \ref
|
|
|
+ atLeft will return an appropriate left margin, \ref atBottom will return an appropriate bottom
|
|
|
+ margin and so forth. For the calculation, this function goes through similar steps as \ref draw,
|
|
|
+ so changing one function likely requires the modification of the other one as well.
|
|
|
+
|
|
|
+ The margin consists of the outward tick length, tick label padding, tick label size, label
|
|
|
+ padding, label size, and padding.
|
|
|
+
|
|
|
+ The margin is cached internally, so repeated calls while leaving the axis range, fonts, etc.
|
|
|
+ unchanged are very fast.
|
|
|
+*/
|
|
|
+int QCPAxis::calculateMargin()
|
|
|
+{
|
|
|
+ if (!mVisible) // if not visible, directly return 0, don't cache 0 because we can't react to setVisible in QCPAxis
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ if (mCachedMarginValid)
|
|
|
+ return mCachedMargin;
|
|
|
+
|
|
|
+ // run through similar steps as QCPAxis::draw, and calculate margin needed to fit axis and its labels
|
|
|
+ int margin = 0;
|
|
|
+
|
|
|
+ QVector<double> tickPositions; // the final coordToPixel transformed vector passed to QCPAxisPainter
|
|
|
+ QVector<QString> tickLabels; // the final vector passed to QCPAxisPainter
|
|
|
+ tickPositions.reserve(mTickVector.size());
|
|
|
+ tickLabels.reserve(mTickVector.size());
|
|
|
+
|
|
|
+ if (mTicks)
|
|
|
+ {
|
|
|
+ for (int i=0; i<mTickVector.size(); ++i)
|
|
|
+ {
|
|
|
+ tickPositions.append(coordToPixel(mTickVector.at(i)));
|
|
|
+ if (mTickLabels)
|
|
|
+ tickLabels.append(mTickVectorLabels.at(i));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ // transfer all properties of this axis to QCPAxisPainterPrivate which it needs to calculate the size.
|
|
|
+ // Note that some axis painter properties are already set by direct feed-through with QCPAxis setters
|
|
|
+ mAxisPainter->type = mAxisType;
|
|
|
+ mAxisPainter->labelFont = getLabelFont();
|
|
|
+ mAxisPainter->label = mLabel;
|
|
|
+ mAxisPainter->tickLabelFont = mTickLabelFont;
|
|
|
+ mAxisPainter->axisRect = mAxisRect->rect();
|
|
|
+ mAxisPainter->viewportRect = mParentPlot->viewport();
|
|
|
+ mAxisPainter->tickPositions = tickPositions;
|
|
|
+ mAxisPainter->tickLabels = tickLabels;
|
|
|
+ margin += mAxisPainter->size();
|
|
|
+ margin += mPadding;
|
|
|
+
|
|
|
+ mCachedMargin = margin;
|
|
|
+ mCachedMarginValid = true;
|
|
|
+ return margin;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+QCP::Interaction QCPAxis::selectionCategory() const
|
|
|
+{
|
|
|
+ return QCP::iSelectAxes;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPAxisPainterPrivate
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+/*! \class QCPAxisPainterPrivate
|
|
|
+
|
|
|
+ \internal
|
|
|
+ \brief (Private)
|
|
|
+
|
|
|
+ This is a private class and not part of the public QCustomPlot interface.
|
|
|
+
|
|
|
+ It is used by QCPAxis to do the low-level drawing of axis backbone, tick marks, tick labels and
|
|
|
+ axis label. It also buffers the labels to reduce replot times. The parameters are configured by
|
|
|
+ directly accessing the public member variables.
|
|
|
+*/
|
|
|
+
|
|
|
+/*!
|
|
|
+ Constructs a QCPAxisPainterPrivate instance. Make sure to not create a new instance on every
|
|
|
+ redraw, to utilize the caching mechanisms.
|
|
|
+*/
|
|
|
+QCPAxisPainterPrivate::QCPAxisPainterPrivate(QCustomPlot *parentPlot) :
|
|
|
+ type(QCPAxis::atLeft),
|
|
|
+ basePen(QPen(Qt::black, 0, Qt::SolidLine, Qt::SquareCap)),
|
|
|
+ lowerEnding(QCPLineEnding::esNone),
|
|
|
+ upperEnding(QCPLineEnding::esNone),
|
|
|
+ labelPadding(0),
|
|
|
+ tickLabelPadding(0),
|
|
|
+ tickLabelRotation(0),
|
|
|
+ tickLabelSide(QCPAxis::lsOutside),
|
|
|
+ substituteExponent(true),
|
|
|
+ numberMultiplyCross(false),
|
|
|
+ tickLengthIn(5),
|
|
|
+ tickLengthOut(0),
|
|
|
+ subTickLengthIn(2),
|
|
|
+ subTickLengthOut(0),
|
|
|
+ tickPen(QPen(Qt::black, 0, Qt::SolidLine, Qt::SquareCap)),
|
|
|
+ subTickPen(QPen(Qt::black, 0, Qt::SolidLine, Qt::SquareCap)),
|
|
|
+ offset(0),
|
|
|
+ abbreviateDecimalPowers(false),
|
|
|
+ reversedEndings(false),
|
|
|
+ mParentPlot(parentPlot),
|
|
|
+ mLabelCache(16) // cache at most 16 (tick) labels
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+QCPAxisPainterPrivate::~QCPAxisPainterPrivate()
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Draws the axis with the specified \a painter.
|
|
|
+
|
|
|
+ The selection boxes (mAxisSelectionBox, mTickLabelsSelectionBox, mLabelSelectionBox) are set
|
|
|
+ here, too.
|
|
|
+*/
|
|
|
+void QCPAxisPainterPrivate::draw(QCPPainter *painter)
|
|
|
+{
|
|
|
+ QByteArray newHash = generateLabelParameterHash();
|
|
|
+ if (newHash != mLabelParameterHash)
|
|
|
+ {
|
|
|
+ mLabelCache.clear();
|
|
|
+ mLabelParameterHash = newHash;
|
|
|
+ }
|
|
|
+
|
|
|
+ QPoint origin;
|
|
|
+ switch (type)
|
|
|
+ {
|
|
|
+ case QCPAxis::atLeft: origin = axisRect.bottomLeft() +QPoint(-offset, 0); break;
|
|
|
+ case QCPAxis::atRight: origin = axisRect.bottomRight()+QPoint(+offset, 0); break;
|
|
|
+ case QCPAxis::atTop: origin = axisRect.topLeft() +QPoint(0, -offset); break;
|
|
|
+ case QCPAxis::atBottom: origin = axisRect.bottomLeft() +QPoint(0, +offset); break;
|
|
|
+ }
|
|
|
+
|
|
|
+ double xCor = 0, yCor = 0; // paint system correction, for pixel exact matches (affects baselines and ticks of top/right axes)
|
|
|
+ switch (type)
|
|
|
+ {
|
|
|
+ case QCPAxis::atTop: yCor = -1; break;
|
|
|
+ case QCPAxis::atRight: xCor = 1; break;
|
|
|
+ default: break;
|
|
|
+ }
|
|
|
+ int margin = 0;
|
|
|
+ // draw baseline:
|
|
|
+ QLineF baseLine;
|
|
|
+ painter->setPen(basePen);
|
|
|
+ if (QCPAxis::orientation(type) == Qt::Horizontal)
|
|
|
+ baseLine.setPoints(origin+QPointF(xCor, yCor), origin+QPointF(axisRect.width()+xCor, yCor));
|
|
|
+ else
|
|
|
+ baseLine.setPoints(origin+QPointF(xCor, yCor), origin+QPointF(xCor, -axisRect.height()+yCor));
|
|
|
+ if (reversedEndings)
|
|
|
+ baseLine = QLineF(baseLine.p2(), baseLine.p1()); // won't make a difference for line itself, but for line endings later
|
|
|
+ painter->drawLine(baseLine);
|
|
|
+
|
|
|
+ // draw ticks:
|
|
|
+ if (!tickPositions.isEmpty())
|
|
|
+ {
|
|
|
+ painter->setPen(tickPen);
|
|
|
+ int tickDir = (type == QCPAxis::atBottom || type == QCPAxis::atRight) ? -1 : 1; // direction of ticks ("inward" is right for left axis and left for right axis)
|
|
|
+ if (QCPAxis::orientation(type) == Qt::Horizontal)
|
|
|
+ {
|
|
|
+ for (int i=0; i<tickPositions.size(); ++i)
|
|
|
+ painter->drawLine(QLineF(tickPositions.at(i)+xCor, origin.y()-tickLengthOut*tickDir+yCor, tickPositions.at(i)+xCor, origin.y()+tickLengthIn*tickDir+yCor));
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ for (int i=0; i<tickPositions.size(); ++i)
|
|
|
+ painter->drawLine(QLineF(origin.x()-tickLengthOut*tickDir+xCor, tickPositions.at(i)+yCor, origin.x()+tickLengthIn*tickDir+xCor, tickPositions.at(i)+yCor));
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // draw subticks:
|
|
|
+ if (!subTickPositions.isEmpty())
|
|
|
+ {
|
|
|
+ painter->setPen(subTickPen);
|
|
|
+ // direction of ticks ("inward" is right for left axis and left for right axis)
|
|
|
+ int tickDir = (type == QCPAxis::atBottom || type == QCPAxis::atRight) ? -1 : 1;
|
|
|
+ if (QCPAxis::orientation(type) == Qt::Horizontal)
|
|
|
+ {
|
|
|
+ for (int i=0; i<subTickPositions.size(); ++i)
|
|
|
+ painter->drawLine(QLineF(subTickPositions.at(i)+xCor, origin.y()-subTickLengthOut*tickDir+yCor, subTickPositions.at(i)+xCor, origin.y()+subTickLengthIn*tickDir+yCor));
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ for (int i=0; i<subTickPositions.size(); ++i)
|
|
|
+ painter->drawLine(QLineF(origin.x()-subTickLengthOut*tickDir+xCor, subTickPositions.at(i)+yCor, origin.x()+subTickLengthIn*tickDir+xCor, subTickPositions.at(i)+yCor));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ margin += qMax(0, qMax(tickLengthOut, subTickLengthOut));
|
|
|
+
|
|
|
+ // draw axis base endings:
|
|
|
+ bool antialiasingBackup = painter->antialiasing();
|
|
|
+ painter->setAntialiasing(true); // always want endings to be antialiased, even if base and ticks themselves aren't
|
|
|
+ painter->setBrush(QBrush(basePen.color()));
|
|
|
+ QCPVector2D baseLineVector(baseLine.dx(), baseLine.dy());
|
|
|
+ if (lowerEnding.style() != QCPLineEnding::esNone)
|
|
|
+ lowerEnding.draw(painter, QCPVector2D(baseLine.p1())-baseLineVector.normalized()*lowerEnding.realLength()*(lowerEnding.inverted()?-1:1), -baseLineVector);
|
|
|
+ if (upperEnding.style() != QCPLineEnding::esNone)
|
|
|
+ upperEnding.draw(painter, QCPVector2D(baseLine.p2())+baseLineVector.normalized()*upperEnding.realLength()*(upperEnding.inverted()?-1:1), baseLineVector);
|
|
|
+ painter->setAntialiasing(antialiasingBackup);
|
|
|
+
|
|
|
+ // tick labels:
|
|
|
+ QRect oldClipRect;
|
|
|
+ if (tickLabelSide == QCPAxis::lsInside) // if using inside labels, clip them to the axis rect
|
|
|
+ {
|
|
|
+ oldClipRect = painter->clipRegion().boundingRect();
|
|
|
+ painter->setClipRect(axisRect);
|
|
|
+ }
|
|
|
+ QSize tickLabelsSize(0, 0); // size of largest tick label, for offset calculation of axis label
|
|
|
+ if (!tickLabels.isEmpty())
|
|
|
+ {
|
|
|
+ if (tickLabelSide == QCPAxis::lsOutside)
|
|
|
+ margin += tickLabelPadding;
|
|
|
+ painter->setFont(tickLabelFont);
|
|
|
+ painter->setPen(QPen(tickLabelColor));
|
|
|
+ const int maxLabelIndex = qMin(tickPositions.size(), tickLabels.size());
|
|
|
+ int distanceToAxis = margin;
|
|
|
+ if (tickLabelSide == QCPAxis::lsInside)
|
|
|
+ distanceToAxis = -(qMax(tickLengthIn, subTickLengthIn)+tickLabelPadding);
|
|
|
+ for (int i=0; i<maxLabelIndex; ++i)
|
|
|
+ placeTickLabel(painter, tickPositions.at(i), distanceToAxis, tickLabels.at(i), &tickLabelsSize);
|
|
|
+ if (tickLabelSide == QCPAxis::lsOutside)
|
|
|
+ margin += (QCPAxis::orientation(type) == Qt::Horizontal) ? tickLabelsSize.height() : tickLabelsSize.width();
|
|
|
+ }
|
|
|
+ if (tickLabelSide == QCPAxis::lsInside)
|
|
|
+ painter->setClipRect(oldClipRect);
|
|
|
+
|
|
|
+ // axis label:
|
|
|
+ QRect labelBounds;
|
|
|
+ if (!label.isEmpty())
|
|
|
+ {
|
|
|
+ margin += labelPadding;
|
|
|
+ painter->setFont(labelFont);
|
|
|
+ painter->setPen(QPen(labelColor));
|
|
|
+ labelBounds = painter->fontMetrics().boundingRect(0, 0, 0, 0, Qt::TextDontClip, label);
|
|
|
+ if (type == QCPAxis::atLeft)
|
|
|
+ {
|
|
|
+ QTransform oldTransform = painter->transform();
|
|
|
+ painter->translate((origin.x()-margin-labelBounds.height()), origin.y());
|
|
|
+ painter->rotate(-90);
|
|
|
+ painter->drawText(0, 0, axisRect.height(), labelBounds.height(), Qt::TextDontClip | Qt::AlignCenter, label);
|
|
|
+ painter->setTransform(oldTransform);
|
|
|
+ }
|
|
|
+ else if (type == QCPAxis::atRight)
|
|
|
+ {
|
|
|
+ QTransform oldTransform = painter->transform();
|
|
|
+ painter->translate((origin.x()+margin+labelBounds.height()), origin.y()-axisRect.height());
|
|
|
+ painter->rotate(90);
|
|
|
+ painter->drawText(0, 0, axisRect.height(), labelBounds.height(), Qt::TextDontClip | Qt::AlignCenter, label);
|
|
|
+ painter->setTransform(oldTransform);
|
|
|
+ }
|
|
|
+ else if (type == QCPAxis::atTop)
|
|
|
+ painter->drawText(origin.x(), origin.y()-margin-labelBounds.height(), axisRect.width(), labelBounds.height(), Qt::TextDontClip | Qt::AlignCenter, label);
|
|
|
+ else if (type == QCPAxis::atBottom)
|
|
|
+ painter->drawText(origin.x(), origin.y()+margin, axisRect.width(), labelBounds.height(), Qt::TextDontClip | Qt::AlignCenter, label);
|
|
|
+ }
|
|
|
+
|
|
|
+ // set selection boxes:
|
|
|
+ int selectionTolerance = 0;
|
|
|
+ if (mParentPlot)
|
|
|
+ selectionTolerance = mParentPlot->selectionTolerance();
|
|
|
+ else
|
|
|
+ qDebug() << Q_FUNC_INFO << "mParentPlot is null";
|
|
|
+ int selAxisOutSize = qMax(qMax(tickLengthOut, subTickLengthOut), selectionTolerance);
|
|
|
+ int selAxisInSize = selectionTolerance;
|
|
|
+ int selTickLabelSize;
|
|
|
+ int selTickLabelOffset;
|
|
|
+ if (tickLabelSide == QCPAxis::lsOutside)
|
|
|
+ {
|
|
|
+ selTickLabelSize = (QCPAxis::orientation(type) == Qt::Horizontal ? tickLabelsSize.height() : tickLabelsSize.width());
|
|
|
+ selTickLabelOffset = qMax(tickLengthOut, subTickLengthOut)+tickLabelPadding;
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ selTickLabelSize = -(QCPAxis::orientation(type) == Qt::Horizontal ? tickLabelsSize.height() : tickLabelsSize.width());
|
|
|
+ selTickLabelOffset = -(qMax(tickLengthIn, subTickLengthIn)+tickLabelPadding);
|
|
|
+ }
|
|
|
+ int selLabelSize = labelBounds.height();
|
|
|
+ int selLabelOffset = qMax(tickLengthOut, subTickLengthOut)+(!tickLabels.isEmpty() && tickLabelSide == QCPAxis::lsOutside ? tickLabelPadding+selTickLabelSize : 0)+labelPadding;
|
|
|
+ if (type == QCPAxis::atLeft)
|
|
|
+ {
|
|
|
+ mAxisSelectionBox.setCoords(origin.x()-selAxisOutSize, axisRect.top(), origin.x()+selAxisInSize, axisRect.bottom());
|
|
|
+ mTickLabelsSelectionBox.setCoords(origin.x()-selTickLabelOffset-selTickLabelSize, axisRect.top(), origin.x()-selTickLabelOffset, axisRect.bottom());
|
|
|
+ mLabelSelectionBox.setCoords(origin.x()-selLabelOffset-selLabelSize, axisRect.top(), origin.x()-selLabelOffset, axisRect.bottom());
|
|
|
+ } else if (type == QCPAxis::atRight)
|
|
|
+ {
|
|
|
+ mAxisSelectionBox.setCoords(origin.x()-selAxisInSize, axisRect.top(), origin.x()+selAxisOutSize, axisRect.bottom());
|
|
|
+ mTickLabelsSelectionBox.setCoords(origin.x()+selTickLabelOffset+selTickLabelSize, axisRect.top(), origin.x()+selTickLabelOffset, axisRect.bottom());
|
|
|
+ mLabelSelectionBox.setCoords(origin.x()+selLabelOffset+selLabelSize, axisRect.top(), origin.x()+selLabelOffset, axisRect.bottom());
|
|
|
+ } else if (type == QCPAxis::atTop)
|
|
|
+ {
|
|
|
+ mAxisSelectionBox.setCoords(axisRect.left(), origin.y()-selAxisOutSize, axisRect.right(), origin.y()+selAxisInSize);
|
|
|
+ mTickLabelsSelectionBox.setCoords(axisRect.left(), origin.y()-selTickLabelOffset-selTickLabelSize, axisRect.right(), origin.y()-selTickLabelOffset);
|
|
|
+ mLabelSelectionBox.setCoords(axisRect.left(), origin.y()-selLabelOffset-selLabelSize, axisRect.right(), origin.y()-selLabelOffset);
|
|
|
+ } else if (type == QCPAxis::atBottom)
|
|
|
+ {
|
|
|
+ mAxisSelectionBox.setCoords(axisRect.left(), origin.y()-selAxisInSize, axisRect.right(), origin.y()+selAxisOutSize);
|
|
|
+ mTickLabelsSelectionBox.setCoords(axisRect.left(), origin.y()+selTickLabelOffset+selTickLabelSize, axisRect.right(), origin.y()+selTickLabelOffset);
|
|
|
+ mLabelSelectionBox.setCoords(axisRect.left(), origin.y()+selLabelOffset+selLabelSize, axisRect.right(), origin.y()+selLabelOffset);
|
|
|
+ }
|
|
|
+ mAxisSelectionBox = mAxisSelectionBox.normalized();
|
|
|
+ mTickLabelsSelectionBox = mTickLabelsSelectionBox.normalized();
|
|
|
+ mLabelSelectionBox = mLabelSelectionBox.normalized();
|
|
|
+ // draw hitboxes for debug purposes:
|
|
|
+ //painter->setBrush(Qt::NoBrush);
|
|
|
+ //painter->drawRects(QVector<QRect>() << mAxisSelectionBox << mTickLabelsSelectionBox << mLabelSelectionBox);
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the size ("margin" in QCPAxisRect context, so measured perpendicular to the axis backbone
|
|
|
+ direction) needed to fit the axis.
|
|
|
+*/
|
|
|
+int QCPAxisPainterPrivate::size() const
|
|
|
+{
|
|
|
+ int result = 0;
|
|
|
+
|
|
|
+ // get length of tick marks pointing outwards:
|
|
|
+ if (!tickPositions.isEmpty())
|
|
|
+ result += qMax(0, qMax(tickLengthOut, subTickLengthOut));
|
|
|
+
|
|
|
+ // calculate size of tick labels:
|
|
|
+ if (tickLabelSide == QCPAxis::lsOutside)
|
|
|
+ {
|
|
|
+ QSize tickLabelsSize(0, 0);
|
|
|
+ if (!tickLabels.isEmpty())
|
|
|
+ {
|
|
|
+ for (int i=0; i<tickLabels.size(); ++i)
|
|
|
+ getMaxTickLabelSize(tickLabelFont, tickLabels.at(i), &tickLabelsSize);
|
|
|
+ result += QCPAxis::orientation(type) == Qt::Horizontal ? tickLabelsSize.height() : tickLabelsSize.width();
|
|
|
+ result += tickLabelPadding;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // calculate size of axis label (only height needed, because left/right labels are rotated by 90 degrees):
|
|
|
+ if (!label.isEmpty())
|
|
|
+ {
|
|
|
+ QFontMetrics fontMetrics(labelFont);
|
|
|
+ QRect bounds;
|
|
|
+ bounds = fontMetrics.boundingRect(0, 0, 0, 0, Qt::TextDontClip | Qt::AlignHCenter | Qt::AlignVCenter, label);
|
|
|
+ result += bounds.height() + labelPadding;
|
|
|
+ }
|
|
|
+
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Clears the internal label cache. Upon the next \ref draw, all labels will be created new. This
|
|
|
+ method is called automatically in \ref draw, if any parameters have changed that invalidate the
|
|
|
+ cached labels, such as font, color, etc.
|
|
|
+*/
|
|
|
+void QCPAxisPainterPrivate::clearCache()
|
|
|
+{
|
|
|
+ mLabelCache.clear();
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns a hash that allows uniquely identifying whether the label parameters have changed such
|
|
|
+ that the cached labels must be refreshed (\ref clearCache). It is used in \ref draw. If the
|
|
|
+ return value of this method hasn't changed since the last redraw, the respective label parameters
|
|
|
+ haven't changed and cached labels may be used.
|
|
|
+*/
|
|
|
+QByteArray QCPAxisPainterPrivate::generateLabelParameterHash() const
|
|
|
+{
|
|
|
+ QByteArray result;
|
|
|
+ result.append(QByteArray::number(mParentPlot->bufferDevicePixelRatio()));
|
|
|
+ result.append(QByteArray::number(tickLabelRotation));
|
|
|
+ result.append(QByteArray::number((int)tickLabelSide));
|
|
|
+ result.append(QByteArray::number((int)substituteExponent));
|
|
|
+ result.append(QByteArray::number((int)numberMultiplyCross));
|
|
|
+ result.append(tickLabelColor.name().toLatin1()+QByteArray::number(tickLabelColor.alpha(), 16));
|
|
|
+ result.append(tickLabelFont.toString().toLatin1());
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Draws a single tick label with the provided \a painter, utilizing the internal label cache to
|
|
|
+ significantly speed up drawing of labels that were drawn in previous calls. The tick label is
|
|
|
+ always bound to an axis, the distance to the axis is controllable via \a distanceToAxis in
|
|
|
+ pixels. The pixel position in the axis direction is passed in the \a position parameter. Hence
|
|
|
+ for the bottom axis, \a position would indicate the horizontal pixel position (not coordinate),
|
|
|
+ at which the label should be drawn.
|
|
|
+
|
|
|
+ In order to later draw the axis label in a place that doesn't overlap with the tick labels, the
|
|
|
+ largest tick label size is needed. This is acquired by passing a \a tickLabelsSize to the \ref
|
|
|
+ drawTickLabel calls during the process of drawing all tick labels of one axis. In every call, \a
|
|
|
+ tickLabelsSize is expanded, if the drawn label exceeds the value \a tickLabelsSize currently
|
|
|
+ holds.
|
|
|
+
|
|
|
+ The label is drawn with the font and pen that are currently set on the \a painter. To draw
|
|
|
+ superscripted powers, the font is temporarily made smaller by a fixed factor (see \ref
|
|
|
+ getTickLabelData).
|
|
|
+*/
|
|
|
+void QCPAxisPainterPrivate::placeTickLabel(QCPPainter *painter, double position, int distanceToAxis, const QString &text, QSize *tickLabelsSize)
|
|
|
+{
|
|
|
+ // warning: if you change anything here, also adapt getMaxTickLabelSize() accordingly!
|
|
|
+ if (text.isEmpty()) return;
|
|
|
+ QSize finalSize;
|
|
|
+ QPointF labelAnchor;
|
|
|
+ switch (type)
|
|
|
+ {
|
|
|
+ case QCPAxis::atLeft: labelAnchor = QPointF(axisRect.left()-distanceToAxis-offset, position); break;
|
|
|
+ case QCPAxis::atRight: labelAnchor = QPointF(axisRect.right()+distanceToAxis+offset, position); break;
|
|
|
+ case QCPAxis::atTop: labelAnchor = QPointF(position, axisRect.top()-distanceToAxis-offset); break;
|
|
|
+ case QCPAxis::atBottom: labelAnchor = QPointF(position, axisRect.bottom()+distanceToAxis+offset); break;
|
|
|
+ }
|
|
|
+ if (mParentPlot->plottingHints().testFlag(QCP::phCacheLabels) && !painter->modes().testFlag(QCPPainter::pmNoCaching)) // label caching enabled
|
|
|
+ {
|
|
|
+ CachedLabel *cachedLabel = mLabelCache.take(text); // attempt to get label from cache
|
|
|
+ if (!cachedLabel) // no cached label existed, create it
|
|
|
+ {
|
|
|
+ cachedLabel = new CachedLabel;
|
|
|
+ TickLabelData labelData = getTickLabelData(painter->font(), text);
|
|
|
+ cachedLabel->offset = getTickLabelDrawOffset(labelData)+labelData.rotatedTotalBounds.topLeft();
|
|
|
+ if (!qFuzzyCompare(1.0, mParentPlot->bufferDevicePixelRatio()))
|
|
|
+ {
|
|
|
+ cachedLabel->pixmap = QPixmap(labelData.rotatedTotalBounds.size()*mParentPlot->bufferDevicePixelRatio());
|
|
|
+#ifdef QCP_DEVICEPIXELRATIO_SUPPORTED
|
|
|
+# ifdef QCP_DEVICEPIXELRATIO_FLOAT
|
|
|
+ cachedLabel->pixmap.setDevicePixelRatio(mParentPlot->devicePixelRatioF());
|
|
|
+# else
|
|
|
+ cachedLabel->pixmap.setDevicePixelRatio(mParentPlot->devicePixelRatio());
|
|
|
+# endif
|
|
|
+#endif
|
|
|
+ } else
|
|
|
+ cachedLabel->pixmap = QPixmap(labelData.rotatedTotalBounds.size());
|
|
|
+ cachedLabel->pixmap.fill(Qt::transparent);
|
|
|
+ QCPPainter cachePainter(&cachedLabel->pixmap);
|
|
|
+ cachePainter.setPen(painter->pen());
|
|
|
+ drawTickLabel(&cachePainter, -labelData.rotatedTotalBounds.topLeft().x(), -labelData.rotatedTotalBounds.topLeft().y(), labelData);
|
|
|
+ }
|
|
|
+ // if label would be partly clipped by widget border on sides, don't draw it (only for outside tick labels):
|
|
|
+ bool labelClippedByBorder = false;
|
|
|
+ if (tickLabelSide == QCPAxis::lsOutside)
|
|
|
+ {
|
|
|
+ if (QCPAxis::orientation(type) == Qt::Horizontal)
|
|
|
+ labelClippedByBorder = labelAnchor.x()+cachedLabel->offset.x()+cachedLabel->pixmap.width()/mParentPlot->bufferDevicePixelRatio() > viewportRect.right() || labelAnchor.x()+cachedLabel->offset.x() < viewportRect.left();
|
|
|
+ else
|
|
|
+ labelClippedByBorder = labelAnchor.y()+cachedLabel->offset.y()+cachedLabel->pixmap.height()/mParentPlot->bufferDevicePixelRatio() > viewportRect.bottom() || labelAnchor.y()+cachedLabel->offset.y() < viewportRect.top();
|
|
|
+ }
|
|
|
+ if (!labelClippedByBorder)
|
|
|
+ {
|
|
|
+ painter->drawPixmap(labelAnchor+cachedLabel->offset, cachedLabel->pixmap);
|
|
|
+ finalSize = cachedLabel->pixmap.size()/mParentPlot->bufferDevicePixelRatio();
|
|
|
+ }
|
|
|
+ mLabelCache.insert(text, cachedLabel); // return label to cache or insert for the first time if newly created
|
|
|
+ } else // label caching disabled, draw text directly on surface:
|
|
|
+ {
|
|
|
+ TickLabelData labelData = getTickLabelData(painter->font(), text);
|
|
|
+ QPointF finalPosition = labelAnchor + getTickLabelDrawOffset(labelData);
|
|
|
+ // if label would be partly clipped by widget border on sides, don't draw it (only for outside tick labels):
|
|
|
+ bool labelClippedByBorder = false;
|
|
|
+ if (tickLabelSide == QCPAxis::lsOutside)
|
|
|
+ {
|
|
|
+ if (QCPAxis::orientation(type) == Qt::Horizontal)
|
|
|
+ labelClippedByBorder = finalPosition.x()+(labelData.rotatedTotalBounds.width()+labelData.rotatedTotalBounds.left()) > viewportRect.right() || finalPosition.x()+labelData.rotatedTotalBounds.left() < viewportRect.left();
|
|
|
+ else
|
|
|
+ labelClippedByBorder = finalPosition.y()+(labelData.rotatedTotalBounds.height()+labelData.rotatedTotalBounds.top()) > viewportRect.bottom() || finalPosition.y()+labelData.rotatedTotalBounds.top() < viewportRect.top();
|
|
|
+ }
|
|
|
+ if (!labelClippedByBorder)
|
|
|
+ {
|
|
|
+ drawTickLabel(painter, finalPosition.x(), finalPosition.y(), labelData);
|
|
|
+ finalSize = labelData.rotatedTotalBounds.size();
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // expand passed tickLabelsSize if current tick label is larger:
|
|
|
+ if (finalSize.width() > tickLabelsSize->width())
|
|
|
+ tickLabelsSize->setWidth(finalSize.width());
|
|
|
+ if (finalSize.height() > tickLabelsSize->height())
|
|
|
+ tickLabelsSize->setHeight(finalSize.height());
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ This is a \ref placeTickLabel helper function.
|
|
|
+
|
|
|
+ Draws the tick label specified in \a labelData with \a painter at the pixel positions \a x and \a
|
|
|
+ y. This function is used by \ref placeTickLabel to create new tick labels for the cache, or to
|
|
|
+ directly draw the labels on the QCustomPlot surface when label caching is disabled, i.e. when
|
|
|
+ QCP::phCacheLabels plotting hint is not set.
|
|
|
+*/
|
|
|
+void QCPAxisPainterPrivate::drawTickLabel(QCPPainter *painter, double x, double y, const TickLabelData &labelData) const
|
|
|
+{
|
|
|
+ // backup painter settings that we're about to change:
|
|
|
+ QTransform oldTransform = painter->transform();
|
|
|
+ QFont oldFont = painter->font();
|
|
|
+
|
|
|
+ // transform painter to position/rotation:
|
|
|
+ painter->translate(x, y);
|
|
|
+ if (!qFuzzyIsNull(tickLabelRotation))
|
|
|
+ painter->rotate(tickLabelRotation);
|
|
|
+
|
|
|
+ // draw text:
|
|
|
+ if (!labelData.expPart.isEmpty()) // indicator that beautiful powers must be used
|
|
|
+ {
|
|
|
+ painter->setFont(labelData.baseFont);
|
|
|
+ painter->drawText(0, 0, 0, 0, Qt::TextDontClip, labelData.basePart);
|
|
|
+ if (!labelData.suffixPart.isEmpty())
|
|
|
+ painter->drawText(labelData.baseBounds.width()+1+labelData.expBounds.width(), 0, 0, 0, Qt::TextDontClip, labelData.suffixPart);
|
|
|
+ painter->setFont(labelData.expFont);
|
|
|
+ painter->drawText(labelData.baseBounds.width()+1, 0, labelData.expBounds.width(), labelData.expBounds.height(), Qt::TextDontClip, labelData.expPart);
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ painter->setFont(labelData.baseFont);
|
|
|
+ painter->drawText(0, 0, labelData.totalBounds.width(), labelData.totalBounds.height(), Qt::TextDontClip | Qt::AlignHCenter, labelData.basePart);
|
|
|
+ }
|
|
|
+
|
|
|
+ // reset painter settings to what it was before:
|
|
|
+ painter->setTransform(oldTransform);
|
|
|
+ painter->setFont(oldFont);
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ This is a \ref placeTickLabel helper function.
|
|
|
+
|
|
|
+ Transforms the passed \a text and \a font to a tickLabelData structure that can then be further
|
|
|
+ processed by \ref getTickLabelDrawOffset and \ref drawTickLabel. It splits the text into base and
|
|
|
+ exponent if necessary (member substituteExponent) and calculates appropriate bounding boxes.
|
|
|
+*/
|
|
|
+QCPAxisPainterPrivate::TickLabelData QCPAxisPainterPrivate::getTickLabelData(const QFont &font, const QString &text) const
|
|
|
+{
|
|
|
+ TickLabelData result;
|
|
|
+
|
|
|
+ // determine whether beautiful decimal powers should be used
|
|
|
+ bool useBeautifulPowers = false;
|
|
|
+ int ePos = -1; // first index of exponent part, text before that will be basePart, text until eLast will be expPart
|
|
|
+ int eLast = -1; // last index of exponent part, rest of text after this will be suffixPart
|
|
|
+ if (substituteExponent)
|
|
|
+ {
|
|
|
+ ePos = text.indexOf(QLatin1Char('e'));
|
|
|
+ if (ePos > 0 && text.at(ePos-1).isDigit())
|
|
|
+ {
|
|
|
+ eLast = ePos;
|
|
|
+ while (eLast+1 < text.size() && (text.at(eLast+1) == QLatin1Char('+') || text.at(eLast+1) == QLatin1Char('-') || text.at(eLast+1).isDigit()))
|
|
|
+ ++eLast;
|
|
|
+ if (eLast > ePos) // only if also to right of 'e' is a digit/+/- interpret it as beautifiable power
|
|
|
+ useBeautifulPowers = true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // calculate text bounding rects and do string preparation for beautiful decimal powers:
|
|
|
+ result.baseFont = font;
|
|
|
+ if (result.baseFont.pointSizeF() > 0) // might return -1 if specified with setPixelSize, in that case we can't do correction in next line
|
|
|
+ result.baseFont.setPointSizeF(result.baseFont.pointSizeF()+0.05); // QFontMetrics.boundingRect has a bug for exact point sizes that make the results oscillate due to internal rounding
|
|
|
+ if (useBeautifulPowers)
|
|
|
+ {
|
|
|
+ // split text into parts of number/symbol that will be drawn normally and part that will be drawn as exponent:
|
|
|
+ result.basePart = text.left(ePos);
|
|
|
+ result.suffixPart = text.mid(eLast+1); // also drawn normally but after exponent
|
|
|
+ // in log scaling, we want to turn "1*10^n" into "10^n", else add multiplication sign and decimal base:
|
|
|
+ if (abbreviateDecimalPowers && result.basePart == QLatin1String("1"))
|
|
|
+ result.basePart = QLatin1String("10");
|
|
|
+ else
|
|
|
+ result.basePart += (numberMultiplyCross ? QString(QChar(215)) : QString(QChar(183))) + QLatin1String("10");
|
|
|
+ result.expPart = text.mid(ePos+1, eLast-ePos);
|
|
|
+ // clip "+" and leading zeros off expPart:
|
|
|
+ while (result.expPart.length() > 2 && result.expPart.at(1) == QLatin1Char('0')) // length > 2 so we leave one zero when numberFormatChar is 'e'
|
|
|
+ result.expPart.remove(1, 1);
|
|
|
+ if (!result.expPart.isEmpty() && result.expPart.at(0) == QLatin1Char('+'))
|
|
|
+ result.expPart.remove(0, 1);
|
|
|
+ // prepare smaller font for exponent:
|
|
|
+ result.expFont = font;
|
|
|
+ if (result.expFont.pointSize() > 0)
|
|
|
+ result.expFont.setPointSize(result.expFont.pointSize()*0.75);
|
|
|
+ else
|
|
|
+ result.expFont.setPixelSize(result.expFont.pixelSize()*0.75);
|
|
|
+ // calculate bounding rects of base part(s), exponent part and total one:
|
|
|
+ result.baseBounds = QFontMetrics(result.baseFont).boundingRect(0, 0, 0, 0, Qt::TextDontClip, result.basePart);
|
|
|
+ result.expBounds = QFontMetrics(result.expFont).boundingRect(0, 0, 0, 0, Qt::TextDontClip, result.expPart);
|
|
|
+ if (!result.suffixPart.isEmpty())
|
|
|
+ result.suffixBounds = QFontMetrics(result.baseFont).boundingRect(0, 0, 0, 0, Qt::TextDontClip, result.suffixPart);
|
|
|
+ result.totalBounds = result.baseBounds.adjusted(0, 0, result.expBounds.width()+result.suffixBounds.width()+2, 0); // +2 consists of the 1 pixel spacing between base and exponent (see drawTickLabel) and an extra pixel to include AA
|
|
|
+ } else // useBeautifulPowers == false
|
|
|
+ {
|
|
|
+ result.basePart = text;
|
|
|
+ result.totalBounds = QFontMetrics(result.baseFont).boundingRect(0, 0, 0, 0, Qt::TextDontClip | Qt::AlignHCenter, result.basePart);
|
|
|
+ }
|
|
|
+ result.totalBounds.moveTopLeft(QPoint(0, 0)); // want bounding box aligned top left at origin, independent of how it was created, to make further processing simpler
|
|
|
+
|
|
|
+ // calculate possibly different bounding rect after rotation:
|
|
|
+ result.rotatedTotalBounds = result.totalBounds;
|
|
|
+ if (!qFuzzyIsNull(tickLabelRotation))
|
|
|
+ {
|
|
|
+ QTransform transform;
|
|
|
+ transform.rotate(tickLabelRotation);
|
|
|
+ result.rotatedTotalBounds = transform.mapRect(result.rotatedTotalBounds);
|
|
|
+ }
|
|
|
+
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ This is a \ref placeTickLabel helper function.
|
|
|
+
|
|
|
+ Calculates the offset at which the top left corner of the specified tick label shall be drawn.
|
|
|
+ The offset is relative to a point right next to the tick the label belongs to.
|
|
|
+
|
|
|
+ This function is thus responsible for e.g. centering tick labels under ticks and positioning them
|
|
|
+ appropriately when they are rotated.
|
|
|
+*/
|
|
|
+QPointF QCPAxisPainterPrivate::getTickLabelDrawOffset(const TickLabelData &labelData) const
|
|
|
+{
|
|
|
+ /*
|
|
|
+ calculate label offset from base point at tick (non-trivial, for best visual appearance): short
|
|
|
+ explanation for bottom axis: The anchor, i.e. the point in the label that is placed
|
|
|
+ horizontally under the corresponding tick is always on the label side that is closer to the
|
|
|
+ axis (e.g. the left side of the text when we're rotating clockwise). On that side, the height
|
|
|
+ is halved and the resulting point is defined the anchor. This way, a 90 degree rotated text
|
|
|
+ will be centered under the tick (i.e. displaced horizontally by half its height). At the same
|
|
|
+ time, a 45 degree rotated text will "point toward" its tick, as is typical for rotated tick
|
|
|
+ labels.
|
|
|
+ */
|
|
|
+ bool doRotation = !qFuzzyIsNull(tickLabelRotation);
|
|
|
+ bool flip = qFuzzyCompare(qAbs(tickLabelRotation), 90.0); // perfect +/-90 degree flip. Indicates vertical label centering on vertical axes.
|
|
|
+ double radians = tickLabelRotation/180.0*M_PI;
|
|
|
+ int x=0, y=0;
|
|
|
+ if ((type == QCPAxis::atLeft && tickLabelSide == QCPAxis::lsOutside) || (type == QCPAxis::atRight && tickLabelSide == QCPAxis::lsInside)) // Anchor at right side of tick label
|
|
|
+ {
|
|
|
+ if (doRotation)
|
|
|
+ {
|
|
|
+ if (tickLabelRotation > 0)
|
|
|
+ {
|
|
|
+ x = -qCos(radians)*labelData.totalBounds.width();
|
|
|
+ y = flip ? -labelData.totalBounds.width()/2.0 : -qSin(radians)*labelData.totalBounds.width()-qCos(radians)*labelData.totalBounds.height()/2.0;
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ x = -qCos(-radians)*labelData.totalBounds.width()-qSin(-radians)*labelData.totalBounds.height();
|
|
|
+ y = flip ? +labelData.totalBounds.width()/2.0 : +qSin(-radians)*labelData.totalBounds.width()-qCos(-radians)*labelData.totalBounds.height()/2.0;
|
|
|
+ }
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ x = -labelData.totalBounds.width();
|
|
|
+ y = -labelData.totalBounds.height()/2.0;
|
|
|
+ }
|
|
|
+ } else if ((type == QCPAxis::atRight && tickLabelSide == QCPAxis::lsOutside) || (type == QCPAxis::atLeft && tickLabelSide == QCPAxis::lsInside)) // Anchor at left side of tick label
|
|
|
+ {
|
|
|
+ if (doRotation)
|
|
|
+ {
|
|
|
+ if (tickLabelRotation > 0)
|
|
|
+ {
|
|
|
+ x = +qSin(radians)*labelData.totalBounds.height();
|
|
|
+ y = flip ? -labelData.totalBounds.width()/2.0 : -qCos(radians)*labelData.totalBounds.height()/2.0;
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ x = 0;
|
|
|
+ y = flip ? +labelData.totalBounds.width()/2.0 : -qCos(-radians)*labelData.totalBounds.height()/2.0;
|
|
|
+ }
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ x = 0;
|
|
|
+ y = -labelData.totalBounds.height()/2.0;
|
|
|
+ }
|
|
|
+ } else if ((type == QCPAxis::atTop && tickLabelSide == QCPAxis::lsOutside) || (type == QCPAxis::atBottom && tickLabelSide == QCPAxis::lsInside)) // Anchor at bottom side of tick label
|
|
|
+ {
|
|
|
+ if (doRotation)
|
|
|
+ {
|
|
|
+ if (tickLabelRotation > 0)
|
|
|
+ {
|
|
|
+ x = -qCos(radians)*labelData.totalBounds.width()+qSin(radians)*labelData.totalBounds.height()/2.0;
|
|
|
+ y = -qSin(radians)*labelData.totalBounds.width()-qCos(radians)*labelData.totalBounds.height();
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ x = -qSin(-radians)*labelData.totalBounds.height()/2.0;
|
|
|
+ y = -qCos(-radians)*labelData.totalBounds.height();
|
|
|
+ }
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ x = -labelData.totalBounds.width()/2.0;
|
|
|
+ y = -labelData.totalBounds.height();
|
|
|
+ }
|
|
|
+ } else if ((type == QCPAxis::atBottom && tickLabelSide == QCPAxis::lsOutside) || (type == QCPAxis::atTop && tickLabelSide == QCPAxis::lsInside)) // Anchor at top side of tick label
|
|
|
+ {
|
|
|
+ if (doRotation)
|
|
|
+ {
|
|
|
+ if (tickLabelRotation > 0)
|
|
|
+ {
|
|
|
+ x = +qSin(radians)*labelData.totalBounds.height()/2.0;
|
|
|
+ y = 0;
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ x = -qCos(-radians)*labelData.totalBounds.width()-qSin(-radians)*labelData.totalBounds.height()/2.0;
|
|
|
+ y = +qSin(-radians)*labelData.totalBounds.width();
|
|
|
+ }
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ x = -labelData.totalBounds.width()/2.0;
|
|
|
+ y = 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return QPointF(x, y);
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Simulates the steps done by \ref placeTickLabel by calculating bounding boxes of the text label
|
|
|
+ to be drawn, depending on number format etc. Since only the largest tick label is wanted for the
|
|
|
+ margin calculation, the passed \a tickLabelsSize is only expanded, if it's currently set to a
|
|
|
+ smaller width/height.
|
|
|
+*/
|
|
|
+void QCPAxisPainterPrivate::getMaxTickLabelSize(const QFont &font, const QString &text, QSize *tickLabelsSize) const
|
|
|
+{
|
|
|
+ // note: this function must return the same tick label sizes as the placeTickLabel function.
|
|
|
+ QSize finalSize;
|
|
|
+ if (mParentPlot->plottingHints().testFlag(QCP::phCacheLabels) && mLabelCache.contains(text)) // label caching enabled and have cached label
|
|
|
+ {
|
|
|
+ const CachedLabel *cachedLabel = mLabelCache.object(text);
|
|
|
+ finalSize = cachedLabel->pixmap.size()/mParentPlot->bufferDevicePixelRatio();
|
|
|
+ } else // label caching disabled or no label with this text cached:
|
|
|
+ {
|
|
|
+ TickLabelData labelData = getTickLabelData(font, text);
|
|
|
+ finalSize = labelData.rotatedTotalBounds.size();
|
|
|
+ }
|
|
|
+
|
|
|
+ // expand passed tickLabelsSize if current tick label is larger:
|
|
|
+ if (finalSize.width() > tickLabelsSize->width())
|
|
|
+ tickLabelsSize->setWidth(finalSize.width());
|
|
|
+ if (finalSize.height() > tickLabelsSize->height())
|
|
|
+ tickLabelsSize->setHeight(finalSize.height());
|
|
|
+}
|
|
|
+/* end of 'src/axis/axis.cpp' */
|
|
|
+
|
|
|
+
|
|
|
+/* including file 'src/scatterstyle.cpp', size 17450 */
|
|
|
+/* commit 9868e55d3b412f2f89766bb482fcf299e93a0988 2017-09-04 01:56:22 +0200 */
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// 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 undefined, the pen of the respective plottable will be used for drawing scatters.
|
|
|
+
|
|
|
+ If a pen was defined for this scatter style instance, and you now wish to undefine the pen, call
|
|
|
+ \ref undefinePen.
|
|
|
+
|
|
|
+ \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 in its
|
|
|
+ original size by default. To for example double the size of the path, 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)
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Copies the specified \a properties from the \a other scatter style to this scatter style.
|
|
|
+*/
|
|
|
+void QCPScatterStyle::setFromOther(const QCPScatterStyle &other, ScatterProperties properties)
|
|
|
+{
|
|
|
+ if (properties.testFlag(spPen))
|
|
|
+ {
|
|
|
+ setPen(other.pen());
|
|
|
+ if (!other.isPenDefined())
|
|
|
+ undefinePen();
|
|
|
+ }
|
|
|
+ if (properties.testFlag(spBrush))
|
|
|
+ setBrush(other.brush());
|
|
|
+ if (properties.testFlag(spSize))
|
|
|
+ setSize(other.size());
|
|
|
+ if (properties.testFlag(spShape))
|
|
|
+ {
|
|
|
+ setShape(other.shape());
|
|
|
+ if (other.shape() == ssPixmap)
|
|
|
+ setPixmap(other.pixmap());
|
|
|
+ else if (other.shape() == ssCustom)
|
|
|
+ setCustomPath(other.customPath());
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ 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>. If you have defined a pen
|
|
|
+ previously by calling this function and now wish to undefine the pen, call \ref undefinePen.
|
|
|
+
|
|
|
+ \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;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets this scatter style to have an undefined pen (see \ref isPenDefined for what an undefined pen
|
|
|
+ implies).
|
|
|
+
|
|
|
+ A call to \ref setPen will define a pen.
|
|
|
+*/
|
|
|
+void QCPScatterStyle::undefinePen()
|
|
|
+{
|
|
|
+ mPenDefined = false;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ 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, const 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:
|
|
|
+ {
|
|
|
+ QPointF lineArray[4] = {QPointF(x-w, y),
|
|
|
+ QPointF( x, y-w),
|
|
|
+ QPointF(x+w, y),
|
|
|
+ QPointF( x, y+w)};
|
|
|
+ painter->drawPolygon(lineArray, 4);
|
|
|
+ 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:
|
|
|
+ {
|
|
|
+ QPointF lineArray[3] = {QPointF(x-w, y+0.755*w),
|
|
|
+ QPointF(x+w, y+0.755*w),
|
|
|
+ QPointF( x, y-0.977*w)};
|
|
|
+ painter->drawPolygon(lineArray, 3);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case ssTriangleInverted:
|
|
|
+ {
|
|
|
+ QPointF lineArray[3] = {QPointF(x-w, y-0.755*w),
|
|
|
+ QPointF(x+w, y-0.755*w),
|
|
|
+ QPointF( x, y+0.977*w)};
|
|
|
+ painter->drawPolygon(lineArray, 3);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case ssCrossSquare:
|
|
|
+ {
|
|
|
+ painter->drawRect(QRectF(x-w, y-w, mSize, mSize));
|
|
|
+ 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));
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case ssPlusSquare:
|
|
|
+ {
|
|
|
+ painter->drawRect(QRectF(x-w, y-w, mSize, mSize));
|
|
|
+ painter->drawLine(QLineF(x-w, y, x+w*0.95, y));
|
|
|
+ painter->drawLine(QLineF( x, y+w, x, y-w));
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case ssCrossCircle:
|
|
|
+ {
|
|
|
+ painter->drawEllipse(QPointF(x, y), w, w);
|
|
|
+ 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));
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case ssPlusCircle:
|
|
|
+ {
|
|
|
+ painter->drawEllipse(QPointF(x, y), w, w);
|
|
|
+ painter->drawLine(QLineF(x-w, y, x+w, y));
|
|
|
+ painter->drawLine(QLineF( x, y+w, x, y-w));
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case ssPeace:
|
|
|
+ {
|
|
|
+ painter->drawEllipse(QPointF(x, y), w, w);
|
|
|
+ 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));
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case ssPixmap:
|
|
|
+ {
|
|
|
+ const double widthHalf = mPixmap.width()*0.5;
|
|
|
+ const double heightHalf = mPixmap.height()*0.5;
|
|
|
+#if QT_VERSION < QT_VERSION_CHECK(4, 8, 0)
|
|
|
+ const QRectF clipRect = painter->clipRegion().boundingRect().adjusted(-widthHalf, -heightHalf, widthHalf, heightHalf);
|
|
|
+#else
|
|
|
+ const QRectF clipRect = painter->clipBoundingRect().adjusted(-widthHalf, -heightHalf, widthHalf, heightHalf);
|
|
|
+#endif
|
|
|
+ if (clipRect.contains(x, y))
|
|
|
+ painter->drawPixmap(x-widthHalf, y-heightHalf, 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;
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+/* end of 'src/scatterstyle.cpp' */
|
|
|
+
|
|
|
+//amalgamation: add datacontainer.cpp
|
|
|
+
|
|
|
+/* including file 'src/plottable.cpp', size 38845 */
|
|
|
+/* commit 9868e55d3b412f2f89766bb482fcf299e93a0988 2017-09-04 01:56:22 +0200 */
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPSelectionDecorator
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+/*! \class QCPSelectionDecorator
|
|
|
+ \brief Controls how a plottable's data selection is drawn
|
|
|
+
|
|
|
+ Each \ref QCPAbstractPlottable instance has one \ref QCPSelectionDecorator (accessible via \ref
|
|
|
+ QCPAbstractPlottable::selectionDecorator) and uses it when drawing selected segments of its data.
|
|
|
+
|
|
|
+ The selection decorator controls both pen (\ref setPen) and brush (\ref setBrush), as well as the
|
|
|
+ scatter style (\ref setScatterStyle) if the plottable draws scatters. Since a \ref
|
|
|
+ QCPScatterStyle is itself composed of different properties such as color shape and size, the
|
|
|
+ decorator allows specifying exactly which of those properties shall be used for the selected data
|
|
|
+ point, via \ref setUsedScatterProperties.
|
|
|
+
|
|
|
+ A \ref QCPSelectionDecorator subclass instance can be passed to a plottable via \ref
|
|
|
+ QCPAbstractPlottable::setSelectionDecorator, allowing greater customizability of the appearance
|
|
|
+ of selected segments.
|
|
|
+
|
|
|
+ Use \ref copyFrom to easily transfer the settings of one decorator to another one. This is
|
|
|
+ especially useful since plottables take ownership of the passed selection decorator, and thus the
|
|
|
+ same decorator instance can not be passed to multiple plottables.
|
|
|
+
|
|
|
+ Selection decorators can also themselves perform drawing operations by reimplementing \ref
|
|
|
+ drawDecoration, which is called by the plottable's draw method. The base class \ref
|
|
|
+ QCPSelectionDecorator does not make use of this however. For example, \ref
|
|
|
+ QCPSelectionDecoratorBracket draws brackets around selected data segments.
|
|
|
+*/
|
|
|
+
|
|
|
+/*!
|
|
|
+ Creates a new QCPSelectionDecorator instance with default values
|
|
|
+*/
|
|
|
+QCPSelectionDecorator::QCPSelectionDecorator() :
|
|
|
+ mPen(QColor(80, 80, 255), 2.5),
|
|
|
+ mBrush(Qt::NoBrush),
|
|
|
+ mScatterStyle(),
|
|
|
+ mUsedScatterProperties(QCPScatterStyle::spNone),
|
|
|
+ mPlottable(0)
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+QCPSelectionDecorator::~QCPSelectionDecorator()
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the pen that will be used by the parent plottable to draw selected data segments.
|
|
|
+*/
|
|
|
+void QCPSelectionDecorator::setPen(const QPen &pen)
|
|
|
+{
|
|
|
+ mPen = pen;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the brush that will be used by the parent plottable to draw selected data segments.
|
|
|
+*/
|
|
|
+void QCPSelectionDecorator::setBrush(const QBrush &brush)
|
|
|
+{
|
|
|
+ mBrush = brush;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the scatter style that will be used by the parent plottable to draw scatters in selected
|
|
|
+ data segments.
|
|
|
+
|
|
|
+ \a usedProperties specifies which parts of the passed \a scatterStyle will be used by the
|
|
|
+ plottable. The used properties can also be changed via \ref setUsedScatterProperties.
|
|
|
+*/
|
|
|
+void QCPSelectionDecorator::setScatterStyle(const QCPScatterStyle &scatterStyle, QCPScatterStyle::ScatterProperties usedProperties)
|
|
|
+{
|
|
|
+ mScatterStyle = scatterStyle;
|
|
|
+ setUsedScatterProperties(usedProperties);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Use this method to define which properties of the scatter style (set via \ref setScatterStyle)
|
|
|
+ will be used for selected data segments. All properties of the scatter style that are not
|
|
|
+ specified in \a properties will remain as specified in the plottable's original scatter style.
|
|
|
+
|
|
|
+ \see QCPScatterStyle::ScatterProperty
|
|
|
+*/
|
|
|
+void QCPSelectionDecorator::setUsedScatterProperties(const QCPScatterStyle::ScatterProperties &properties)
|
|
|
+{
|
|
|
+ mUsedScatterProperties = properties;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the pen of \a painter to the pen of this selection decorator.
|
|
|
+
|
|
|
+ \see applyBrush, getFinalScatterStyle
|
|
|
+*/
|
|
|
+void QCPSelectionDecorator::applyPen(QCPPainter *painter) const
|
|
|
+{
|
|
|
+ painter->setPen(mPen);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the brush of \a painter to the brush of this selection decorator.
|
|
|
+
|
|
|
+ \see applyPen, getFinalScatterStyle
|
|
|
+*/
|
|
|
+void QCPSelectionDecorator::applyBrush(QCPPainter *painter) const
|
|
|
+{
|
|
|
+ painter->setBrush(mBrush);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns the scatter style that the parent plottable shall use for selected scatter points. The
|
|
|
+ plottable's original (unselected) scatter style must be passed as \a unselectedStyle. Depending
|
|
|
+ on the setting of \ref setUsedScatterProperties, the returned scatter style is a mixture of this
|
|
|
+ selecion decorator's scatter style (\ref setScatterStyle), and \a unselectedStyle.
|
|
|
+
|
|
|
+ \see applyPen, applyBrush, setScatterStyle
|
|
|
+*/
|
|
|
+QCPScatterStyle QCPSelectionDecorator::getFinalScatterStyle(const QCPScatterStyle &unselectedStyle) const
|
|
|
+{
|
|
|
+ QCPScatterStyle result(unselectedStyle);
|
|
|
+ result.setFromOther(mScatterStyle, mUsedScatterProperties);
|
|
|
+
|
|
|
+ // if style shall inherit pen from plottable (has no own pen defined), give it the selected
|
|
|
+ // plottable pen explicitly, so it doesn't use the unselected plottable pen when used in the
|
|
|
+ // plottable:
|
|
|
+ if (!result.isPenDefined())
|
|
|
+ result.setPen(mPen);
|
|
|
+
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Copies all properties (e.g. color, fill, scatter style) of the \a other selection decorator to
|
|
|
+ this selection decorator.
|
|
|
+*/
|
|
|
+void QCPSelectionDecorator::copyFrom(const QCPSelectionDecorator *other)
|
|
|
+{
|
|
|
+ setPen(other->pen());
|
|
|
+ setBrush(other->brush());
|
|
|
+ setScatterStyle(other->scatterStyle(), other->usedScatterProperties());
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ This method is called by all plottables' draw methods to allow custom selection decorations to be
|
|
|
+ drawn. Use the passed \a painter to perform the drawing operations. \a selection carries the data
|
|
|
+ selection for which the decoration shall be drawn.
|
|
|
+
|
|
|
+ The default base class implementation of \ref QCPSelectionDecorator has no special decoration, so
|
|
|
+ this method does nothing.
|
|
|
+*/
|
|
|
+void QCPSelectionDecorator::drawDecoration(QCPPainter *painter, QCPDataSelection selection)
|
|
|
+{
|
|
|
+ Q_UNUSED(painter)
|
|
|
+ Q_UNUSED(selection)
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ This method is called as soon as a selection decorator is associated with a plottable, by a call
|
|
|
+ to \ref QCPAbstractPlottable::setSelectionDecorator. This way the selection decorator can obtain a pointer to the plottable that uses it (e.g. to access
|
|
|
+ data points via the \ref QCPAbstractPlottable::interface1D interface).
|
|
|
+
|
|
|
+ If the selection decorator was already added to a different plottable before, this method aborts
|
|
|
+ the registration and returns false.
|
|
|
+*/
|
|
|
+bool QCPSelectionDecorator::registerWithPlottable(QCPAbstractPlottable *plottable)
|
|
|
+{
|
|
|
+ if (!mPlottable)
|
|
|
+ {
|
|
|
+ mPlottable = plottable;
|
|
|
+ return true;
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "This selection decorator is already registered with plottable:" << reinterpret_cast<quintptr>(mPlottable);
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPAbstractPlottable
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+/*! \class QCPAbstractPlottable
|
|
|
+ \brief The abstract base class for all data representing objects in a plot.
|
|
|
+
|
|
|
+ It defines a very basic interface like name, pen, brush, visibility etc. Since this class is
|
|
|
+ abstract, it can't be instantiated. Use one of the subclasses or create a subclass yourself to
|
|
|
+ create new ways of displaying data (see "Creating own plottables" below). Plottables that display
|
|
|
+ one-dimensional data (i.e. data points have a single key dimension and one or multiple values at
|
|
|
+ each key) are based off of the template subclass \ref QCPAbstractPlottable1D, see details
|
|
|
+ there.
|
|
|
+
|
|
|
+ All further specifics are in the subclasses, for example:
|
|
|
+ \li A normal graph with possibly a line and/or scatter points \ref QCPGraph
|
|
|
+ (typically created with \ref QCustomPlot::addGraph)
|
|
|
+ \li A parametric curve: \ref QCPCurve
|
|
|
+ \li A bar chart: \ref QCPBars
|
|
|
+ \li A statistical box plot: \ref QCPStatisticalBox
|
|
|
+ \li A color encoded two-dimensional map: \ref QCPColorMap
|
|
|
+ \li An OHLC/Candlestick chart: \ref QCPFinancial
|
|
|
+
|
|
|
+ \section plottables-subclassing Creating own plottables
|
|
|
+
|
|
|
+ Subclassing directly from QCPAbstractPlottable is only recommended if you wish to display
|
|
|
+ two-dimensional data like \ref QCPColorMap, i.e. two logical key dimensions and one (or more)
|
|
|
+ data dimensions. If you want to display data with only one logical key dimension, you should
|
|
|
+ rather derive from \ref QCPAbstractPlottable1D.
|
|
|
+
|
|
|
+ If subclassing QCPAbstractPlottable directly, these are the pure virtual functions you must
|
|
|
+ implement:
|
|
|
+ \li \ref selectTest
|
|
|
+ \li \ref draw
|
|
|
+ \li \ref drawLegendIcon
|
|
|
+ \li \ref getKeyRange
|
|
|
+ \li \ref getValueRange
|
|
|
+
|
|
|
+ See the documentation of those functions for what they need to do.
|
|
|
+
|
|
|
+ For drawing your plot, you can use the \ref coordsToPixels functions to translate a point in plot
|
|
|
+ coordinates to pixel coordinates. This function is quite convenient, because it takes the
|
|
|
+ orientation of the key and value axes into account for you (x and y are swapped when the key axis
|
|
|
+ is vertical and the value axis horizontal). If you are worried about performance (i.e. you need
|
|
|
+ to translate many points in a loop like QCPGraph), you can directly use \ref
|
|
|
+ QCPAxis::coordToPixel. However, you must then take care about the orientation of the axis
|
|
|
+ yourself.
|
|
|
+
|
|
|
+ Here are some important members you inherit from QCPAbstractPlottable:
|
|
|
+ <table>
|
|
|
+ <tr>
|
|
|
+ <td>QCustomPlot *\b mParentPlot</td>
|
|
|
+ <td>A pointer to the parent QCustomPlot instance. The parent plot is inferred from the axes that are passed in the constructor.</td>
|
|
|
+ </tr><tr>
|
|
|
+ <td>QString \b mName</td>
|
|
|
+ <td>The name of the plottable.</td>
|
|
|
+ </tr><tr>
|
|
|
+ <td>QPen \b mPen</td>
|
|
|
+ <td>The generic pen of the plottable. You should use this pen for the most prominent data representing lines in the plottable
|
|
|
+ (e.g QCPGraph uses this pen for its graph lines and scatters)</td>
|
|
|
+ </tr><tr>
|
|
|
+ <td>QBrush \b mBrush</td>
|
|
|
+ <td>The generic brush of the plottable. You should use this brush for the most prominent fillable structures in the plottable
|
|
|
+ (e.g. QCPGraph uses this brush to control filling under the graph)</td>
|
|
|
+ </tr><tr>
|
|
|
+ <td>QPointer<\ref QCPAxis> \b mKeyAxis, \b mValueAxis</td>
|
|
|
+ <td>The key and value axes this plottable is attached to. Call their QCPAxis::coordToPixel functions to translate coordinates
|
|
|
+ to pixels in either the key or value dimension. Make sure to check whether the pointer is null before using it. If one of
|
|
|
+ the axes is null, don't draw the plottable.</td>
|
|
|
+ </tr><tr>
|
|
|
+ <td>\ref QCPSelectionDecorator \b mSelectionDecorator</td>
|
|
|
+ <td>The currently set selection decorator which specifies how selected data of the plottable shall be drawn and decorated.
|
|
|
+ When drawing your data, you must consult this decorator for the appropriate pen/brush before drawing unselected/selected data segments.
|
|
|
+ Finally, you should call its \ref QCPSelectionDecorator::drawDecoration method at the end of your \ref draw implementation.</td>
|
|
|
+ </tr><tr>
|
|
|
+ <td>\ref QCP::SelectionType \b mSelectable</td>
|
|
|
+ <td>In which composition, if at all, this plottable's data may be selected. Enforcing this setting on the data selection is done
|
|
|
+ by QCPAbstractPlottable automatically.</td>
|
|
|
+ </tr><tr>
|
|
|
+ <td>\ref QCPDataSelection \b mSelection</td>
|
|
|
+ <td>Holds the current selection state of the plottable's data, i.e. the selected data ranges (\ref QCPDataRange).</td>
|
|
|
+ </tr>
|
|
|
+ </table>
|
|
|
+*/
|
|
|
+
|
|
|
+/* start of documentation of inline functions */
|
|
|
+
|
|
|
+/*! \fn QCPSelectionDecorator *QCPAbstractPlottable::selectionDecorator() const
|
|
|
+
|
|
|
+ Provides access to the selection decorator of this plottable. The selection decorator controls
|
|
|
+ how selected data ranges are drawn (e.g. their pen color and fill), see \ref
|
|
|
+ QCPSelectionDecorator for details.
|
|
|
+
|
|
|
+ If you wish to use an own \ref QCPSelectionDecorator subclass, pass an instance of it to \ref
|
|
|
+ setSelectionDecorator.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn bool QCPAbstractPlottable::selected() const
|
|
|
+
|
|
|
+ Returns true if there are any data points of the plottable currently selected. Use \ref selection
|
|
|
+ to retrieve the current \ref QCPDataSelection.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn QCPDataSelection QCPAbstractPlottable::selection() const
|
|
|
+
|
|
|
+ Returns a \ref QCPDataSelection encompassing all the data points that are currently selected on
|
|
|
+ this plottable.
|
|
|
+
|
|
|
+ \see selected, setSelection, setSelectable
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn virtual QCPPlottableInterface1D *QCPAbstractPlottable::interface1D()
|
|
|
+
|
|
|
+ If this plottable is a one-dimensional plottable, i.e. it implements the \ref
|
|
|
+ QCPPlottableInterface1D, returns the \a this pointer with that type. Otherwise (e.g. in the case
|
|
|
+ of a \ref QCPColorMap) returns zero.
|
|
|
+
|
|
|
+ You can use this method to gain read access to data coordinates while holding a pointer to the
|
|
|
+ abstract base class only.
|
|
|
+*/
|
|
|
+
|
|
|
+/* end of documentation of inline functions */
|
|
|
+/* start of documentation of pure virtual functions */
|
|
|
+
|
|
|
+/*! \fn void QCPAbstractPlottable::drawLegendIcon(QCPPainter *painter, const QRect &rect) const = 0
|
|
|
+ \internal
|
|
|
+
|
|
|
+ called by QCPLegend::draw (via QCPPlottableLegendItem::draw) to create a graphical representation
|
|
|
+ of this plottable inside \a rect, next to the plottable name.
|
|
|
+
|
|
|
+ The passed \a painter has its cliprect set to \a rect, so painting outside of \a rect won't
|
|
|
+ appear outside the legend icon border.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn QCPRange QCPAbstractPlottable::getKeyRange(bool &foundRange, QCP::SignDomain inSignDomain) const = 0
|
|
|
+
|
|
|
+ Returns the coordinate range that all data in this plottable span in the key axis dimension. For
|
|
|
+ logarithmic plots, one can set \a inSignDomain to either \ref QCP::sdNegative or \ref
|
|
|
+ QCP::sdPositive in order to restrict the returned range to that sign domain. E.g. when only
|
|
|
+ negative range is wanted, set \a inSignDomain to \ref QCP::sdNegative and all positive points
|
|
|
+ will be ignored for range calculation. For no restriction, just set \a inSignDomain to \ref
|
|
|
+ QCP::sdBoth (default). \a foundRange is an output parameter that indicates whether a range could
|
|
|
+ be found or not. If this is false, you shouldn't use the returned range (e.g. no points in data).
|
|
|
+
|
|
|
+ Note that \a foundRange is not the same as \ref QCPRange::validRange, since the range returned by
|
|
|
+ this function may have size zero (e.g. when there is only one data point). In this case \a
|
|
|
+ foundRange would return true, but the returned range is not a valid range in terms of \ref
|
|
|
+ QCPRange::validRange.
|
|
|
+
|
|
|
+ \see rescaleAxes, getValueRange
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn QCPRange QCPAbstractPlottable::getValueRange(bool &foundRange, QCP::SignDomain inSignDomain, const QCPRange &inKeyRange) const = 0
|
|
|
+
|
|
|
+ Returns the coordinate range that the data points in the specified key range (\a inKeyRange) span
|
|
|
+ in the value axis dimension. For logarithmic plots, one can set \a inSignDomain to either \ref
|
|
|
+ QCP::sdNegative or \ref QCP::sdPositive in order to restrict the returned range to that sign
|
|
|
+ domain. E.g. when only negative range is wanted, set \a inSignDomain to \ref QCP::sdNegative and
|
|
|
+ all positive points will be ignored for range calculation. For no restriction, just set \a
|
|
|
+ inSignDomain to \ref QCP::sdBoth (default). \a foundRange is an output parameter that indicates
|
|
|
+ whether a range could be found or not. If this is false, you shouldn't use the returned range
|
|
|
+ (e.g. no points in data).
|
|
|
+
|
|
|
+ If \a inKeyRange has both lower and upper bound set to zero (is equal to <tt>QCPRange()</tt>),
|
|
|
+ all data points are considered, without any restriction on the keys.
|
|
|
+
|
|
|
+ Note that \a foundRange is not the same as \ref QCPRange::validRange, since the range returned by
|
|
|
+ this function may have size zero (e.g. when there is only one data point). In this case \a
|
|
|
+ foundRange would return true, but the returned range is not a valid range in terms of \ref
|
|
|
+ QCPRange::validRange.
|
|
|
+
|
|
|
+ \see rescaleAxes, getKeyRange
|
|
|
+*/
|
|
|
+
|
|
|
+/* end of documentation of pure virtual functions */
|
|
|
+/* start of documentation of signals */
|
|
|
+
|
|
|
+/*! \fn void QCPAbstractPlottable::selectionChanged(bool selected)
|
|
|
+
|
|
|
+ This signal is emitted when the selection state of this plottable has changed, either by user
|
|
|
+ interaction or by a direct call to \ref setSelection. The parameter \a selected indicates whether
|
|
|
+ there are any points selected or not.
|
|
|
+
|
|
|
+ \see selectionChanged(const QCPDataSelection &selection)
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn void QCPAbstractPlottable::selectionChanged(const QCPDataSelection &selection)
|
|
|
+
|
|
|
+ This signal is emitted when the selection state of this plottable has changed, either by user
|
|
|
+ interaction or by a direct call to \ref setSelection. The parameter \a selection holds the
|
|
|
+ currently selected data ranges.
|
|
|
+
|
|
|
+ \see selectionChanged(bool selected)
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn void QCPAbstractPlottable::selectableChanged(QCP::SelectionType selectable);
|
|
|
+
|
|
|
+ This signal is emitted when the selectability of this plottable has changed.
|
|
|
+
|
|
|
+ \see setSelectable
|
|
|
+*/
|
|
|
+
|
|
|
+/* end of documentation of signals */
|
|
|
+
|
|
|
+/*!
|
|
|
+ Constructs an abstract plottable which uses \a keyAxis as its key axis ("x") and \a valueAxis as
|
|
|
+ its value axis ("y"). \a keyAxis and \a valueAxis must reside in the same QCustomPlot instance
|
|
|
+ and have perpendicular orientations. If either of these restrictions is violated, a corresponding
|
|
|
+ message is printed to the debug output (qDebug), the construction is not aborted, though.
|
|
|
+
|
|
|
+ Since QCPAbstractPlottable is an abstract class that defines the basic interface to plottables,
|
|
|
+ it can't be directly instantiated.
|
|
|
+
|
|
|
+ You probably want one of the subclasses like \ref QCPGraph or \ref QCPCurve instead.
|
|
|
+*/
|
|
|
+QCPAbstractPlottable::QCPAbstractPlottable(QCPAxis *keyAxis, QCPAxis *valueAxis) :
|
|
|
+ QCPLayerable(keyAxis->parentPlot(), QString(), keyAxis->axisRect()),
|
|
|
+ mName(),
|
|
|
+ mAntialiasedFill(true),
|
|
|
+ mAntialiasedScatters(true),
|
|
|
+ mPen(Qt::black),
|
|
|
+ mBrush(Qt::NoBrush),
|
|
|
+ mKeyAxis(keyAxis),
|
|
|
+ mValueAxis(valueAxis),
|
|
|
+ mSelectable(QCP::stWhole),
|
|
|
+ mSelectionDecorator(0)
|
|
|
+{
|
|
|
+ if (keyAxis->parentPlot() != valueAxis->parentPlot())
|
|
|
+ qDebug() << Q_FUNC_INFO << "Parent plot of keyAxis is not the same as that of valueAxis.";
|
|
|
+ if (keyAxis->orientation() == valueAxis->orientation())
|
|
|
+ qDebug() << Q_FUNC_INFO << "keyAxis and valueAxis must be orthogonal to each other.";
|
|
|
+
|
|
|
+ mParentPlot->registerPlottable(this);
|
|
|
+ setSelectionDecorator(new QCPSelectionDecorator);
|
|
|
+}
|
|
|
+
|
|
|
+QCPAbstractPlottable::~QCPAbstractPlottable()
|
|
|
+{
|
|
|
+ if (mSelectionDecorator)
|
|
|
+ {
|
|
|
+ delete mSelectionDecorator;
|
|
|
+ mSelectionDecorator = 0;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ The name is the textual representation of this plottable as it is displayed in the legend
|
|
|
+ (\ref QCPLegend). It may contain any UTF-8 characters, including newlines.
|
|
|
+*/
|
|
|
+void QCPAbstractPlottable::setName(const QString &name)
|
|
|
+{
|
|
|
+ mName = name;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets whether fills of this plottable are drawn antialiased or not.
|
|
|
+
|
|
|
+ Note that this setting may be overridden by \ref QCustomPlot::setAntialiasedElements and \ref
|
|
|
+ QCustomPlot::setNotAntialiasedElements.
|
|
|
+*/
|
|
|
+void QCPAbstractPlottable::setAntialiasedFill(bool enabled)
|
|
|
+{
|
|
|
+ mAntialiasedFill = enabled;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets whether the scatter symbols of this plottable are drawn antialiased or not.
|
|
|
+
|
|
|
+ Note that this setting may be overridden by \ref QCustomPlot::setAntialiasedElements and \ref
|
|
|
+ QCustomPlot::setNotAntialiasedElements.
|
|
|
+*/
|
|
|
+void QCPAbstractPlottable::setAntialiasedScatters(bool enabled)
|
|
|
+{
|
|
|
+ mAntialiasedScatters = enabled;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ The pen is used to draw basic lines that make up the plottable representation in the
|
|
|
+ plot.
|
|
|
+
|
|
|
+ For example, the \ref QCPGraph subclass draws its graph lines with this pen.
|
|
|
+
|
|
|
+ \see setBrush
|
|
|
+*/
|
|
|
+void QCPAbstractPlottable::setPen(const QPen &pen)
|
|
|
+{
|
|
|
+ mPen = pen;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ The brush is used to draw basic fills of the plottable representation in the
|
|
|
+ plot. The Fill can be a color, gradient or texture, see the usage of QBrush.
|
|
|
+
|
|
|
+ For example, the \ref QCPGraph subclass draws the fill under the graph with this brush, when
|
|
|
+ it's not set to Qt::NoBrush.
|
|
|
+
|
|
|
+ \see setPen
|
|
|
+*/
|
|
|
+void QCPAbstractPlottable::setBrush(const QBrush &brush)
|
|
|
+{
|
|
|
+ mBrush = brush;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ The key axis of a plottable can be set to any axis of a QCustomPlot, as long as it is orthogonal
|
|
|
+ to the plottable's value axis. This function performs no checks to make sure this is the case.
|
|
|
+ The typical mathematical choice is to use the x-axis (QCustomPlot::xAxis) as key axis and the
|
|
|
+ y-axis (QCustomPlot::yAxis) as value axis.
|
|
|
+
|
|
|
+ Normally, the key and value axes are set in the constructor of the plottable (or \ref
|
|
|
+ QCustomPlot::addGraph when working with QCPGraphs through the dedicated graph interface).
|
|
|
+
|
|
|
+ \see setValueAxis
|
|
|
+*/
|
|
|
+void QCPAbstractPlottable::setKeyAxis(QCPAxis *axis)
|
|
|
+{
|
|
|
+ mKeyAxis = axis;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ The value axis of a plottable can be set to any axis of a QCustomPlot, as long as it is
|
|
|
+ orthogonal to the plottable's key axis. This function performs no checks to make sure this is the
|
|
|
+ case. The typical mathematical choice is to use the x-axis (QCustomPlot::xAxis) as key axis and
|
|
|
+ the y-axis (QCustomPlot::yAxis) as value axis.
|
|
|
+
|
|
|
+ Normally, the key and value axes are set in the constructor of the plottable (or \ref
|
|
|
+ QCustomPlot::addGraph when working with QCPGraphs through the dedicated graph interface).
|
|
|
+
|
|
|
+ \see setKeyAxis
|
|
|
+*/
|
|
|
+void QCPAbstractPlottable::setValueAxis(QCPAxis *axis)
|
|
|
+{
|
|
|
+ mValueAxis = axis;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets which data ranges of this plottable are selected. Selected data ranges are drawn differently
|
|
|
+ (e.g. color) in the plot. This can be controlled via the selection decorator (see \ref
|
|
|
+ selectionDecorator).
|
|
|
+
|
|
|
+ The entire selection mechanism for plottables is handled automatically when \ref
|
|
|
+ QCustomPlot::setInteractions contains iSelectPlottables. You only need to call this function when
|
|
|
+ you wish to change the selection state programmatically.
|
|
|
+
|
|
|
+ Using \ref setSelectable you can further specify for each plottable whether and to which
|
|
|
+ granularity it is selectable. If \a selection is not compatible with the current \ref
|
|
|
+ QCP::SelectionType set via \ref setSelectable, the resulting selection will be adjusted
|
|
|
+ accordingly (see \ref QCPDataSelection::enforceType).
|
|
|
+
|
|
|
+ emits the \ref selectionChanged signal when \a selected is different from the previous selection state.
|
|
|
+
|
|
|
+ \see setSelectable, selectTest
|
|
|
+*/
|
|
|
+void QCPAbstractPlottable::setSelection(QCPDataSelection selection)
|
|
|
+{
|
|
|
+ selection.enforceType(mSelectable);
|
|
|
+ if (mSelection != selection)
|
|
|
+ {
|
|
|
+ mSelection = selection;
|
|
|
+ emit selectionChanged(selected());
|
|
|
+ emit selectionChanged(mSelection);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Use this method to set an own QCPSelectionDecorator (subclass) instance. This allows you to
|
|
|
+ customize the visual representation of selected data ranges further than by using the default
|
|
|
+ QCPSelectionDecorator.
|
|
|
+
|
|
|
+ The plottable takes ownership of the \a decorator.
|
|
|
+
|
|
|
+ The currently set decorator can be accessed via \ref selectionDecorator.
|
|
|
+*/
|
|
|
+void QCPAbstractPlottable::setSelectionDecorator(QCPSelectionDecorator *decorator)
|
|
|
+{
|
|
|
+ if (decorator)
|
|
|
+ {
|
|
|
+ if (decorator->registerWithPlottable(this))
|
|
|
+ {
|
|
|
+ if (mSelectionDecorator) // delete old decorator if necessary
|
|
|
+ delete mSelectionDecorator;
|
|
|
+ mSelectionDecorator = decorator;
|
|
|
+ }
|
|
|
+ } else if (mSelectionDecorator) // just clear decorator
|
|
|
+ {
|
|
|
+ delete mSelectionDecorator;
|
|
|
+ mSelectionDecorator = 0;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets whether and to which granularity this plottable can be selected.
|
|
|
+
|
|
|
+ A selection can happen by clicking on the QCustomPlot surface (When \ref
|
|
|
+ QCustomPlot::setInteractions contains \ref QCP::iSelectPlottables), by dragging a selection rect
|
|
|
+ (When \ref QCustomPlot::setSelectionRectMode is \ref QCP::srmSelect), or programmatically by
|
|
|
+ calling \ref setSelection.
|
|
|
+
|
|
|
+ \see setSelection, QCP::SelectionType
|
|
|
+*/
|
|
|
+void QCPAbstractPlottable::setSelectable(QCP::SelectionType selectable)
|
|
|
+{
|
|
|
+ if (mSelectable != selectable)
|
|
|
+ {
|
|
|
+ mSelectable = selectable;
|
|
|
+ QCPDataSelection oldSelection = mSelection;
|
|
|
+ mSelection.enforceType(mSelectable);
|
|
|
+ emit selectableChanged(mSelectable);
|
|
|
+ if (mSelection != oldSelection)
|
|
|
+ {
|
|
|
+ emit selectionChanged(selected());
|
|
|
+ emit selectionChanged(mSelection);
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+/*!
|
|
|
+ Convenience function for transforming a key/value pair to pixels on the QCustomPlot surface,
|
|
|
+ taking the orientations of the axes associated with this plottable into account (e.g. whether key
|
|
|
+ represents x or y).
|
|
|
+
|
|
|
+ \a key and \a value are transformed to the coodinates in pixels and are written to \a x and \a y.
|
|
|
+
|
|
|
+ \see pixelsToCoords, QCPAxis::coordToPixel
|
|
|
+*/
|
|
|
+void QCPAbstractPlottable::coordsToPixels(double key, double value, double &x, double &y) const
|
|
|
+{
|
|
|
+ QCPAxis *keyAxis = mKeyAxis.data();
|
|
|
+ QCPAxis *valueAxis = mValueAxis.data();
|
|
|
+ if (!keyAxis || !valueAxis) { qDebug() << Q_FUNC_INFO << "invalid key or value axis"; return; }
|
|
|
+
|
|
|
+ if (keyAxis->orientation() == Qt::Horizontal)
|
|
|
+ {
|
|
|
+ x = keyAxis->coordToPixel(key);
|
|
|
+ y = valueAxis->coordToPixel(value);
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ y = keyAxis->coordToPixel(key);
|
|
|
+ x = valueAxis->coordToPixel(value);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Transforms the given \a key and \a value to pixel coordinates and returns them in a QPointF.
|
|
|
+*/
|
|
|
+const QPointF QCPAbstractPlottable::coordsToPixels(double key, double value) const
|
|
|
+{
|
|
|
+ QCPAxis *keyAxis = mKeyAxis.data();
|
|
|
+ QCPAxis *valueAxis = mValueAxis.data();
|
|
|
+ if (!keyAxis || !valueAxis) { qDebug() << Q_FUNC_INFO << "invalid key or value axis"; return QPointF(); }
|
|
|
+
|
|
|
+ if (keyAxis->orientation() == Qt::Horizontal)
|
|
|
+ return QPointF(keyAxis->coordToPixel(key), valueAxis->coordToPixel(value));
|
|
|
+ else
|
|
|
+ return QPointF(valueAxis->coordToPixel(value), keyAxis->coordToPixel(key));
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Convenience function for transforming a x/y pixel pair on the QCustomPlot surface to plot coordinates,
|
|
|
+ taking the orientations of the axes associated with this plottable into account (e.g. whether key
|
|
|
+ represents x or y).
|
|
|
+
|
|
|
+ \a x and \a y are transformed to the plot coodinates and are written to \a key and \a value.
|
|
|
+
|
|
|
+ \see coordsToPixels, QCPAxis::coordToPixel
|
|
|
+*/
|
|
|
+void QCPAbstractPlottable::pixelsToCoords(double x, double y, double &key, double &value) const
|
|
|
+{
|
|
|
+ QCPAxis *keyAxis = mKeyAxis.data();
|
|
|
+ QCPAxis *valueAxis = mValueAxis.data();
|
|
|
+ if (!keyAxis || !valueAxis) { qDebug() << Q_FUNC_INFO << "invalid key or value axis"; return; }
|
|
|
+
|
|
|
+ if (keyAxis->orientation() == Qt::Horizontal)
|
|
|
+ {
|
|
|
+ key = keyAxis->pixelToCoord(x);
|
|
|
+ value = valueAxis->pixelToCoord(y);
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ key = keyAxis->pixelToCoord(y);
|
|
|
+ value = valueAxis->pixelToCoord(x);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Returns the pixel input \a pixelPos as plot coordinates \a key and \a value.
|
|
|
+*/
|
|
|
+void QCPAbstractPlottable::pixelsToCoords(const QPointF &pixelPos, double &key, double &value) const
|
|
|
+{
|
|
|
+ pixelsToCoords(pixelPos.x(), pixelPos.y(), key, value);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Rescales the key and value axes associated with this plottable to contain all displayed data, so
|
|
|
+ the whole plottable is visible. If the scaling of an axis is logarithmic, rescaleAxes will make
|
|
|
+ sure not to rescale to an illegal range i.e. a range containing different signs and/or zero.
|
|
|
+ Instead it will stay in the current sign domain and ignore all parts of the plottable that lie
|
|
|
+ outside of that domain.
|
|
|
+
|
|
|
+ \a onlyEnlarge makes sure the ranges are only expanded, never reduced. So it's possible to show
|
|
|
+ multiple plottables in their entirety by multiple calls to rescaleAxes where the first call has
|
|
|
+ \a onlyEnlarge set to false (the default), and all subsequent set to true.
|
|
|
+
|
|
|
+ \see rescaleKeyAxis, rescaleValueAxis, QCustomPlot::rescaleAxes, QCPAxis::rescale
|
|
|
+*/
|
|
|
+void QCPAbstractPlottable::rescaleAxes(bool onlyEnlarge) const
|
|
|
+{
|
|
|
+ rescaleKeyAxis(onlyEnlarge);
|
|
|
+ rescaleValueAxis(onlyEnlarge);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Rescales the key axis of the plottable so the whole plottable is visible.
|
|
|
+
|
|
|
+ See \ref rescaleAxes for detailed behaviour.
|
|
|
+*/
|
|
|
+void QCPAbstractPlottable::rescaleKeyAxis(bool onlyEnlarge) const
|
|
|
+{
|
|
|
+ QCPAxis *keyAxis = mKeyAxis.data();
|
|
|
+ if (!keyAxis) { qDebug() << Q_FUNC_INFO << "invalid key axis"; return; }
|
|
|
+
|
|
|
+ QCP::SignDomain signDomain = QCP::sdBoth;
|
|
|
+ if (keyAxis->scaleType() == QCPAxis::stLogarithmic)
|
|
|
+ signDomain = (keyAxis->range().upper < 0 ? QCP::sdNegative : QCP::sdPositive);
|
|
|
+
|
|
|
+ bool foundRange;
|
|
|
+ QCPRange newRange = getKeyRange(foundRange, signDomain);
|
|
|
+ if (foundRange)
|
|
|
+ {
|
|
|
+ if (onlyEnlarge)
|
|
|
+ newRange.expand(keyAxis->range());
|
|
|
+ if (!QCPRange::validRange(newRange)) // likely due to range being zero (plottable has only constant data in this axis dimension), shift current range to at least center the plottable
|
|
|
+ {
|
|
|
+ double center = (newRange.lower+newRange.upper)*0.5; // upper and lower should be equal anyway, but just to make sure, incase validRange returned false for other reason
|
|
|
+ if (keyAxis->scaleType() == QCPAxis::stLinear)
|
|
|
+ {
|
|
|
+ newRange.lower = center-keyAxis->range().size()/2.0;
|
|
|
+ newRange.upper = center+keyAxis->range().size()/2.0;
|
|
|
+ } else // scaleType() == stLogarithmic
|
|
|
+ {
|
|
|
+ newRange.lower = center/qSqrt(keyAxis->range().upper/keyAxis->range().lower);
|
|
|
+ newRange.upper = center*qSqrt(keyAxis->range().upper/keyAxis->range().lower);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ keyAxis->setRange(newRange);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Rescales the value axis of the plottable so the whole plottable is visible. If \a inKeyRange is
|
|
|
+ set to true, only the data points which are in the currently visible key axis range are
|
|
|
+ considered.
|
|
|
+
|
|
|
+ Returns true if the axis was actually scaled. This might not be the case if this plottable has an
|
|
|
+ invalid range, e.g. because it has no data points.
|
|
|
+
|
|
|
+ See \ref rescaleAxes for detailed behaviour.
|
|
|
+*/
|
|
|
+void QCPAbstractPlottable::rescaleValueAxis(bool onlyEnlarge, bool inKeyRange) const
|
|
|
+{
|
|
|
+ QCPAxis *keyAxis = mKeyAxis.data();
|
|
|
+ QCPAxis *valueAxis = mValueAxis.data();
|
|
|
+ if (!keyAxis || !valueAxis) { qDebug() << Q_FUNC_INFO << "invalid key or value axis"; return; }
|
|
|
+
|
|
|
+ QCP::SignDomain signDomain = QCP::sdBoth;
|
|
|
+ if (valueAxis->scaleType() == QCPAxis::stLogarithmic)
|
|
|
+ signDomain = (valueAxis->range().upper < 0 ? QCP::sdNegative : QCP::sdPositive);
|
|
|
+
|
|
|
+ bool foundRange;
|
|
|
+ QCPRange newRange = getValueRange(foundRange, signDomain, inKeyRange ? keyAxis->range() : QCPRange());
|
|
|
+ if (foundRange)
|
|
|
+ {
|
|
|
+ if (onlyEnlarge)
|
|
|
+ newRange.expand(valueAxis->range());
|
|
|
+ if (!QCPRange::validRange(newRange)) // likely due to range being zero (plottable has only constant data in this axis dimension), shift current range to at least center the plottable
|
|
|
+ {
|
|
|
+ double center = (newRange.lower+newRange.upper)*0.5; // upper and lower should be equal anyway, but just to make sure, incase validRange returned false for other reason
|
|
|
+ if (valueAxis->scaleType() == QCPAxis::stLinear)
|
|
|
+ {
|
|
|
+ newRange.lower = center-valueAxis->range().size()/2.0;
|
|
|
+ newRange.upper = center+valueAxis->range().size()/2.0;
|
|
|
+ } else // scaleType() == stLogarithmic
|
|
|
+ {
|
|
|
+ newRange.lower = center/qSqrt(valueAxis->range().upper/valueAxis->range().lower);
|
|
|
+ newRange.upper = center*qSqrt(valueAxis->range().upper/valueAxis->range().lower);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ valueAxis->setRange(newRange);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Adds this plottable to the specified \a legend.
|
|
|
+
|
|
|
+ Creates a QCPPlottableLegendItem which is inserted into the legend. Returns true on success, i.e.
|
|
|
+ when the legend exists and a legend item associated with this plottable isn't already in the
|
|
|
+ legend.
|
|
|
+
|
|
|
+ If the plottable needs a more specialized representation in the legend, you can create a
|
|
|
+ corresponding subclass of \ref QCPPlottableLegendItem and add it to the legend manually instead
|
|
|
+ of calling this method.
|
|
|
+
|
|
|
+ \see removeFromLegend, QCPLegend::addItem
|
|
|
+*/
|
|
|
+bool QCPAbstractPlottable::addToLegend(QCPLegend *legend)
|
|
|
+{
|
|
|
+ if (!legend)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "passed legend is null";
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ if (legend->parentPlot() != mParentPlot)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "passed legend isn't in the same QCustomPlot as this plottable";
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!legend->hasItemWithPlottable(this))
|
|
|
+ {
|
|
|
+ legend->addItem(new QCPPlottableLegendItem(legend, this));
|
|
|
+ return true;
|
|
|
+ } else
|
|
|
+ return false;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Adds this plottable to the legend of the parent QCustomPlot (\ref QCustomPlot::legend).
|
|
|
+
|
|
|
+ \see removeFromLegend
|
|
|
+*/
|
|
|
+bool QCPAbstractPlottable::addToLegend()
|
|
|
+{
|
|
|
+ if (!mParentPlot || !mParentPlot->legend)
|
|
|
+ return false;
|
|
|
+ else
|
|
|
+ return addToLegend(mParentPlot->legend);
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Removes the plottable from the specifed \a legend. This means the \ref QCPPlottableLegendItem
|
|
|
+ that is associated with this plottable is removed.
|
|
|
+
|
|
|
+ Returns true on success, i.e. if the legend exists and a legend item associated with this
|
|
|
+ plottable was found and removed.
|
|
|
+
|
|
|
+ \see addToLegend, QCPLegend::removeItem
|
|
|
+*/
|
|
|
+bool QCPAbstractPlottable::removeFromLegend(QCPLegend *legend) const
|
|
|
+{
|
|
|
+ if (!legend)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "passed legend is null";
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (QCPPlottableLegendItem *lip = legend->itemWithPlottable(this))
|
|
|
+ return legend->removeItem(lip);
|
|
|
+ else
|
|
|
+ return false;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Removes the plottable from the legend of the parent QCustomPlot.
|
|
|
+
|
|
|
+ \see addToLegend
|
|
|
+*/
|
|
|
+bool QCPAbstractPlottable::removeFromLegend() const
|
|
|
+{
|
|
|
+ if (!mParentPlot || !mParentPlot->legend)
|
|
|
+ return false;
|
|
|
+ else
|
|
|
+ return removeFromLegend(mParentPlot->legend);
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+QRect QCPAbstractPlottable::clipRect() const
|
|
|
+{
|
|
|
+ if (mKeyAxis && mValueAxis)
|
|
|
+ return mKeyAxis.data()->axisRect()->rect() & mValueAxis.data()->axisRect()->rect();
|
|
|
+ else
|
|
|
+ return QRect();
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+QCP::Interaction QCPAbstractPlottable::selectionCategory() const
|
|
|
+{
|
|
|
+ return QCP::iSelectPlottables;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ A convenience function to easily set the QPainter::Antialiased hint on the provided \a painter
|
|
|
+ before drawing plottable 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.
|
|
|
+
|
|
|
+ \seebaseclassmethod
|
|
|
+
|
|
|
+ \see setAntialiased, applyFillAntialiasingHint, applyScattersAntialiasingHint
|
|
|
+*/
|
|
|
+void QCPAbstractPlottable::applyDefaultAntialiasingHint(QCPPainter *painter) const
|
|
|
+{
|
|
|
+ applyAntialiasingHint(painter, mAntialiased, QCP::aePlottables);
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ A convenience function to easily set the QPainter::Antialiased hint on the provided \a painter
|
|
|
+ before drawing plottable fills.
|
|
|
+
|
|
|
+ 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, applyDefaultAntialiasingHint, applyScattersAntialiasingHint
|
|
|
+*/
|
|
|
+void QCPAbstractPlottable::applyFillAntialiasingHint(QCPPainter *painter) const
|
|
|
+{
|
|
|
+ applyAntialiasingHint(painter, mAntialiasedFill, QCP::aeFills);
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ A convenience function to easily set the QPainter::Antialiased hint on the provided \a painter
|
|
|
+ before drawing plottable scatter points.
|
|
|
+
|
|
|
+ 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, applyFillAntialiasingHint, applyDefaultAntialiasingHint
|
|
|
+*/
|
|
|
+void QCPAbstractPlottable::applyScattersAntialiasingHint(QCPPainter *painter) const
|
|
|
+{
|
|
|
+ applyAntialiasingHint(painter, mAntialiasedScatters, QCP::aeScatters);
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPAbstractPlottable::selectEvent(QMouseEvent *event, bool additive, const QVariant &details, bool *selectionStateChanged)
|
|
|
+{
|
|
|
+ Q_UNUSED(event)
|
|
|
+
|
|
|
+ if (mSelectable != QCP::stNone)
|
|
|
+ {
|
|
|
+ QCPDataSelection newSelection = details.value<QCPDataSelection>();
|
|
|
+ QCPDataSelection selectionBefore = mSelection;
|
|
|
+ if (additive)
|
|
|
+ {
|
|
|
+ if (mSelectable == QCP::stWhole) // in whole selection mode, we toggle to no selection even if currently unselected point was hit
|
|
|
+ {
|
|
|
+ if (selected())
|
|
|
+ setSelection(QCPDataSelection());
|
|
|
+ else
|
|
|
+ setSelection(newSelection);
|
|
|
+ } else // in all other selection modes we toggle selections of homogeneously selected/unselected segments
|
|
|
+ {
|
|
|
+ if (mSelection.contains(newSelection)) // if entire newSelection is already selected, toggle selection
|
|
|
+ setSelection(mSelection-newSelection);
|
|
|
+ else
|
|
|
+ setSelection(mSelection+newSelection);
|
|
|
+ }
|
|
|
+ } else
|
|
|
+ setSelection(newSelection);
|
|
|
+ if (selectionStateChanged)
|
|
|
+ *selectionStateChanged = mSelection != selectionBefore;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPAbstractPlottable::deselectEvent(bool *selectionStateChanged)
|
|
|
+{
|
|
|
+ if (mSelectable != QCP::stNone)
|
|
|
+ {
|
|
|
+ QCPDataSelection selectionBefore = mSelection;
|
|
|
+ setSelection(QCPDataSelection());
|
|
|
+ if (selectionStateChanged)
|
|
|
+ *selectionStateChanged = mSelection != selectionBefore;
|
|
|
+ }
|
|
|
+}
|
|
|
+/* end of 'src/plottable.cpp' */
|
|
|
+
|
|
|
+
|
|
|
+/* including file 'src/item.cpp', size 49269 */
|
|
|
+/* commit 9868e55d3b412f2f89766bb482fcf299e93a0988 2017-09-04 01:56:22 +0200 */
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPItemAnchor
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+/*! \class QCPItemAnchor
|
|
|
+ \brief An anchor of an item to which positions can be attached to.
|
|
|
+
|
|
|
+ An item (QCPAbstractItem) may have one or more anchors. Unlike QCPItemPosition, an anchor doesn't
|
|
|
+ control anything on its item, but provides a way to tie other items via their positions to the
|
|
|
+ anchor.
|
|
|
+
|
|
|
+ For example, a QCPItemRect is defined by its positions \a topLeft and \a bottomRight.
|
|
|
+ Additionally it has various anchors like \a top, \a topRight or \a bottomLeft etc. So you can
|
|
|
+ attach the \a start (which is a QCPItemPosition) of a QCPItemLine to one of the anchors by
|
|
|
+ calling QCPItemPosition::setParentAnchor on \a start, passing the wanted anchor of the
|
|
|
+ QCPItemRect. This way the start of the line will now always follow the respective anchor location
|
|
|
+ on the rect item.
|
|
|
+
|
|
|
+ Note that QCPItemPosition derives from QCPItemAnchor, so every position can also serve as an
|
|
|
+ anchor to other positions.
|
|
|
+
|
|
|
+ To learn how to provide anchors in your own item subclasses, see the subclassing section of the
|
|
|
+ QCPAbstractItem documentation.
|
|
|
+*/
|
|
|
+
|
|
|
+/* start documentation of inline functions */
|
|
|
+
|
|
|
+/*! \fn virtual QCPItemPosition *QCPItemAnchor::toQCPItemPosition()
|
|
|
+
|
|
|
+ Returns 0 if this instance is merely a QCPItemAnchor, and a valid pointer of type QCPItemPosition* if
|
|
|
+ it actually is a QCPItemPosition (which is a subclass of QCPItemAnchor).
|
|
|
+
|
|
|
+ This safe downcast functionality could also be achieved with a dynamic_cast. However, QCustomPlot avoids
|
|
|
+ dynamic_cast to work with projects that don't have RTTI support enabled (e.g. -fno-rtti flag with
|
|
|
+ gcc compiler).
|
|
|
+*/
|
|
|
+
|
|
|
+/* end documentation of inline functions */
|
|
|
+
|
|
|
+/*!
|
|
|
+ Creates a new QCPItemAnchor. You shouldn't create QCPItemAnchor instances directly, even if
|
|
|
+ you want to make a new item subclass. Use \ref QCPAbstractItem::createAnchor instead, as
|
|
|
+ explained in the subclassing section of the QCPAbstractItem documentation.
|
|
|
+*/
|
|
|
+QCPItemAnchor::QCPItemAnchor(QCustomPlot *parentPlot, QCPAbstractItem *parentItem, const QString &name, int anchorId) :
|
|
|
+ mName(name),
|
|
|
+ mParentPlot(parentPlot),
|
|
|
+ mParentItem(parentItem),
|
|
|
+ mAnchorId(anchorId)
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+QCPItemAnchor::~QCPItemAnchor()
|
|
|
+{
|
|
|
+ // unregister as parent at children:
|
|
|
+ foreach (QCPItemPosition *child, mChildrenX.toList())
|
|
|
+ {
|
|
|
+ if (child->parentAnchorX() == this)
|
|
|
+ child->setParentAnchorX(0); // this acts back on this anchor and child removes itself from mChildrenX
|
|
|
+ }
|
|
|
+ foreach (QCPItemPosition *child, mChildrenY.toList())
|
|
|
+ {
|
|
|
+ if (child->parentAnchorY() == this)
|
|
|
+ child->setParentAnchorY(0); // this acts back on this anchor and child removes itself from mChildrenY
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns the final absolute pixel position of the QCPItemAnchor on the QCustomPlot surface.
|
|
|
+
|
|
|
+ The pixel information is internally retrieved via QCPAbstractItem::anchorPixelPosition of the
|
|
|
+ parent item, QCPItemAnchor is just an intermediary.
|
|
|
+*/
|
|
|
+QPointF QCPItemAnchor::pixelPosition() const
|
|
|
+{
|
|
|
+ if (mParentItem)
|
|
|
+ {
|
|
|
+ if (mAnchorId > -1)
|
|
|
+ {
|
|
|
+ return mParentItem->anchorPixelPosition(mAnchorId);
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "no valid anchor id set:" << mAnchorId;
|
|
|
+ return QPointF();
|
|
|
+ }
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "no parent item set";
|
|
|
+ return QPointF();
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Adds \a pos to the childX list of this anchor, which keeps track of which children use this
|
|
|
+ anchor as parent anchor for the respective coordinate. This is necessary to notify the children
|
|
|
+ prior to destruction of the anchor.
|
|
|
+
|
|
|
+ Note that this function does not change the parent setting in \a pos.
|
|
|
+*/
|
|
|
+void QCPItemAnchor::addChildX(QCPItemPosition *pos)
|
|
|
+{
|
|
|
+ if (!mChildrenX.contains(pos))
|
|
|
+ mChildrenX.insert(pos);
|
|
|
+ else
|
|
|
+ qDebug() << Q_FUNC_INFO << "provided pos is child already" << reinterpret_cast<quintptr>(pos);
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Removes \a pos from the childX list of this anchor.
|
|
|
+
|
|
|
+ Note that this function does not change the parent setting in \a pos.
|
|
|
+*/
|
|
|
+void QCPItemAnchor::removeChildX(QCPItemPosition *pos)
|
|
|
+{
|
|
|
+ if (!mChildrenX.remove(pos))
|
|
|
+ qDebug() << Q_FUNC_INFO << "provided pos isn't child" << reinterpret_cast<quintptr>(pos);
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Adds \a pos to the childY list of this anchor, which keeps track of which children use this
|
|
|
+ anchor as parent anchor for the respective coordinate. This is necessary to notify the children
|
|
|
+ prior to destruction of the anchor.
|
|
|
+
|
|
|
+ Note that this function does not change the parent setting in \a pos.
|
|
|
+*/
|
|
|
+void QCPItemAnchor::addChildY(QCPItemPosition *pos)
|
|
|
+{
|
|
|
+ if (!mChildrenY.contains(pos))
|
|
|
+ mChildrenY.insert(pos);
|
|
|
+ else
|
|
|
+ qDebug() << Q_FUNC_INFO << "provided pos is child already" << reinterpret_cast<quintptr>(pos);
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Removes \a pos from the childY list of this anchor.
|
|
|
+
|
|
|
+ Note that this function does not change the parent setting in \a pos.
|
|
|
+*/
|
|
|
+void QCPItemAnchor::removeChildY(QCPItemPosition *pos)
|
|
|
+{
|
|
|
+ if (!mChildrenY.remove(pos))
|
|
|
+ qDebug() << Q_FUNC_INFO << "provided pos isn't child" << reinterpret_cast<quintptr>(pos);
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPItemPosition
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+/*! \class QCPItemPosition
|
|
|
+ \brief Manages the position of an item.
|
|
|
+
|
|
|
+ Every item has at least one public QCPItemPosition member pointer which provides ways to position the
|
|
|
+ item on the QCustomPlot surface. Some items have multiple positions, for example QCPItemRect has two:
|
|
|
+ \a topLeft and \a bottomRight.
|
|
|
+
|
|
|
+ QCPItemPosition has a type (\ref PositionType) that can be set with \ref setType. This type
|
|
|
+ defines how coordinates passed to \ref setCoords are to be interpreted, e.g. as absolute pixel
|
|
|
+ coordinates, as plot coordinates of certain axes, etc. For more advanced plots it is also
|
|
|
+ possible to assign different types per X/Y coordinate of the position (see \ref setTypeX, \ref
|
|
|
+ setTypeY). This way an item could be positioned at a fixed pixel distance from the top in the Y
|
|
|
+ direction, while following a plot coordinate in the X direction.
|
|
|
+
|
|
|
+ A QCPItemPosition may have a parent QCPItemAnchor, see \ref setParentAnchor. This way you can tie
|
|
|
+ multiple items together. If the QCPItemPosition has a parent, its coordinates (\ref setCoords)
|
|
|
+ are considered to be absolute pixels in the reference frame of the parent anchor, where (0, 0)
|
|
|
+ means directly ontop of the parent anchor. For example, You could attach the \a start position of
|
|
|
+ a QCPItemLine to the \a bottom anchor of a QCPItemText to make the starting point of the line
|
|
|
+ always be centered under the text label, no matter where the text is moved to. For more advanced
|
|
|
+ plots, it is possible to assign different parent anchors per X/Y coordinate of the position, see
|
|
|
+ \ref setParentAnchorX, \ref setParentAnchorY. This way an item could follow another item in the X
|
|
|
+ direction but stay at a fixed position in the Y direction. Or even follow item A in X, and item B
|
|
|
+ in Y.
|
|
|
+
|
|
|
+ Note that every QCPItemPosition inherits from QCPItemAnchor and thus can itself be used as parent
|
|
|
+ anchor for other positions.
|
|
|
+
|
|
|
+ To set the apparent pixel position on the QCustomPlot surface directly, use \ref setPixelPosition. This
|
|
|
+ works no matter what type this QCPItemPosition is or what parent-child situation it is in, as \ref
|
|
|
+ setPixelPosition transforms the coordinates appropriately, to make the position appear at the specified
|
|
|
+ pixel values.
|
|
|
+*/
|
|
|
+
|
|
|
+/* start documentation of inline functions */
|
|
|
+
|
|
|
+/*! \fn QCPItemPosition::PositionType *QCPItemPosition::type() const
|
|
|
+
|
|
|
+ Returns the current position type.
|
|
|
+
|
|
|
+ If different types were set for X and Y (\ref setTypeX, \ref setTypeY), this method returns the
|
|
|
+ type of the X coordinate. In that case rather use \a typeX() and \a typeY().
|
|
|
+
|
|
|
+ \see setType
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn QCPItemAnchor *QCPItemPosition::parentAnchor() const
|
|
|
+
|
|
|
+ Returns the current parent anchor.
|
|
|
+
|
|
|
+ If different parent anchors were set for X and Y (\ref setParentAnchorX, \ref setParentAnchorY),
|
|
|
+ this method returns the parent anchor of the Y coordinate. In that case rather use \a
|
|
|
+ parentAnchorX() and \a parentAnchorY().
|
|
|
+
|
|
|
+ \see setParentAnchor
|
|
|
+*/
|
|
|
+
|
|
|
+/* end documentation of inline functions */
|
|
|
+
|
|
|
+/*!
|
|
|
+ Creates a new QCPItemPosition. You shouldn't create QCPItemPosition instances directly, even if
|
|
|
+ you want to make a new item subclass. Use \ref QCPAbstractItem::createPosition instead, as
|
|
|
+ explained in the subclassing section of the QCPAbstractItem documentation.
|
|
|
+*/
|
|
|
+QCPItemPosition::QCPItemPosition(QCustomPlot *parentPlot, QCPAbstractItem *parentItem, const QString &name) :
|
|
|
+ QCPItemAnchor(parentPlot, parentItem, name),
|
|
|
+ mPositionTypeX(ptAbsolute),
|
|
|
+ mPositionTypeY(ptAbsolute),
|
|
|
+ mKey(0),
|
|
|
+ mValue(0),
|
|
|
+ mParentAnchorX(0),
|
|
|
+ mParentAnchorY(0)
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+QCPItemPosition::~QCPItemPosition()
|
|
|
+{
|
|
|
+ // unregister as parent at children:
|
|
|
+ // Note: this is done in ~QCPItemAnchor again, but it's important QCPItemPosition does it itself, because only then
|
|
|
+ // the setParentAnchor(0) call the correct QCPItemPosition::pixelPosition function instead of QCPItemAnchor::pixelPosition
|
|
|
+ foreach (QCPItemPosition *child, mChildrenX.toList())
|
|
|
+ {
|
|
|
+ if (child->parentAnchorX() == this)
|
|
|
+ child->setParentAnchorX(0); // this acts back on this anchor and child removes itself from mChildrenX
|
|
|
+ }
|
|
|
+ foreach (QCPItemPosition *child, mChildrenY.toList())
|
|
|
+ {
|
|
|
+ if (child->parentAnchorY() == this)
|
|
|
+ child->setParentAnchorY(0); // this acts back on this anchor and child removes itself from mChildrenY
|
|
|
+ }
|
|
|
+ // unregister as child in parent:
|
|
|
+ if (mParentAnchorX)
|
|
|
+ mParentAnchorX->removeChildX(this);
|
|
|
+ if (mParentAnchorY)
|
|
|
+ mParentAnchorY->removeChildY(this);
|
|
|
+}
|
|
|
+
|
|
|
+/* can't make this a header inline function, because QPointer breaks with forward declared types, see QTBUG-29588 */
|
|
|
+QCPAxisRect *QCPItemPosition::axisRect() const
|
|
|
+{
|
|
|
+ return mAxisRect.data();
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the type of the position. The type defines how the coordinates passed to \ref setCoords
|
|
|
+ should be handled and how the QCPItemPosition should behave in the plot.
|
|
|
+
|
|
|
+ The possible values for \a type can be separated in two main categories:
|
|
|
+
|
|
|
+ \li The position is regarded as a point in plot coordinates. This corresponds to \ref ptPlotCoords
|
|
|
+ and requires two axes that define the plot coordinate system. They can be specified with \ref setAxes.
|
|
|
+ By default, the QCustomPlot's x- and yAxis are used.
|
|
|
+
|
|
|
+ \li The position is fixed on the QCustomPlot surface, i.e. independent of axis ranges. This
|
|
|
+ corresponds to all other types, i.e. \ref ptAbsolute, \ref ptViewportRatio and \ref
|
|
|
+ ptAxisRectRatio. They differ only in the way the absolute position is described, see the
|
|
|
+ documentation of \ref PositionType for details. For \ref ptAxisRectRatio, note that you can specify
|
|
|
+ the axis rect with \ref setAxisRect. By default this is set to the main axis rect.
|
|
|
+
|
|
|
+ Note that the position type \ref ptPlotCoords is only available (and sensible) when the position
|
|
|
+ has no parent anchor (\ref setParentAnchor).
|
|
|
+
|
|
|
+ If the type is changed, the apparent pixel position on the plot is preserved. This means
|
|
|
+ the coordinates as retrieved with coords() and set with \ref setCoords may change in the process.
|
|
|
+
|
|
|
+ This method sets the type for both X and Y directions. It is also possible to set different types
|
|
|
+ for X and Y, see \ref setTypeX, \ref setTypeY.
|
|
|
+*/
|
|
|
+void QCPItemPosition::setType(QCPItemPosition::PositionType type)
|
|
|
+{
|
|
|
+ setTypeX(type);
|
|
|
+ setTypeY(type);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ This method sets the position type of the X coordinate to \a type.
|
|
|
+
|
|
|
+ For a detailed description of what a position type is, see the documentation of \ref setType.
|
|
|
+
|
|
|
+ \see setType, setTypeY
|
|
|
+*/
|
|
|
+void QCPItemPosition::setTypeX(QCPItemPosition::PositionType type)
|
|
|
+{
|
|
|
+ if (mPositionTypeX != type)
|
|
|
+ {
|
|
|
+ // if switching from or to coordinate type that isn't valid (e.g. because axes or axis rect
|
|
|
+ // were deleted), don't try to recover the pixelPosition() because it would output a qDebug warning.
|
|
|
+ bool retainPixelPosition = true;
|
|
|
+ if ((mPositionTypeX == ptPlotCoords || type == ptPlotCoords) && (!mKeyAxis || !mValueAxis))
|
|
|
+ retainPixelPosition = false;
|
|
|
+ if ((mPositionTypeX == ptAxisRectRatio || type == ptAxisRectRatio) && (!mAxisRect))
|
|
|
+ retainPixelPosition = false;
|
|
|
+
|
|
|
+ QPointF pixel;
|
|
|
+ if (retainPixelPosition)
|
|
|
+ pixel = pixelPosition();
|
|
|
+
|
|
|
+ mPositionTypeX = type;
|
|
|
+
|
|
|
+ if (retainPixelPosition)
|
|
|
+ setPixelPosition(pixel);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ This method sets the position type of the Y coordinate to \a type.
|
|
|
+
|
|
|
+ For a detailed description of what a position type is, see the documentation of \ref setType.
|
|
|
+
|
|
|
+ \see setType, setTypeX
|
|
|
+*/
|
|
|
+void QCPItemPosition::setTypeY(QCPItemPosition::PositionType type)
|
|
|
+{
|
|
|
+ if (mPositionTypeY != type)
|
|
|
+ {
|
|
|
+ // if switching from or to coordinate type that isn't valid (e.g. because axes or axis rect
|
|
|
+ // were deleted), don't try to recover the pixelPosition() because it would output a qDebug warning.
|
|
|
+ bool retainPixelPosition = true;
|
|
|
+ if ((mPositionTypeY == ptPlotCoords || type == ptPlotCoords) && (!mKeyAxis || !mValueAxis))
|
|
|
+ retainPixelPosition = false;
|
|
|
+ if ((mPositionTypeY == ptAxisRectRatio || type == ptAxisRectRatio) && (!mAxisRect))
|
|
|
+ retainPixelPosition = false;
|
|
|
+
|
|
|
+ QPointF pixel;
|
|
|
+ if (retainPixelPosition)
|
|
|
+ pixel = pixelPosition();
|
|
|
+
|
|
|
+ mPositionTypeY = type;
|
|
|
+
|
|
|
+ if (retainPixelPosition)
|
|
|
+ setPixelPosition(pixel);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the parent of this QCPItemPosition to \a parentAnchor. This means the position will now
|
|
|
+ follow any position changes of the anchor. The local coordinate system of positions with a parent
|
|
|
+ anchor always is absolute pixels, with (0, 0) being exactly on top of the parent anchor. (Hence
|
|
|
+ the type shouldn't be set to \ref ptPlotCoords for positions with parent anchors.)
|
|
|
+
|
|
|
+ if \a keepPixelPosition is true, the current pixel position of the QCPItemPosition is preserved
|
|
|
+ during reparenting. If it's set to false, the coordinates are set to (0, 0), i.e. the position
|
|
|
+ will be exactly on top of the parent anchor.
|
|
|
+
|
|
|
+ To remove this QCPItemPosition from any parent anchor, set \a parentAnchor to 0.
|
|
|
+
|
|
|
+ If the QCPItemPosition previously had no parent and the type is \ref ptPlotCoords, the type is
|
|
|
+ set to \ref ptAbsolute, to keep the position in a valid state.
|
|
|
+
|
|
|
+ This method sets the parent anchor for both X and Y directions. It is also possible to set
|
|
|
+ different parents for X and Y, see \ref setParentAnchorX, \ref setParentAnchorY.
|
|
|
+*/
|
|
|
+bool QCPItemPosition::setParentAnchor(QCPItemAnchor *parentAnchor, bool keepPixelPosition)
|
|
|
+{
|
|
|
+ bool successX = setParentAnchorX(parentAnchor, keepPixelPosition);
|
|
|
+ bool successY = setParentAnchorY(parentAnchor, keepPixelPosition);
|
|
|
+ return successX && successY;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ This method sets the parent anchor of the X coordinate to \a parentAnchor.
|
|
|
+
|
|
|
+ For a detailed description of what a parent anchor is, see the documentation of \ref setParentAnchor.
|
|
|
+
|
|
|
+ \see setParentAnchor, setParentAnchorY
|
|
|
+*/
|
|
|
+bool QCPItemPosition::setParentAnchorX(QCPItemAnchor *parentAnchor, bool keepPixelPosition)
|
|
|
+{
|
|
|
+ // make sure self is not assigned as parent:
|
|
|
+ if (parentAnchor == this)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "can't set self as parent anchor" << reinterpret_cast<quintptr>(parentAnchor);
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ // make sure no recursive parent-child-relationships are created:
|
|
|
+ QCPItemAnchor *currentParent = parentAnchor;
|
|
|
+ while (currentParent)
|
|
|
+ {
|
|
|
+ if (QCPItemPosition *currentParentPos = currentParent->toQCPItemPosition())
|
|
|
+ {
|
|
|
+ // is a QCPItemPosition, might have further parent, so keep iterating
|
|
|
+ if (currentParentPos == this)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "can't create recursive parent-child-relationship" << reinterpret_cast<quintptr>(parentAnchor);
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ currentParent = currentParentPos->parentAnchorX();
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ // is a QCPItemAnchor, can't have further parent. Now make sure the parent items aren't the
|
|
|
+ // same, to prevent a position being child of an anchor which itself depends on the position,
|
|
|
+ // because they're both on the same item:
|
|
|
+ if (currentParent->mParentItem == mParentItem)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "can't set parent to be an anchor which itself depends on this position" << reinterpret_cast<quintptr>(parentAnchor);
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // if previously no parent set and PosType is still ptPlotCoords, set to ptAbsolute:
|
|
|
+ if (!mParentAnchorX && mPositionTypeX == ptPlotCoords)
|
|
|
+ setTypeX(ptAbsolute);
|
|
|
+
|
|
|
+ // save pixel position:
|
|
|
+ QPointF pixelP;
|
|
|
+ if (keepPixelPosition)
|
|
|
+ pixelP = pixelPosition();
|
|
|
+ // unregister at current parent anchor:
|
|
|
+ if (mParentAnchorX)
|
|
|
+ mParentAnchorX->removeChildX(this);
|
|
|
+ // register at new parent anchor:
|
|
|
+ if (parentAnchor)
|
|
|
+ parentAnchor->addChildX(this);
|
|
|
+ mParentAnchorX = parentAnchor;
|
|
|
+ // restore pixel position under new parent:
|
|
|
+ if (keepPixelPosition)
|
|
|
+ setPixelPosition(pixelP);
|
|
|
+ else
|
|
|
+ setCoords(0, coords().y());
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ This method sets the parent anchor of the Y coordinate to \a parentAnchor.
|
|
|
+
|
|
|
+ For a detailed description of what a parent anchor is, see the documentation of \ref setParentAnchor.
|
|
|
+
|
|
|
+ \see setParentAnchor, setParentAnchorX
|
|
|
+*/
|
|
|
+bool QCPItemPosition::setParentAnchorY(QCPItemAnchor *parentAnchor, bool keepPixelPosition)
|
|
|
+{
|
|
|
+ // make sure self is not assigned as parent:
|
|
|
+ if (parentAnchor == this)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "can't set self as parent anchor" << reinterpret_cast<quintptr>(parentAnchor);
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ // make sure no recursive parent-child-relationships are created:
|
|
|
+ QCPItemAnchor *currentParent = parentAnchor;
|
|
|
+ while (currentParent)
|
|
|
+ {
|
|
|
+ if (QCPItemPosition *currentParentPos = currentParent->toQCPItemPosition())
|
|
|
+ {
|
|
|
+ // is a QCPItemPosition, might have further parent, so keep iterating
|
|
|
+ if (currentParentPos == this)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "can't create recursive parent-child-relationship" << reinterpret_cast<quintptr>(parentAnchor);
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ currentParent = currentParentPos->parentAnchorY();
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ // is a QCPItemAnchor, can't have further parent. Now make sure the parent items aren't the
|
|
|
+ // same, to prevent a position being child of an anchor which itself depends on the position,
|
|
|
+ // because they're both on the same item:
|
|
|
+ if (currentParent->mParentItem == mParentItem)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "can't set parent to be an anchor which itself depends on this position" << reinterpret_cast<quintptr>(parentAnchor);
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // if previously no parent set and PosType is still ptPlotCoords, set to ptAbsolute:
|
|
|
+ if (!mParentAnchorY && mPositionTypeY == ptPlotCoords)
|
|
|
+ setTypeY(ptAbsolute);
|
|
|
+
|
|
|
+ // save pixel position:
|
|
|
+ QPointF pixelP;
|
|
|
+ if (keepPixelPosition)
|
|
|
+ pixelP = pixelPosition();
|
|
|
+ // unregister at current parent anchor:
|
|
|
+ if (mParentAnchorY)
|
|
|
+ mParentAnchorY->removeChildY(this);
|
|
|
+ // register at new parent anchor:
|
|
|
+ if (parentAnchor)
|
|
|
+ parentAnchor->addChildY(this);
|
|
|
+ mParentAnchorY = parentAnchor;
|
|
|
+ // restore pixel position under new parent:
|
|
|
+ if (keepPixelPosition)
|
|
|
+ setPixelPosition(pixelP);
|
|
|
+ else
|
|
|
+ setCoords(coords().x(), 0);
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the coordinates of this QCPItemPosition. What the coordinates mean, is defined by the type
|
|
|
+ (\ref setType, \ref setTypeX, \ref setTypeY).
|
|
|
+
|
|
|
+ For example, if the type is \ref ptAbsolute, \a key and \a value mean the x and y pixel position
|
|
|
+ on the QCustomPlot surface. In that case the origin (0, 0) is in the top left corner of the
|
|
|
+ QCustomPlot viewport. If the type is \ref ptPlotCoords, \a key and \a value mean a point in the
|
|
|
+ plot coordinate system defined by the axes set by \ref setAxes. By default those are the
|
|
|
+ QCustomPlot's xAxis and yAxis. See the documentation of \ref setType for other available
|
|
|
+ coordinate types and their meaning.
|
|
|
+
|
|
|
+ If different types were configured for X and Y (\ref setTypeX, \ref setTypeY), \a key and \a
|
|
|
+ value must also be provided in the different coordinate systems. Here, the X type refers to \a
|
|
|
+ key, and the Y type refers to \a value.
|
|
|
+
|
|
|
+ \see setPixelPosition
|
|
|
+*/
|
|
|
+void QCPItemPosition::setCoords(double key, double value)
|
|
|
+{
|
|
|
+ mKey = key;
|
|
|
+ mValue = value;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Sets the coordinates as a QPointF \a pos where pos.x has the meaning of \a key and pos.y the
|
|
|
+ meaning of \a value of the \ref setCoords(double key, double value) method.
|
|
|
+*/
|
|
|
+void QCPItemPosition::setCoords(const QPointF &pos)
|
|
|
+{
|
|
|
+ setCoords(pos.x(), pos.y());
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns the final absolute pixel position of the QCPItemPosition on the QCustomPlot surface. It
|
|
|
+ includes all effects of type (\ref setType) and possible parent anchors (\ref setParentAnchor).
|
|
|
+
|
|
|
+ \see setPixelPosition
|
|
|
+*/
|
|
|
+QPointF QCPItemPosition::pixelPosition() const
|
|
|
+{
|
|
|
+ QPointF result;
|
|
|
+
|
|
|
+ // determine X:
|
|
|
+ switch (mPositionTypeX)
|
|
|
+ {
|
|
|
+ case ptAbsolute:
|
|
|
+ {
|
|
|
+ result.rx() = mKey;
|
|
|
+ if (mParentAnchorX)
|
|
|
+ result.rx() += mParentAnchorX->pixelPosition().x();
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case ptViewportRatio:
|
|
|
+ {
|
|
|
+ result.rx() = mKey*mParentPlot->viewport().width();
|
|
|
+ if (mParentAnchorX)
|
|
|
+ result.rx() += mParentAnchorX->pixelPosition().x();
|
|
|
+ else
|
|
|
+ result.rx() += mParentPlot->viewport().left();
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case ptAxisRectRatio:
|
|
|
+ {
|
|
|
+ if (mAxisRect)
|
|
|
+ {
|
|
|
+ result.rx() = mKey*mAxisRect.data()->width();
|
|
|
+ if (mParentAnchorX)
|
|
|
+ result.rx() += mParentAnchorX->pixelPosition().x();
|
|
|
+ else
|
|
|
+ result.rx() += mAxisRect.data()->left();
|
|
|
+ } else
|
|
|
+ qDebug() << Q_FUNC_INFO << "Item position type x is ptAxisRectRatio, but no axis rect was defined";
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case ptPlotCoords:
|
|
|
+ {
|
|
|
+ if (mKeyAxis && mKeyAxis.data()->orientation() == Qt::Horizontal)
|
|
|
+ result.rx() = mKeyAxis.data()->coordToPixel(mKey);
|
|
|
+ else if (mValueAxis && mValueAxis.data()->orientation() == Qt::Horizontal)
|
|
|
+ result.rx() = mValueAxis.data()->coordToPixel(mValue);
|
|
|
+ else
|
|
|
+ qDebug() << Q_FUNC_INFO << "Item position type x is ptPlotCoords, but no axes were defined";
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // determine Y:
|
|
|
+ switch (mPositionTypeY)
|
|
|
+ {
|
|
|
+ case ptAbsolute:
|
|
|
+ {
|
|
|
+ result.ry() = mValue;
|
|
|
+ if (mParentAnchorY)
|
|
|
+ result.ry() += mParentAnchorY->pixelPosition().y();
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case ptViewportRatio:
|
|
|
+ {
|
|
|
+ result.ry() = mValue*mParentPlot->viewport().height();
|
|
|
+ if (mParentAnchorY)
|
|
|
+ result.ry() += mParentAnchorY->pixelPosition().y();
|
|
|
+ else
|
|
|
+ result.ry() += mParentPlot->viewport().top();
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case ptAxisRectRatio:
|
|
|
+ {
|
|
|
+ if (mAxisRect)
|
|
|
+ {
|
|
|
+ result.ry() = mValue*mAxisRect.data()->height();
|
|
|
+ if (mParentAnchorY)
|
|
|
+ result.ry() += mParentAnchorY->pixelPosition().y();
|
|
|
+ else
|
|
|
+ result.ry() += mAxisRect.data()->top();
|
|
|
+ } else
|
|
|
+ qDebug() << Q_FUNC_INFO << "Item position type y is ptAxisRectRatio, but no axis rect was defined";
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case ptPlotCoords:
|
|
|
+ {
|
|
|
+ if (mKeyAxis && mKeyAxis.data()->orientation() == Qt::Vertical)
|
|
|
+ result.ry() = mKeyAxis.data()->coordToPixel(mKey);
|
|
|
+ else if (mValueAxis && mValueAxis.data()->orientation() == Qt::Vertical)
|
|
|
+ result.ry() = mValueAxis.data()->coordToPixel(mValue);
|
|
|
+ else
|
|
|
+ qDebug() << Q_FUNC_INFO << "Item position type y is ptPlotCoords, but no axes were defined";
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ When \ref setType is \ref ptPlotCoords, this function may be used to specify the axes the
|
|
|
+ coordinates set with \ref setCoords relate to. By default they are set to the initial xAxis and
|
|
|
+ yAxis of the QCustomPlot.
|
|
|
+*/
|
|
|
+void QCPItemPosition::setAxes(QCPAxis *keyAxis, QCPAxis *valueAxis)
|
|
|
+{
|
|
|
+ mKeyAxis = keyAxis;
|
|
|
+ mValueAxis = valueAxis;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ When \ref setType is \ref ptAxisRectRatio, this function may be used to specify the axis rect the
|
|
|
+ coordinates set with \ref setCoords relate to. By default this is set to the main axis rect of
|
|
|
+ the QCustomPlot.
|
|
|
+*/
|
|
|
+void QCPItemPosition::setAxisRect(QCPAxisRect *axisRect)
|
|
|
+{
|
|
|
+ mAxisRect = axisRect;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the apparent pixel position. This works no matter what type (\ref setType) this
|
|
|
+ QCPItemPosition is or what parent-child situation it is in, as coordinates are transformed
|
|
|
+ appropriately, to make the position finally appear at the specified pixel values.
|
|
|
+
|
|
|
+ Only if the type is \ref ptAbsolute and no parent anchor is set, this function's effect is
|
|
|
+ identical to that of \ref setCoords.
|
|
|
+
|
|
|
+ \see pixelPosition, setCoords
|
|
|
+*/
|
|
|
+void QCPItemPosition::setPixelPosition(const QPointF &pixelPosition)
|
|
|
+{
|
|
|
+ double x = pixelPosition.x();
|
|
|
+ double y = pixelPosition.y();
|
|
|
+
|
|
|
+ switch (mPositionTypeX)
|
|
|
+ {
|
|
|
+ case ptAbsolute:
|
|
|
+ {
|
|
|
+ if (mParentAnchorX)
|
|
|
+ x -= mParentAnchorX->pixelPosition().x();
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case ptViewportRatio:
|
|
|
+ {
|
|
|
+ if (mParentAnchorX)
|
|
|
+ x -= mParentAnchorX->pixelPosition().x();
|
|
|
+ else
|
|
|
+ x -= mParentPlot->viewport().left();
|
|
|
+ x /= (double)mParentPlot->viewport().width();
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case ptAxisRectRatio:
|
|
|
+ {
|
|
|
+ if (mAxisRect)
|
|
|
+ {
|
|
|
+ if (mParentAnchorX)
|
|
|
+ x -= mParentAnchorX->pixelPosition().x();
|
|
|
+ else
|
|
|
+ x -= mAxisRect.data()->left();
|
|
|
+ x /= (double)mAxisRect.data()->width();
|
|
|
+ } else
|
|
|
+ qDebug() << Q_FUNC_INFO << "Item position type x is ptAxisRectRatio, but no axis rect was defined";
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case ptPlotCoords:
|
|
|
+ {
|
|
|
+ if (mKeyAxis && mKeyAxis.data()->orientation() == Qt::Horizontal)
|
|
|
+ x = mKeyAxis.data()->pixelToCoord(x);
|
|
|
+ else if (mValueAxis && mValueAxis.data()->orientation() == Qt::Horizontal)
|
|
|
+ y = mValueAxis.data()->pixelToCoord(x);
|
|
|
+ else
|
|
|
+ qDebug() << Q_FUNC_INFO << "Item position type x is ptPlotCoords, but no axes were defined";
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ switch (mPositionTypeY)
|
|
|
+ {
|
|
|
+ case ptAbsolute:
|
|
|
+ {
|
|
|
+ if (mParentAnchorY)
|
|
|
+ y -= mParentAnchorY->pixelPosition().y();
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case ptViewportRatio:
|
|
|
+ {
|
|
|
+ if (mParentAnchorY)
|
|
|
+ y -= mParentAnchorY->pixelPosition().y();
|
|
|
+ else
|
|
|
+ y -= mParentPlot->viewport().top();
|
|
|
+ y /= (double)mParentPlot->viewport().height();
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case ptAxisRectRatio:
|
|
|
+ {
|
|
|
+ if (mAxisRect)
|
|
|
+ {
|
|
|
+ if (mParentAnchorY)
|
|
|
+ y -= mParentAnchorY->pixelPosition().y();
|
|
|
+ else
|
|
|
+ y -= mAxisRect.data()->top();
|
|
|
+ y /= (double)mAxisRect.data()->height();
|
|
|
+ } else
|
|
|
+ qDebug() << Q_FUNC_INFO << "Item position type y is ptAxisRectRatio, but no axis rect was defined";
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case ptPlotCoords:
|
|
|
+ {
|
|
|
+ if (mKeyAxis && mKeyAxis.data()->orientation() == Qt::Vertical)
|
|
|
+ x = mKeyAxis.data()->pixelToCoord(y);
|
|
|
+ else if (mValueAxis && mValueAxis.data()->orientation() == Qt::Vertical)
|
|
|
+ y = mValueAxis.data()->pixelToCoord(y);
|
|
|
+ else
|
|
|
+ qDebug() << Q_FUNC_INFO << "Item position type y is ptPlotCoords, but no axes were defined";
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ setCoords(x, y);
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPAbstractItem
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+/*! \class QCPAbstractItem
|
|
|
+ \brief The abstract base class for all items in a plot.
|
|
|
+
|
|
|
+ In QCustomPlot, items are supplemental graphical elements that are neither plottables
|
|
|
+ (QCPAbstractPlottable) nor axes (QCPAxis). While plottables are always tied to two axes and thus
|
|
|
+ plot coordinates, items can also be placed in absolute coordinates independent of any axes. Each
|
|
|
+ specific item has at least one QCPItemPosition member which controls the positioning. Some items
|
|
|
+ are defined by more than one coordinate and thus have two or more QCPItemPosition members (For
|
|
|
+ example, QCPItemRect has \a topLeft and \a bottomRight).
|
|
|
+
|
|
|
+ This abstract base class defines a very basic interface like visibility and clipping. Since this
|
|
|
+ class is abstract, it can't be instantiated. Use one of the subclasses or create a subclass
|
|
|
+ yourself to create new items.
|
|
|
+
|
|
|
+ The built-in items are:
|
|
|
+ <table>
|
|
|
+ <tr><td>QCPItemLine</td><td>A line defined by a start and an end point. May have different ending styles on each side (e.g. arrows).</td></tr>
|
|
|
+ <tr><td>QCPItemStraightLine</td><td>A straight line defined by a start and a direction point. Unlike QCPItemLine, the straight line is infinitely long and has no endings.</td></tr>
|
|
|
+ <tr><td>QCPItemCurve</td><td>A curve defined by start, end and two intermediate control points. May have different ending styles on each side (e.g. arrows).</td></tr>
|
|
|
+ <tr><td>QCPItemRect</td><td>A rectangle</td></tr>
|
|
|
+ <tr><td>QCPItemEllipse</td><td>An ellipse</td></tr>
|
|
|
+ <tr><td>QCPItemPixmap</td><td>An arbitrary pixmap</td></tr>
|
|
|
+ <tr><td>QCPItemText</td><td>A text label</td></tr>
|
|
|
+ <tr><td>QCPItemBracket</td><td>A bracket which may be used to reference/highlight certain parts in the plot.</td></tr>
|
|
|
+ <tr><td>QCPItemTracer</td><td>An item that can be attached to a QCPGraph and sticks to its data points, given a key coordinate.</td></tr>
|
|
|
+ </table>
|
|
|
+
|
|
|
+ \section items-clipping Clipping
|
|
|
+
|
|
|
+ Items are by default clipped to the main axis rect (they are only visible inside the axis rect).
|
|
|
+ To make an item visible outside that axis rect, disable clipping via \ref setClipToAxisRect
|
|
|
+ "setClipToAxisRect(false)".
|
|
|
+
|
|
|
+ On the other hand if you want the item to be clipped to a different axis rect, specify it via
|
|
|
+ \ref setClipAxisRect. This clipAxisRect property of an item is only used for clipping behaviour, and
|
|
|
+ in principle is independent of the coordinate axes the item might be tied to via its position
|
|
|
+ members (\ref QCPItemPosition::setAxes). However, it is common that the axis rect for clipping
|
|
|
+ also contains the axes used for the item positions.
|
|
|
+
|
|
|
+ \section items-using Using items
|
|
|
+
|
|
|
+ First you instantiate the item you want to use and add it to the plot:
|
|
|
+ \snippet documentation/doc-code-snippets/mainwindow.cpp qcpitemline-creation-1
|
|
|
+ by default, the positions of the item are bound to the x- and y-Axis of the plot. So we can just
|
|
|
+ set the plot coordinates where the line should start/end:
|
|
|
+ \snippet documentation/doc-code-snippets/mainwindow.cpp qcpitemline-creation-2
|
|
|
+ If we don't want the line to be positioned in plot coordinates but a different coordinate system,
|
|
|
+ e.g. absolute pixel positions on the QCustomPlot surface, we need to change the position type like this:
|
|
|
+ \snippet documentation/doc-code-snippets/mainwindow.cpp qcpitemline-creation-3
|
|
|
+ Then we can set the coordinates, this time in pixels:
|
|
|
+ \snippet documentation/doc-code-snippets/mainwindow.cpp qcpitemline-creation-4
|
|
|
+ and make the line visible on the entire QCustomPlot, by disabling clipping to the axis rect:
|
|
|
+ \snippet documentation/doc-code-snippets/mainwindow.cpp qcpitemline-creation-5
|
|
|
+
|
|
|
+ For more advanced plots, it is even possible to set different types and parent anchors per X/Y
|
|
|
+ coordinate of an item position, using for example \ref QCPItemPosition::setTypeX or \ref
|
|
|
+ QCPItemPosition::setParentAnchorX. For details, see the documentation of \ref QCPItemPosition.
|
|
|
+
|
|
|
+ \section items-subclassing Creating own items
|
|
|
+
|
|
|
+ To create an own item, you implement a subclass of QCPAbstractItem. These are the pure
|
|
|
+ virtual functions, you must implement:
|
|
|
+ \li \ref selectTest
|
|
|
+ \li \ref draw
|
|
|
+
|
|
|
+ See the documentation of those functions for what they need to do.
|
|
|
+
|
|
|
+ \subsection items-positioning Allowing the item to be positioned
|
|
|
+
|
|
|
+ As mentioned, item positions are represented by QCPItemPosition members. Let's assume the new item shall
|
|
|
+ have only one point as its position (as opposed to two like a rect or multiple like a polygon). You then add
|
|
|
+ a public member of type QCPItemPosition like so:
|
|
|
+
|
|
|
+ \code QCPItemPosition * const myPosition;\endcode
|
|
|
+
|
|
|
+ the const makes sure the pointer itself can't be modified from the user of your new item (the QCPItemPosition
|
|
|
+ instance it points to, can be modified, of course).
|
|
|
+ The initialization of this pointer is made easy with the \ref createPosition function. Just assign
|
|
|
+ the return value of this function to each QCPItemPosition in the constructor of your item. \ref createPosition
|
|
|
+ takes a string which is the name of the position, typically this is identical to the variable name.
|
|
|
+ For example, the constructor of QCPItemExample could look like this:
|
|
|
+
|
|
|
+ \code
|
|
|
+ QCPItemExample::QCPItemExample(QCustomPlot *parentPlot) :
|
|
|
+ QCPAbstractItem(parentPlot),
|
|
|
+ myPosition(createPosition("myPosition"))
|
|
|
+ {
|
|
|
+ // other constructor code
|
|
|
+ }
|
|
|
+ \endcode
|
|
|
+
|
|
|
+ \subsection items-drawing The draw function
|
|
|
+
|
|
|
+ To give your item a visual representation, reimplement the \ref draw function and use the passed
|
|
|
+ QCPPainter to draw the item. You can retrieve the item position in pixel coordinates from the
|
|
|
+ position member(s) via \ref QCPItemPosition::pixelPosition.
|
|
|
+
|
|
|
+ To optimize performance you should calculate a bounding rect first (don't forget to take the pen
|
|
|
+ width into account), check whether it intersects the \ref clipRect, and only draw the item at all
|
|
|
+ if this is the case.
|
|
|
+
|
|
|
+ \subsection items-selection The selectTest function
|
|
|
+
|
|
|
+ Your implementation of the \ref selectTest function may use the helpers \ref
|
|
|
+ QCPVector2D::distanceSquaredToLine and \ref rectDistance. With these, the implementation of the
|
|
|
+ selection test becomes significantly simpler for most items. See the documentation of \ref
|
|
|
+ selectTest for what the function parameters mean and what the function should return.
|
|
|
+
|
|
|
+ \subsection anchors Providing anchors
|
|
|
+
|
|
|
+ Providing anchors (QCPItemAnchor) starts off like adding a position. First you create a public
|
|
|
+ member, e.g.
|
|
|
+
|
|
|
+ \code QCPItemAnchor * const bottom;\endcode
|
|
|
+
|
|
|
+ and create it in the constructor with the \ref createAnchor function, assigning it a name and an
|
|
|
+ anchor id (an integer enumerating all anchors on the item, you may create an own enum for this).
|
|
|
+ Since anchors can be placed anywhere, relative to the item's position(s), your item needs to
|
|
|
+ provide the position of every anchor with the reimplementation of the \ref anchorPixelPosition(int
|
|
|
+ anchorId) function.
|
|
|
+
|
|
|
+ In essence the QCPItemAnchor is merely an intermediary that itself asks your item for the pixel
|
|
|
+ position when anything attached to the anchor needs to know the coordinates.
|
|
|
+*/
|
|
|
+
|
|
|
+/* start of documentation of inline functions */
|
|
|
+
|
|
|
+/*! \fn QList<QCPItemPosition*> QCPAbstractItem::positions() const
|
|
|
+
|
|
|
+ Returns all positions of the item in a list.
|
|
|
+
|
|
|
+ \see anchors, position
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn QList<QCPItemAnchor*> QCPAbstractItem::anchors() const
|
|
|
+
|
|
|
+ Returns all anchors of the item in a list. Note that since a position (QCPItemPosition) is always
|
|
|
+ also an anchor, the list will also contain the positions of this item.
|
|
|
+
|
|
|
+ \see positions, anchor
|
|
|
+*/
|
|
|
+
|
|
|
+/* end of documentation of inline functions */
|
|
|
+/* start documentation of pure virtual functions */
|
|
|
+
|
|
|
+/*! \fn void QCPAbstractItem::draw(QCPPainter *painter) = 0
|
|
|
+ \internal
|
|
|
+
|
|
|
+ Draws this item with the provided \a painter.
|
|
|
+
|
|
|
+ The cliprect of the provided painter is set to the rect returned by \ref clipRect before this
|
|
|
+ function is called. The clipRect depends on the clipping settings defined by \ref
|
|
|
+ setClipToAxisRect and \ref setClipAxisRect.
|
|
|
+*/
|
|
|
+
|
|
|
+/* end documentation of pure virtual functions */
|
|
|
+/* start documentation of signals */
|
|
|
+
|
|
|
+/*! \fn void QCPAbstractItem::selectionChanged(bool selected)
|
|
|
+ This signal is emitted when the selection state of this item has changed, either by user interaction
|
|
|
+ or by a direct call to \ref setSelected.
|
|
|
+*/
|
|
|
+
|
|
|
+/* end documentation of signals */
|
|
|
+
|
|
|
+/*!
|
|
|
+ Base class constructor which initializes base class members.
|
|
|
+*/
|
|
|
+QCPAbstractItem::QCPAbstractItem(QCustomPlot *parentPlot) :
|
|
|
+ QCPLayerable(parentPlot),
|
|
|
+ mClipToAxisRect(false),
|
|
|
+ mSelectable(true),
|
|
|
+ mSelected(false)
|
|
|
+{
|
|
|
+ parentPlot->registerItem(this);
|
|
|
+
|
|
|
+ QList<QCPAxisRect*> rects = parentPlot->axisRects();
|
|
|
+ if (rects.size() > 0)
|
|
|
+ {
|
|
|
+ setClipToAxisRect(true);
|
|
|
+ setClipAxisRect(rects.first());
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+QCPAbstractItem::~QCPAbstractItem()
|
|
|
+{
|
|
|
+ // don't delete mPositions because every position is also an anchor and thus in mAnchors
|
|
|
+ qDeleteAll(mAnchors);
|
|
|
+}
|
|
|
+
|
|
|
+/* can't make this a header inline function, because QPointer breaks with forward declared types, see QTBUG-29588 */
|
|
|
+QCPAxisRect *QCPAbstractItem::clipAxisRect() const
|
|
|
+{
|
|
|
+ return mClipAxisRect.data();
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets whether the item shall be clipped to an axis rect or whether it shall be visible on the
|
|
|
+ entire QCustomPlot. The axis rect can be set with \ref setClipAxisRect.
|
|
|
+
|
|
|
+ \see setClipAxisRect
|
|
|
+*/
|
|
|
+void QCPAbstractItem::setClipToAxisRect(bool clip)
|
|
|
+{
|
|
|
+ mClipToAxisRect = clip;
|
|
|
+ if (mClipToAxisRect)
|
|
|
+ setParentLayerable(mClipAxisRect.data());
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the clip axis rect. It defines the rect that will be used to clip the item when \ref
|
|
|
+ setClipToAxisRect is set to true.
|
|
|
+
|
|
|
+ \see setClipToAxisRect
|
|
|
+*/
|
|
|
+void QCPAbstractItem::setClipAxisRect(QCPAxisRect *rect)
|
|
|
+{
|
|
|
+ mClipAxisRect = rect;
|
|
|
+ if (mClipToAxisRect)
|
|
|
+ setParentLayerable(mClipAxisRect.data());
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets whether the user can (de-)select this item by clicking on the QCustomPlot surface.
|
|
|
+ (When \ref QCustomPlot::setInteractions contains QCustomPlot::iSelectItems.)
|
|
|
+
|
|
|
+ However, even when \a selectable was set to false, it is possible to set the selection manually,
|
|
|
+ by calling \ref setSelected.
|
|
|
+
|
|
|
+ \see QCustomPlot::setInteractions, setSelected
|
|
|
+*/
|
|
|
+void QCPAbstractItem::setSelectable(bool selectable)
|
|
|
+{
|
|
|
+ if (mSelectable != selectable)
|
|
|
+ {
|
|
|
+ mSelectable = selectable;
|
|
|
+ emit selectableChanged(mSelectable);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets whether this item is selected or not. When selected, it might use a different visual
|
|
|
+ appearance (e.g. pen and brush), this depends on the specific item though.
|
|
|
+
|
|
|
+ The entire selection mechanism for items is handled automatically when \ref
|
|
|
+ QCustomPlot::setInteractions contains QCustomPlot::iSelectItems. You only need to call this
|
|
|
+ function when you wish to change the selection state manually.
|
|
|
+
|
|
|
+ This function can change the selection state even when \ref setSelectable was set to false.
|
|
|
+
|
|
|
+ emits the \ref selectionChanged signal when \a selected is different from the previous selection state.
|
|
|
+
|
|
|
+ \see setSelectable, selectTest
|
|
|
+*/
|
|
|
+void QCPAbstractItem::setSelected(bool selected)
|
|
|
+{
|
|
|
+ if (mSelected != selected)
|
|
|
+ {
|
|
|
+ mSelected = selected;
|
|
|
+ emit selectionChanged(mSelected);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns the QCPItemPosition with the specified \a name. If this item doesn't have a position by
|
|
|
+ that name, returns 0.
|
|
|
+
|
|
|
+ This function provides an alternative way to access item positions. Normally, you access
|
|
|
+ positions direcly by their member pointers (which typically have the same variable name as \a
|
|
|
+ name).
|
|
|
+
|
|
|
+ \see positions, anchor
|
|
|
+*/
|
|
|
+QCPItemPosition *QCPAbstractItem::position(const QString &name) const
|
|
|
+{
|
|
|
+ for (int i=0; i<mPositions.size(); ++i)
|
|
|
+ {
|
|
|
+ if (mPositions.at(i)->name() == name)
|
|
|
+ return mPositions.at(i);
|
|
|
+ }
|
|
|
+ qDebug() << Q_FUNC_INFO << "position with name not found:" << name;
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns the QCPItemAnchor with the specified \a name. If this item doesn't have an anchor by
|
|
|
+ that name, returns 0.
|
|
|
+
|
|
|
+ This function provides an alternative way to access item anchors. Normally, you access
|
|
|
+ anchors direcly by their member pointers (which typically have the same variable name as \a
|
|
|
+ name).
|
|
|
+
|
|
|
+ \see anchors, position
|
|
|
+*/
|
|
|
+QCPItemAnchor *QCPAbstractItem::anchor(const QString &name) const
|
|
|
+{
|
|
|
+ for (int i=0; i<mAnchors.size(); ++i)
|
|
|
+ {
|
|
|
+ if (mAnchors.at(i)->name() == name)
|
|
|
+ return mAnchors.at(i);
|
|
|
+ }
|
|
|
+ qDebug() << Q_FUNC_INFO << "anchor with name not found:" << name;
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns whether this item has an anchor with the specified \a name.
|
|
|
+
|
|
|
+ Note that you can check for positions with this function, too. This is because every position is
|
|
|
+ also an anchor (QCPItemPosition inherits from QCPItemAnchor).
|
|
|
+
|
|
|
+ \see anchor, position
|
|
|
+*/
|
|
|
+bool QCPAbstractItem::hasAnchor(const QString &name) const
|
|
|
+{
|
|
|
+ for (int i=0; i<mAnchors.size(); ++i)
|
|
|
+ {
|
|
|
+ if (mAnchors.at(i)->name() == name)
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ return false;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the rect the visual representation of this item is clipped to. This depends on the
|
|
|
+ current setting of \ref setClipToAxisRect as well as the axis rect set with \ref setClipAxisRect.
|
|
|
+
|
|
|
+ If the item is not clipped to an axis rect, QCustomPlot's viewport rect is returned.
|
|
|
+
|
|
|
+ \see draw
|
|
|
+*/
|
|
|
+QRect QCPAbstractItem::clipRect() const
|
|
|
+{
|
|
|
+ if (mClipToAxisRect && mClipAxisRect)
|
|
|
+ return mClipAxisRect.data()->rect();
|
|
|
+ else
|
|
|
+ return mParentPlot->viewport();
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ A convenience function to easily set the QPainter::Antialiased hint on the provided \a painter
|
|
|
+ before drawing item 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 QCPAbstractItem::applyDefaultAntialiasingHint(QCPPainter *painter) const
|
|
|
+{
|
|
|
+ applyAntialiasingHint(painter, mAntialiased, QCP::aeItems);
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ A convenience function which returns the selectTest value for a specified \a rect and a specified
|
|
|
+ click position \a pos. \a filledRect defines whether a click inside the rect should also be
|
|
|
+ considered a hit or whether only the rect border is sensitive to hits.
|
|
|
+
|
|
|
+ This function may be used to help with the implementation of the \ref selectTest function for
|
|
|
+ specific items.
|
|
|
+
|
|
|
+ For example, if your item consists of four rects, call this function four times, once for each
|
|
|
+ rect, in your \ref selectTest reimplementation. Finally, return the minimum (non -1) of all four
|
|
|
+ returned values.
|
|
|
+*/
|
|
|
+double QCPAbstractItem::rectDistance(const QRectF &rect, const QPointF &pos, bool filledRect) const
|
|
|
+{
|
|
|
+ double result = -1;
|
|
|
+
|
|
|
+ // distance to border:
|
|
|
+ QList<QLineF> lines;
|
|
|
+ lines << QLineF(rect.topLeft(), rect.topRight()) << QLineF(rect.bottomLeft(), rect.bottomRight())
|
|
|
+ << QLineF(rect.topLeft(), rect.bottomLeft()) << QLineF(rect.topRight(), rect.bottomRight());
|
|
|
+ double minDistSqr = std::numeric_limits<double>::max();
|
|
|
+ for (int i=0; i<lines.size(); ++i)
|
|
|
+ {
|
|
|
+ double distSqr = QCPVector2D(pos).distanceSquaredToLine(lines.at(i).p1(), lines.at(i).p2());
|
|
|
+ if (distSqr < minDistSqr)
|
|
|
+ minDistSqr = distSqr;
|
|
|
+ }
|
|
|
+ result = qSqrt(minDistSqr);
|
|
|
+
|
|
|
+ // filled rect, allow click inside to count as hit:
|
|
|
+ if (filledRect && result > mParentPlot->selectionTolerance()*0.99)
|
|
|
+ {
|
|
|
+ if (rect.contains(pos))
|
|
|
+ result = mParentPlot->selectionTolerance()*0.99;
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the pixel position of the anchor with Id \a anchorId. This function must be reimplemented in
|
|
|
+ item subclasses if they want to provide anchors (QCPItemAnchor).
|
|
|
+
|
|
|
+ For example, if the item has two anchors with id 0 and 1, this function takes one of these anchor
|
|
|
+ ids and returns the respective pixel points of the specified anchor.
|
|
|
+
|
|
|
+ \see createAnchor
|
|
|
+*/
|
|
|
+QPointF QCPAbstractItem::anchorPixelPosition(int anchorId) const
|
|
|
+{
|
|
|
+ qDebug() << Q_FUNC_INFO << "called on item which shouldn't have any anchors (this method not reimplemented). anchorId" << anchorId;
|
|
|
+ return QPointF();
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Creates a QCPItemPosition, registers it with this item and returns a pointer to it. The specified
|
|
|
+ \a name must be a unique string that is usually identical to the variable name of the position
|
|
|
+ member (This is needed to provide the name-based \ref position access to positions).
|
|
|
+
|
|
|
+ Don't delete positions created by this function manually, as the item will take care of it.
|
|
|
+
|
|
|
+ Use this function in the constructor (initialization list) of the specific item subclass to
|
|
|
+ create each position member. Don't create QCPItemPositions with \b new yourself, because they
|
|
|
+ won't be registered with the item properly.
|
|
|
+
|
|
|
+ \see createAnchor
|
|
|
+*/
|
|
|
+QCPItemPosition *QCPAbstractItem::createPosition(const QString &name)
|
|
|
+{
|
|
|
+ if (hasAnchor(name))
|
|
|
+ qDebug() << Q_FUNC_INFO << "anchor/position with name exists already:" << name;
|
|
|
+ QCPItemPosition *newPosition = new QCPItemPosition(mParentPlot, this, name);
|
|
|
+ mPositions.append(newPosition);
|
|
|
+ mAnchors.append(newPosition); // every position is also an anchor
|
|
|
+ newPosition->setAxes(mParentPlot->xAxis, mParentPlot->yAxis);
|
|
|
+ newPosition->setType(QCPItemPosition::ptPlotCoords);
|
|
|
+ if (mParentPlot->axisRect())
|
|
|
+ newPosition->setAxisRect(mParentPlot->axisRect());
|
|
|
+ newPosition->setCoords(0, 0);
|
|
|
+ return newPosition;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Creates a QCPItemAnchor, registers it with this item and returns a pointer to it. The specified
|
|
|
+ \a name must be a unique string that is usually identical to the variable name of the anchor
|
|
|
+ member (This is needed to provide the name based \ref anchor access to anchors).
|
|
|
+
|
|
|
+ The \a anchorId must be a number identifying the created anchor. It is recommended to create an
|
|
|
+ enum (e.g. "AnchorIndex") for this on each item that uses anchors. This id is used by the anchor
|
|
|
+ to identify itself when it calls QCPAbstractItem::anchorPixelPosition. That function then returns
|
|
|
+ the correct pixel coordinates for the passed anchor id.
|
|
|
+
|
|
|
+ Don't delete anchors created by this function manually, as the item will take care of it.
|
|
|
+
|
|
|
+ Use this function in the constructor (initialization list) of the specific item subclass to
|
|
|
+ create each anchor member. Don't create QCPItemAnchors with \b new yourself, because then they
|
|
|
+ won't be registered with the item properly.
|
|
|
+
|
|
|
+ \see createPosition
|
|
|
+*/
|
|
|
+QCPItemAnchor *QCPAbstractItem::createAnchor(const QString &name, int anchorId)
|
|
|
+{
|
|
|
+ if (hasAnchor(name))
|
|
|
+ qDebug() << Q_FUNC_INFO << "anchor/position with name exists already:" << name;
|
|
|
+ QCPItemAnchor *newAnchor = new QCPItemAnchor(mParentPlot, this, name, anchorId);
|
|
|
+ mAnchors.append(newAnchor);
|
|
|
+ return newAnchor;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPAbstractItem::selectEvent(QMouseEvent *event, bool additive, const QVariant &details, bool *selectionStateChanged)
|
|
|
+{
|
|
|
+ Q_UNUSED(event)
|
|
|
+ Q_UNUSED(details)
|
|
|
+ if (mSelectable)
|
|
|
+ {
|
|
|
+ bool selBefore = mSelected;
|
|
|
+ setSelected(additive ? !mSelected : true);
|
|
|
+ if (selectionStateChanged)
|
|
|
+ *selectionStateChanged = mSelected != selBefore;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPAbstractItem::deselectEvent(bool *selectionStateChanged)
|
|
|
+{
|
|
|
+ if (mSelectable)
|
|
|
+ {
|
|
|
+ bool selBefore = mSelected;
|
|
|
+ setSelected(false);
|
|
|
+ if (selectionStateChanged)
|
|
|
+ *selectionStateChanged = mSelected != selBefore;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+QCP::Interaction QCPAbstractItem::selectionCategory() const
|
|
|
+{
|
|
|
+ return QCP::iSelectItems;
|
|
|
+}
|
|
|
+/* end of 'src/item.cpp' */
|
|
|
+
|
|
|
+
|
|
|
+/* including file 'src/core.cpp', size 125037 */
|
|
|
+/* commit 9868e55d3b412f2f89766bb482fcf299e93a0988 2017-09-04 01:56:22 +0200 */
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCustomPlot
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+/*! \class QCustomPlot
|
|
|
+
|
|
|
+ \brief The central class of the library. This is the QWidget which displays the plot and
|
|
|
+ interacts with the user.
|
|
|
+
|
|
|
+ For tutorials on how to use QCustomPlot, see the website\n
|
|
|
+ http://www.qcustomplot.com/
|
|
|
+*/
|
|
|
+
|
|
|
+/* start of documentation of inline functions */
|
|
|
+
|
|
|
+/*! \fn QCPSelectionRect *QCustomPlot::selectionRect() const
|
|
|
+
|
|
|
+ Allows access to the currently used QCPSelectionRect instance (or subclass thereof), that is used
|
|
|
+ to handle and draw selection rect interactions (see \ref setSelectionRectMode).
|
|
|
+
|
|
|
+ \see setSelectionRect
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn QCPLayoutGrid *QCustomPlot::plotLayout() const
|
|
|
+
|
|
|
+ Returns the top level layout of this QCustomPlot instance. It is a \ref QCPLayoutGrid, initially containing just
|
|
|
+ one cell with the main QCPAxisRect inside.
|
|
|
+*/
|
|
|
+
|
|
|
+/* end of documentation of inline functions */
|
|
|
+/* start of documentation of signals */
|
|
|
+
|
|
|
+/*! \fn void QCustomPlot::mouseDoubleClick(QMouseEvent *event)
|
|
|
+
|
|
|
+ This signal is emitted when the QCustomPlot receives a mouse double click event.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn void QCustomPlot::mousePress(QMouseEvent *event)
|
|
|
+
|
|
|
+ This signal is emitted when the QCustomPlot receives a mouse press event.
|
|
|
+
|
|
|
+ It is emitted before QCustomPlot handles any other mechanism like range dragging. So a slot
|
|
|
+ connected to this signal can still influence the behaviour e.g. with \ref QCPAxisRect::setRangeDrag or \ref
|
|
|
+ QCPAxisRect::setRangeDragAxes.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn void QCustomPlot::mouseMove(QMouseEvent *event)
|
|
|
+
|
|
|
+ This signal is emitted when the QCustomPlot receives a mouse move event.
|
|
|
+
|
|
|
+ It is emitted before QCustomPlot handles any other mechanism like range dragging. So a slot
|
|
|
+ connected to this signal can still influence the behaviour e.g. with \ref QCPAxisRect::setRangeDrag or \ref
|
|
|
+ QCPAxisRect::setRangeDragAxes.
|
|
|
+
|
|
|
+ \warning It is discouraged to change the drag-axes with \ref QCPAxisRect::setRangeDragAxes here,
|
|
|
+ because the dragging starting point was saved the moment the mouse was pressed. Thus it only has
|
|
|
+ a meaning for the range drag axes that were set at that moment. If you want to change the drag
|
|
|
+ axes, consider doing this in the \ref mousePress signal instead.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn void QCustomPlot::mouseRelease(QMouseEvent *event)
|
|
|
+
|
|
|
+ This signal is emitted when the QCustomPlot receives a mouse release event.
|
|
|
+
|
|
|
+ It is emitted before QCustomPlot handles any other mechanisms like object selection. So a
|
|
|
+ slot connected to this signal can still influence the behaviour e.g. with \ref setInteractions or
|
|
|
+ \ref QCPAbstractPlottable::setSelectable.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn void QCustomPlot::mouseWheel(QMouseEvent *event)
|
|
|
+
|
|
|
+ This signal is emitted when the QCustomPlot receives a mouse wheel event.
|
|
|
+
|
|
|
+ It is emitted before QCustomPlot handles any other mechanisms like range zooming. So a slot
|
|
|
+ connected to this signal can still influence the behaviour e.g. with \ref QCPAxisRect::setRangeZoom, \ref
|
|
|
+ QCPAxisRect::setRangeZoomAxes or \ref QCPAxisRect::setRangeZoomFactor.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn void QCustomPlot::plottableClick(QCPAbstractPlottable *plottable, int dataIndex, QMouseEvent *event)
|
|
|
+
|
|
|
+ This signal is emitted when a plottable is clicked.
|
|
|
+
|
|
|
+ \a event is the mouse event that caused the click and \a plottable is the plottable that received
|
|
|
+ the click. The parameter \a dataIndex indicates the data point that was closest to the click
|
|
|
+ position.
|
|
|
+
|
|
|
+ \see plottableDoubleClick
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn void QCustomPlot::plottableDoubleClick(QCPAbstractPlottable *plottable, int dataIndex, QMouseEvent *event)
|
|
|
+
|
|
|
+ This signal is emitted when a plottable is double clicked.
|
|
|
+
|
|
|
+ \a event is the mouse event that caused the click and \a plottable is the plottable that received
|
|
|
+ the click. The parameter \a dataIndex indicates the data point that was closest to the click
|
|
|
+ position.
|
|
|
+
|
|
|
+ \see plottableClick
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn void QCustomPlot::itemClick(QCPAbstractItem *item, QMouseEvent *event)
|
|
|
+
|
|
|
+ This signal is emitted when an item is clicked.
|
|
|
+
|
|
|
+ \a event is the mouse event that caused the click and \a item is the item that received the
|
|
|
+ click.
|
|
|
+
|
|
|
+ \see itemDoubleClick
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn void QCustomPlot::itemDoubleClick(QCPAbstractItem *item, QMouseEvent *event)
|
|
|
+
|
|
|
+ This signal is emitted when an item is double clicked.
|
|
|
+
|
|
|
+ \a event is the mouse event that caused the click and \a item is the item that received the
|
|
|
+ click.
|
|
|
+
|
|
|
+ \see itemClick
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn void QCustomPlot::axisClick(QCPAxis *axis, QCPAxis::SelectablePart part, QMouseEvent *event)
|
|
|
+
|
|
|
+ This signal is emitted when an axis is clicked.
|
|
|
+
|
|
|
+ \a event is the mouse event that caused the click, \a axis is the axis that received the click and
|
|
|
+ \a part indicates the part of the axis that was clicked.
|
|
|
+
|
|
|
+ \see axisDoubleClick
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn void QCustomPlot::axisDoubleClick(QCPAxis *axis, QCPAxis::SelectablePart part, QMouseEvent *event)
|
|
|
+
|
|
|
+ This signal is emitted when an axis is double clicked.
|
|
|
+
|
|
|
+ \a event is the mouse event that caused the click, \a axis is the axis that received the click and
|
|
|
+ \a part indicates the part of the axis that was clicked.
|
|
|
+
|
|
|
+ \see axisClick
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn void QCustomPlot::legendClick(QCPLegend *legend, QCPAbstractLegendItem *item, QMouseEvent *event)
|
|
|
+
|
|
|
+ This signal is emitted when a legend (item) is clicked.
|
|
|
+
|
|
|
+ \a event is the mouse event that caused the click, \a legend is the legend that received the
|
|
|
+ click and \a item is the legend item that received the click. If only the legend and no item is
|
|
|
+ clicked, \a item is 0. This happens for a click inside the legend padding or the space between
|
|
|
+ two items.
|
|
|
+
|
|
|
+ \see legendDoubleClick
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn void QCustomPlot::legendDoubleClick(QCPLegend *legend, QCPAbstractLegendItem *item, QMouseEvent *event)
|
|
|
+
|
|
|
+ This signal is emitted when a legend (item) is double clicked.
|
|
|
+
|
|
|
+ \a event is the mouse event that caused the click, \a legend is the legend that received the
|
|
|
+ click and \a item is the legend item that received the click. If only the legend and no item is
|
|
|
+ clicked, \a item is 0. This happens for a click inside the legend padding or the space between
|
|
|
+ two items.
|
|
|
+
|
|
|
+ \see legendClick
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn void QCustomPlot::selectionChangedByUser()
|
|
|
+
|
|
|
+ This signal is emitted after the user has changed the selection in the QCustomPlot, e.g. by
|
|
|
+ clicking. It is not emitted when the selection state of an object has changed programmatically by
|
|
|
+ a direct call to <tt>setSelected()</tt>/<tt>setSelection()</tt> on an object or by calling \ref
|
|
|
+ deselectAll.
|
|
|
+
|
|
|
+ In addition to this signal, selectable objects also provide individual signals, for example \ref
|
|
|
+ QCPAxis::selectionChanged or \ref QCPAbstractPlottable::selectionChanged. Note that those signals
|
|
|
+ are emitted even if the selection state is changed programmatically.
|
|
|
+
|
|
|
+ See the documentation of \ref setInteractions for details about the selection mechanism.
|
|
|
+
|
|
|
+ \see selectedPlottables, selectedGraphs, selectedItems, selectedAxes, selectedLegends
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn void QCustomPlot::beforeReplot()
|
|
|
+
|
|
|
+ This signal is emitted immediately before a replot takes place (caused by a call to the slot \ref
|
|
|
+ replot).
|
|
|
+
|
|
|
+ It is safe to mutually connect the replot slot with this signal on two QCustomPlots to make them
|
|
|
+ replot synchronously, it won't cause an infinite recursion.
|
|
|
+
|
|
|
+ \see replot, afterReplot
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn void QCustomPlot::afterReplot()
|
|
|
+
|
|
|
+ This signal is emitted immediately after a replot has taken place (caused by a call to the slot \ref
|
|
|
+ replot).
|
|
|
+
|
|
|
+ It is safe to mutually connect the replot slot with this signal on two QCustomPlots to make them
|
|
|
+ replot synchronously, it won't cause an infinite recursion.
|
|
|
+
|
|
|
+ \see replot, beforeReplot
|
|
|
+*/
|
|
|
+
|
|
|
+/* end of documentation of signals */
|
|
|
+/* start of documentation of public members */
|
|
|
+
|
|
|
+/*! \var QCPAxis *QCustomPlot::xAxis
|
|
|
+
|
|
|
+ A pointer to the primary x Axis (bottom) of the main axis rect of the plot.
|
|
|
+
|
|
|
+ QCustomPlot offers convenient pointers to the axes (\ref xAxis, \ref yAxis, \ref xAxis2, \ref
|
|
|
+ yAxis2) and the \ref legend. They make it very easy working with plots that only have a single
|
|
|
+ axis rect and at most one axis at each axis rect side. If you use \link thelayoutsystem the
|
|
|
+ layout system\endlink to add multiple axis rects or multiple axes to one side, use the \ref
|
|
|
+ QCPAxisRect::axis interface to access the new axes. If one of the four default axes or the
|
|
|
+ default legend is removed due to manipulation of the layout system (e.g. by removing the main
|
|
|
+ axis rect), the corresponding pointers become 0.
|
|
|
+
|
|
|
+ If an axis convenience pointer is currently zero and a new axis rect or a corresponding axis is
|
|
|
+ added in the place of the main axis rect, QCustomPlot resets the convenience pointers to the
|
|
|
+ according new axes. Similarly the \ref legend convenience pointer will be reset if a legend is
|
|
|
+ added after the main legend was removed before.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \var QCPAxis *QCustomPlot::yAxis
|
|
|
+
|
|
|
+ A pointer to the primary y Axis (left) of the main axis rect of the plot.
|
|
|
+
|
|
|
+ QCustomPlot offers convenient pointers to the axes (\ref xAxis, \ref yAxis, \ref xAxis2, \ref
|
|
|
+ yAxis2) and the \ref legend. They make it very easy working with plots that only have a single
|
|
|
+ axis rect and at most one axis at each axis rect side. If you use \link thelayoutsystem the
|
|
|
+ layout system\endlink to add multiple axis rects or multiple axes to one side, use the \ref
|
|
|
+ QCPAxisRect::axis interface to access the new axes. If one of the four default axes or the
|
|
|
+ default legend is removed due to manipulation of the layout system (e.g. by removing the main
|
|
|
+ axis rect), the corresponding pointers become 0.
|
|
|
+
|
|
|
+ If an axis convenience pointer is currently zero and a new axis rect or a corresponding axis is
|
|
|
+ added in the place of the main axis rect, QCustomPlot resets the convenience pointers to the
|
|
|
+ according new axes. Similarly the \ref legend convenience pointer will be reset if a legend is
|
|
|
+ added after the main legend was removed before.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \var QCPAxis *QCustomPlot::xAxis2
|
|
|
+
|
|
|
+ A pointer to the secondary x Axis (top) of the main axis rect of the plot. Secondary axes are
|
|
|
+ invisible by default. Use QCPAxis::setVisible to change this (or use \ref
|
|
|
+ QCPAxisRect::setupFullAxesBox).
|
|
|
+
|
|
|
+ QCustomPlot offers convenient pointers to the axes (\ref xAxis, \ref yAxis, \ref xAxis2, \ref
|
|
|
+ yAxis2) and the \ref legend. They make it very easy working with plots that only have a single
|
|
|
+ axis rect and at most one axis at each axis rect side. If you use \link thelayoutsystem the
|
|
|
+ layout system\endlink to add multiple axis rects or multiple axes to one side, use the \ref
|
|
|
+ QCPAxisRect::axis interface to access the new axes. If one of the four default axes or the
|
|
|
+ default legend is removed due to manipulation of the layout system (e.g. by removing the main
|
|
|
+ axis rect), the corresponding pointers become 0.
|
|
|
+
|
|
|
+ If an axis convenience pointer is currently zero and a new axis rect or a corresponding axis is
|
|
|
+ added in the place of the main axis rect, QCustomPlot resets the convenience pointers to the
|
|
|
+ according new axes. Similarly the \ref legend convenience pointer will be reset if a legend is
|
|
|
+ added after the main legend was removed before.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \var QCPAxis *QCustomPlot::yAxis2
|
|
|
+
|
|
|
+ A pointer to the secondary y Axis (right) of the main axis rect of the plot. Secondary axes are
|
|
|
+ invisible by default. Use QCPAxis::setVisible to change this (or use \ref
|
|
|
+ QCPAxisRect::setupFullAxesBox).
|
|
|
+
|
|
|
+ QCustomPlot offers convenient pointers to the axes (\ref xAxis, \ref yAxis, \ref xAxis2, \ref
|
|
|
+ yAxis2) and the \ref legend. They make it very easy working with plots that only have a single
|
|
|
+ axis rect and at most one axis at each axis rect side. If you use \link thelayoutsystem the
|
|
|
+ layout system\endlink to add multiple axis rects or multiple axes to one side, use the \ref
|
|
|
+ QCPAxisRect::axis interface to access the new axes. If one of the four default axes or the
|
|
|
+ default legend is removed due to manipulation of the layout system (e.g. by removing the main
|
|
|
+ axis rect), the corresponding pointers become 0.
|
|
|
+
|
|
|
+ If an axis convenience pointer is currently zero and a new axis rect or a corresponding axis is
|
|
|
+ added in the place of the main axis rect, QCustomPlot resets the convenience pointers to the
|
|
|
+ according new axes. Similarly the \ref legend convenience pointer will be reset if a legend is
|
|
|
+ added after the main legend was removed before.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \var QCPLegend *QCustomPlot::legend
|
|
|
+
|
|
|
+ A pointer to the default legend of the main axis rect. The legend is invisible by default. Use
|
|
|
+ QCPLegend::setVisible to change this.
|
|
|
+
|
|
|
+ QCustomPlot offers convenient pointers to the axes (\ref xAxis, \ref yAxis, \ref xAxis2, \ref
|
|
|
+ yAxis2) and the \ref legend. They make it very easy working with plots that only have a single
|
|
|
+ axis rect and at most one axis at each axis rect side. If you use \link thelayoutsystem the
|
|
|
+ layout system\endlink to add multiple legends to the plot, use the layout system interface to
|
|
|
+ access the new legend. For example, legends can be placed inside an axis rect's \ref
|
|
|
+ QCPAxisRect::insetLayout "inset layout", and must then also be accessed via the inset layout. If
|
|
|
+ the default legend is removed due to manipulation of the layout system (e.g. by removing the main
|
|
|
+ axis rect), the corresponding pointer becomes 0.
|
|
|
+
|
|
|
+ If an axis convenience pointer is currently zero and a new axis rect or a corresponding axis is
|
|
|
+ added in the place of the main axis rect, QCustomPlot resets the convenience pointers to the
|
|
|
+ according new axes. Similarly the \ref legend convenience pointer will be reset if a legend is
|
|
|
+ added after the main legend was removed before.
|
|
|
+*/
|
|
|
+
|
|
|
+/* end of documentation of public members */
|
|
|
+
|
|
|
+/*!
|
|
|
+ Constructs a QCustomPlot and sets reasonable default values.
|
|
|
+*/
|
|
|
+QCustomPlot::QCustomPlot(QWidget *parent) :
|
|
|
+ QWidget(parent),
|
|
|
+ xAxis(0),
|
|
|
+ yAxis(0),
|
|
|
+ xAxis2(0),
|
|
|
+ yAxis2(0),
|
|
|
+ legend(0),
|
|
|
+ mBufferDevicePixelRatio(1.0), // will be adapted to primary screen below
|
|
|
+ mPlotLayout(0),
|
|
|
+ mAutoAddPlottableToLegend(true),
|
|
|
+ mAntialiasedElements(QCP::aeNone),
|
|
|
+ mNotAntialiasedElements(QCP::aeNone),
|
|
|
+ mInteractions(0),
|
|
|
+ mSelectionTolerance(8),
|
|
|
+ mNoAntialiasingOnDrag(false),
|
|
|
+ mBackgroundBrush(Qt::white, Qt::SolidPattern),
|
|
|
+ mBackgroundScaled(true),
|
|
|
+ mBackgroundScaledMode(Qt::KeepAspectRatioByExpanding),
|
|
|
+ mCurrentLayer(0),
|
|
|
+ mPlottingHints(QCP::phCacheLabels|QCP::phImmediateRefresh),
|
|
|
+ mMultiSelectModifier(Qt::ControlModifier),
|
|
|
+ mSelectionRectMode(QCP::srmNone),
|
|
|
+ mSelectionRect(0),
|
|
|
+ mOpenGl(false),
|
|
|
+ mMouseHasMoved(false),
|
|
|
+ mMouseEventLayerable(0),
|
|
|
+ mMouseSignalLayerable(0),
|
|
|
+ mReplotting(false),
|
|
|
+ mReplotQueued(false),
|
|
|
+ mOpenGlMultisamples(16),
|
|
|
+ mOpenGlAntialiasedElementsBackup(QCP::aeNone),
|
|
|
+ mOpenGlCacheLabelsBackup(true)
|
|
|
+{
|
|
|
+ setAttribute(Qt::WA_NoMousePropagation);
|
|
|
+ setAttribute(Qt::WA_OpaquePaintEvent);
|
|
|
+ setFocusPolicy(Qt::ClickFocus);
|
|
|
+ setMouseTracking(true);
|
|
|
+ QLocale currentLocale = locale();
|
|
|
+ currentLocale.setNumberOptions(QLocale::OmitGroupSeparator);
|
|
|
+ setLocale(currentLocale);
|
|
|
+#ifdef QCP_DEVICEPIXELRATIO_SUPPORTED
|
|
|
+# ifdef QCP_DEVICEPIXELRATIO_FLOAT
|
|
|
+ setBufferDevicePixelRatio(QWidget::devicePixelRatioF());
|
|
|
+# else
|
|
|
+ setBufferDevicePixelRatio(QWidget::devicePixelRatio());
|
|
|
+# endif
|
|
|
+#endif
|
|
|
+
|
|
|
+ mOpenGlAntialiasedElementsBackup = mAntialiasedElements;
|
|
|
+ mOpenGlCacheLabelsBackup = mPlottingHints.testFlag(QCP::phCacheLabels);
|
|
|
+ // create initial layers:
|
|
|
+ mLayers.append(new QCPLayer(this, QLatin1String("background")));
|
|
|
+ mLayers.append(new QCPLayer(this, QLatin1String("grid")));
|
|
|
+ mLayers.append(new QCPLayer(this, QLatin1String("main")));
|
|
|
+ mLayers.append(new QCPLayer(this, QLatin1String("axes")));
|
|
|
+ mLayers.append(new QCPLayer(this, QLatin1String("legend")));
|
|
|
+ mLayers.append(new QCPLayer(this, QLatin1String("overlay")));
|
|
|
+ updateLayerIndices();
|
|
|
+ setCurrentLayer(QLatin1String("main"));
|
|
|
+ layer(QLatin1String("overlay"))->setMode(QCPLayer::lmBuffered);
|
|
|
+
|
|
|
+ // create initial layout, axis rect and legend:
|
|
|
+ mPlotLayout = new QCPLayoutGrid;
|
|
|
+ mPlotLayout->initializeParentPlot(this);
|
|
|
+ mPlotLayout->setParent(this); // important because if parent is QWidget, QCPLayout::sizeConstraintsChanged will call QWidget::updateGeometry
|
|
|
+ mPlotLayout->setLayer(QLatin1String("main"));
|
|
|
+ QCPAxisRect *defaultAxisRect = new QCPAxisRect(this, true);
|
|
|
+ mPlotLayout->addElement(0, 0, defaultAxisRect);
|
|
|
+ xAxis = defaultAxisRect->axis(QCPAxis::atBottom);
|
|
|
+ yAxis = defaultAxisRect->axis(QCPAxis::atLeft);
|
|
|
+ xAxis2 = defaultAxisRect->axis(QCPAxis::atTop);
|
|
|
+ yAxis2 = defaultAxisRect->axis(QCPAxis::atRight);
|
|
|
+ legend = new QCPLegend;
|
|
|
+ legend->setVisible(false);
|
|
|
+ defaultAxisRect->insetLayout()->addElement(legend, Qt::AlignRight|Qt::AlignTop);
|
|
|
+ defaultAxisRect->insetLayout()->setMargins(QMargins(12, 12, 12, 12));
|
|
|
+
|
|
|
+ defaultAxisRect->setLayer(QLatin1String("background"));
|
|
|
+ xAxis->setLayer(QLatin1String("axes"));
|
|
|
+ yAxis->setLayer(QLatin1String("axes"));
|
|
|
+ xAxis2->setLayer(QLatin1String("axes"));
|
|
|
+ yAxis2->setLayer(QLatin1String("axes"));
|
|
|
+ xAxis->grid()->setLayer(QLatin1String("grid"));
|
|
|
+ yAxis->grid()->setLayer(QLatin1String("grid"));
|
|
|
+ xAxis2->grid()->setLayer(QLatin1String("grid"));
|
|
|
+ yAxis2->grid()->setLayer(QLatin1String("grid"));
|
|
|
+ legend->setLayer(QLatin1String("legend"));
|
|
|
+
|
|
|
+ // create selection rect instance:
|
|
|
+ mSelectionRect = new QCPSelectionRect(this);
|
|
|
+ mSelectionRect->setLayer(QLatin1String("overlay"));
|
|
|
+
|
|
|
+ setViewport(rect()); // needs to be called after mPlotLayout has been created
|
|
|
+
|
|
|
+ replot(rpQueuedReplot);
|
|
|
+}
|
|
|
+
|
|
|
+QCustomPlot::~QCustomPlot()
|
|
|
+{
|
|
|
+ clearPlottables();
|
|
|
+ clearItems();
|
|
|
+
|
|
|
+ if (mPlotLayout)
|
|
|
+ {
|
|
|
+ delete mPlotLayout;
|
|
|
+ mPlotLayout = 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ mCurrentLayer = 0;
|
|
|
+ qDeleteAll(mLayers); // don't use removeLayer, because it would prevent the last layer to be removed
|
|
|
+ mLayers.clear();
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets which elements are forcibly drawn antialiased as an \a or combination of QCP::AntialiasedElement.
|
|
|
+
|
|
|
+ This overrides the antialiasing settings for whole element groups, normally controlled with the
|
|
|
+ \a setAntialiasing function on the individual elements. If an element is neither specified in
|
|
|
+ \ref setAntialiasedElements nor in \ref setNotAntialiasedElements, the antialiasing setting on
|
|
|
+ each individual element instance is used.
|
|
|
+
|
|
|
+ For example, if \a antialiasedElements contains \ref QCP::aePlottables, all plottables will be
|
|
|
+ drawn antialiased, no matter what the specific QCPAbstractPlottable::setAntialiased value was set
|
|
|
+ to.
|
|
|
+
|
|
|
+ if an element in \a antialiasedElements is already set in \ref setNotAntialiasedElements, it is
|
|
|
+ removed from there.
|
|
|
+
|
|
|
+ \see setNotAntialiasedElements
|
|
|
+*/
|
|
|
+void QCustomPlot::setAntialiasedElements(const QCP::AntialiasedElements &antialiasedElements)
|
|
|
+{
|
|
|
+ mAntialiasedElements = antialiasedElements;
|
|
|
+
|
|
|
+ // make sure elements aren't in mNotAntialiasedElements and mAntialiasedElements simultaneously:
|
|
|
+ if ((mNotAntialiasedElements & mAntialiasedElements) != 0)
|
|
|
+ mNotAntialiasedElements |= ~mAntialiasedElements;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets whether the specified \a antialiasedElement is forcibly drawn antialiased.
|
|
|
+
|
|
|
+ See \ref setAntialiasedElements for details.
|
|
|
+
|
|
|
+ \see setNotAntialiasedElement
|
|
|
+*/
|
|
|
+void QCustomPlot::setAntialiasedElement(QCP::AntialiasedElement antialiasedElement, bool enabled)
|
|
|
+{
|
|
|
+ if (!enabled && mAntialiasedElements.testFlag(antialiasedElement))
|
|
|
+ mAntialiasedElements &= ~antialiasedElement;
|
|
|
+ else if (enabled && !mAntialiasedElements.testFlag(antialiasedElement))
|
|
|
+ mAntialiasedElements |= antialiasedElement;
|
|
|
+
|
|
|
+ // make sure elements aren't in mNotAntialiasedElements and mAntialiasedElements simultaneously:
|
|
|
+ if ((mNotAntialiasedElements & mAntialiasedElements) != 0)
|
|
|
+ mNotAntialiasedElements |= ~mAntialiasedElements;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets which elements are forcibly drawn not antialiased as an \a or combination of
|
|
|
+ QCP::AntialiasedElement.
|
|
|
+
|
|
|
+ This overrides the antialiasing settings for whole element groups, normally controlled with the
|
|
|
+ \a setAntialiasing function on the individual elements. If an element is neither specified in
|
|
|
+ \ref setAntialiasedElements nor in \ref setNotAntialiasedElements, the antialiasing setting on
|
|
|
+ each individual element instance is used.
|
|
|
+
|
|
|
+ For example, if \a notAntialiasedElements contains \ref QCP::aePlottables, no plottables will be
|
|
|
+ drawn antialiased, no matter what the specific QCPAbstractPlottable::setAntialiased value was set
|
|
|
+ to.
|
|
|
+
|
|
|
+ if an element in \a notAntialiasedElements is already set in \ref setAntialiasedElements, it is
|
|
|
+ removed from there.
|
|
|
+
|
|
|
+ \see setAntialiasedElements
|
|
|
+*/
|
|
|
+void QCustomPlot::setNotAntialiasedElements(const QCP::AntialiasedElements ¬AntialiasedElements)
|
|
|
+{
|
|
|
+ mNotAntialiasedElements = notAntialiasedElements;
|
|
|
+
|
|
|
+ // make sure elements aren't in mNotAntialiasedElements and mAntialiasedElements simultaneously:
|
|
|
+ if ((mNotAntialiasedElements & mAntialiasedElements) != 0)
|
|
|
+ mAntialiasedElements |= ~mNotAntialiasedElements;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets whether the specified \a notAntialiasedElement is forcibly drawn not antialiased.
|
|
|
+
|
|
|
+ See \ref setNotAntialiasedElements for details.
|
|
|
+
|
|
|
+ \see setAntialiasedElement
|
|
|
+*/
|
|
|
+void QCustomPlot::setNotAntialiasedElement(QCP::AntialiasedElement notAntialiasedElement, bool enabled)
|
|
|
+{
|
|
|
+ if (!enabled && mNotAntialiasedElements.testFlag(notAntialiasedElement))
|
|
|
+ mNotAntialiasedElements &= ~notAntialiasedElement;
|
|
|
+ else if (enabled && !mNotAntialiasedElements.testFlag(notAntialiasedElement))
|
|
|
+ mNotAntialiasedElements |= notAntialiasedElement;
|
|
|
+
|
|
|
+ // make sure elements aren't in mNotAntialiasedElements and mAntialiasedElements simultaneously:
|
|
|
+ if ((mNotAntialiasedElements & mAntialiasedElements) != 0)
|
|
|
+ mAntialiasedElements |= ~mNotAntialiasedElements;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ If set to true, adding a plottable (e.g. a graph) to the QCustomPlot automatically also adds the
|
|
|
+ plottable to the legend (QCustomPlot::legend).
|
|
|
+
|
|
|
+ \see addGraph, QCPLegend::addItem
|
|
|
+*/
|
|
|
+void QCustomPlot::setAutoAddPlottableToLegend(bool on)
|
|
|
+{
|
|
|
+ mAutoAddPlottableToLegend = on;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the possible interactions of this QCustomPlot as an or-combination of \ref QCP::Interaction
|
|
|
+ enums. There are the following types of interactions:
|
|
|
+
|
|
|
+ <b>Axis range manipulation</b> is controlled via \ref QCP::iRangeDrag and \ref QCP::iRangeZoom. When the
|
|
|
+ respective interaction is enabled, the user may drag axes ranges and zoom with the mouse wheel.
|
|
|
+ For details how to control which axes the user may drag/zoom and in what orientations, see \ref
|
|
|
+ QCPAxisRect::setRangeDrag, \ref QCPAxisRect::setRangeZoom, \ref QCPAxisRect::setRangeDragAxes,
|
|
|
+ \ref QCPAxisRect::setRangeZoomAxes.
|
|
|
+
|
|
|
+ <b>Plottable data selection</b> is controlled by \ref QCP::iSelectPlottables. If \ref
|
|
|
+ QCP::iSelectPlottables is set, the user may select plottables (graphs, curves, bars,...) and
|
|
|
+ their data by clicking on them or in their vicinity (\ref setSelectionTolerance). Whether the
|
|
|
+ user can actually select a plottable and its data can further be restricted with the \ref
|
|
|
+ QCPAbstractPlottable::setSelectable method on the specific plottable. For details, see the
|
|
|
+ special page about the \ref dataselection "data selection mechanism". To retrieve a list of all
|
|
|
+ currently selected plottables, call \ref selectedPlottables. If you're only interested in
|
|
|
+ QCPGraphs, you may use the convenience function \ref selectedGraphs.
|
|
|
+
|
|
|
+ <b>Item selection</b> is controlled by \ref QCP::iSelectItems. If \ref QCP::iSelectItems is set, the user
|
|
|
+ may select items (QCPItemLine, QCPItemText,...) by clicking on them or in their vicinity. To find
|
|
|
+ out whether a specific item is selected, call QCPAbstractItem::selected(). To retrieve a list of
|
|
|
+ all currently selected items, call \ref selectedItems.
|
|
|
+
|
|
|
+ <b>Axis selection</b> is controlled with \ref QCP::iSelectAxes. If \ref QCP::iSelectAxes is set, the user
|
|
|
+ may select parts of the axes by clicking on them. What parts exactly (e.g. Axis base line, tick
|
|
|
+ labels, axis label) are selectable can be controlled via \ref QCPAxis::setSelectableParts for
|
|
|
+ each axis. To retrieve a list of all axes that currently contain selected parts, call \ref
|
|
|
+ selectedAxes. Which parts of an axis are selected, can be retrieved with QCPAxis::selectedParts().
|
|
|
+
|
|
|
+ <b>Legend selection</b> is controlled with \ref QCP::iSelectLegend. If this is set, the user may
|
|
|
+ select the legend itself or individual items by clicking on them. What parts exactly are
|
|
|
+ selectable can be controlled via \ref QCPLegend::setSelectableParts. To find out whether the
|
|
|
+ legend or any of its child items are selected, check the value of QCPLegend::selectedParts. To
|
|
|
+ find out which child items are selected, call \ref QCPLegend::selectedItems.
|
|
|
+
|
|
|
+ <b>All other selectable elements</b> The selection of all other selectable objects (e.g.
|
|
|
+ QCPTextElement, or your own layerable subclasses) is controlled with \ref QCP::iSelectOther. If set, the
|
|
|
+ user may select those objects by clicking on them. To find out which are currently selected, you
|
|
|
+ need to check their selected state explicitly.
|
|
|
+
|
|
|
+ If the selection state has changed by user interaction, the \ref selectionChangedByUser signal is
|
|
|
+ emitted. Each selectable object additionally emits an individual selectionChanged signal whenever
|
|
|
+ their selection state has changed, i.e. not only by user interaction.
|
|
|
+
|
|
|
+ To allow multiple objects to be selected by holding the selection modifier (\ref
|
|
|
+ setMultiSelectModifier), set the flag \ref QCP::iMultiSelect.
|
|
|
+
|
|
|
+ \note In addition to the selection mechanism presented here, QCustomPlot always emits
|
|
|
+ corresponding signals, when an object is clicked or double clicked. see \ref plottableClick and
|
|
|
+ \ref plottableDoubleClick for example.
|
|
|
+
|
|
|
+ \see setInteraction, setSelectionTolerance
|
|
|
+*/
|
|
|
+void QCustomPlot::setInteractions(const QCP::Interactions &interactions)
|
|
|
+{
|
|
|
+ mInteractions = interactions;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the single \a interaction of this QCustomPlot to \a enabled.
|
|
|
+
|
|
|
+ For details about the interaction system, see \ref setInteractions.
|
|
|
+
|
|
|
+ \see setInteractions
|
|
|
+*/
|
|
|
+void QCustomPlot::setInteraction(const QCP::Interaction &interaction, bool enabled)
|
|
|
+{
|
|
|
+ if (!enabled && mInteractions.testFlag(interaction))
|
|
|
+ mInteractions &= ~interaction;
|
|
|
+ else if (enabled && !mInteractions.testFlag(interaction))
|
|
|
+ mInteractions |= interaction;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the tolerance that is used to decide whether a click selects an object (e.g. a plottable) or
|
|
|
+ not.
|
|
|
+
|
|
|
+ If the user clicks in the vicinity of the line of e.g. a QCPGraph, it's only regarded as a
|
|
|
+ potential selection when the minimum distance between the click position and the graph line is
|
|
|
+ smaller than \a pixels. Objects that are defined by an area (e.g. QCPBars) only react to clicks
|
|
|
+ directly inside the area and ignore this selection tolerance. In other words, it only has meaning
|
|
|
+ for parts of objects that are too thin to exactly hit with a click and thus need such a
|
|
|
+ tolerance.
|
|
|
+
|
|
|
+ \see setInteractions, QCPLayerable::selectTest
|
|
|
+*/
|
|
|
+void QCustomPlot::setSelectionTolerance(int pixels)
|
|
|
+{
|
|
|
+ mSelectionTolerance = pixels;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets whether antialiasing is disabled for this QCustomPlot while the user is dragging axes
|
|
|
+ ranges. If many objects, especially plottables, are drawn antialiased, this greatly improves
|
|
|
+ performance during dragging. Thus it creates a more responsive user experience. As soon as the
|
|
|
+ user stops dragging, the last replot is done with normal antialiasing, to restore high image
|
|
|
+ quality.
|
|
|
+
|
|
|
+ \see setAntialiasedElements, setNotAntialiasedElements
|
|
|
+*/
|
|
|
+void QCustomPlot::setNoAntialiasingOnDrag(bool enabled)
|
|
|
+{
|
|
|
+ mNoAntialiasingOnDrag = enabled;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the plotting hints for this QCustomPlot instance as an \a or combination of QCP::PlottingHint.
|
|
|
+
|
|
|
+ \see setPlottingHint
|
|
|
+*/
|
|
|
+void QCustomPlot::setPlottingHints(const QCP::PlottingHints &hints)
|
|
|
+{
|
|
|
+ mPlottingHints = hints;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the specified plotting \a hint to \a enabled.
|
|
|
+
|
|
|
+ \see setPlottingHints
|
|
|
+*/
|
|
|
+void QCustomPlot::setPlottingHint(QCP::PlottingHint hint, bool enabled)
|
|
|
+{
|
|
|
+ QCP::PlottingHints newHints = mPlottingHints;
|
|
|
+ if (!enabled)
|
|
|
+ newHints &= ~hint;
|
|
|
+ else
|
|
|
+ newHints |= hint;
|
|
|
+
|
|
|
+ if (newHints != mPlottingHints)
|
|
|
+ setPlottingHints(newHints);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the keyboard modifier that will be recognized as multi-select-modifier.
|
|
|
+
|
|
|
+ If \ref QCP::iMultiSelect is specified in \ref setInteractions, the user may select multiple
|
|
|
+ objects (or data points) by clicking on them one after the other while holding down \a modifier.
|
|
|
+
|
|
|
+ By default the multi-select-modifier is set to Qt::ControlModifier.
|
|
|
+
|
|
|
+ \see setInteractions
|
|
|
+*/
|
|
|
+void QCustomPlot::setMultiSelectModifier(Qt::KeyboardModifier modifier)
|
|
|
+{
|
|
|
+ mMultiSelectModifier = modifier;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets how QCustomPlot processes mouse click-and-drag interactions by the user.
|
|
|
+
|
|
|
+ If \a mode is \ref QCP::srmNone, the mouse drag is forwarded to the underlying objects. For
|
|
|
+ example, QCPAxisRect may process a mouse drag by dragging axis ranges, see \ref
|
|
|
+ QCPAxisRect::setRangeDrag. If \a mode is not \ref QCP::srmNone, the current selection rect (\ref
|
|
|
+ selectionRect) becomes activated and allows e.g. rect zooming and data point selection.
|
|
|
+
|
|
|
+ If you wish to provide your user both with axis range dragging and data selection/range zooming,
|
|
|
+ use this method to switch between the modes just before the interaction is processed, e.g. in
|
|
|
+ reaction to the \ref mousePress or \ref mouseMove signals. For example you could check whether
|
|
|
+ the user is holding a certain keyboard modifier, and then decide which \a mode shall be set.
|
|
|
+
|
|
|
+ If a selection rect interaction is currently active, and \a mode is set to \ref QCP::srmNone, the
|
|
|
+ interaction is canceled (\ref QCPSelectionRect::cancel). Switching between any of the other modes
|
|
|
+ will keep the selection rect active. Upon completion of the interaction, the behaviour is as
|
|
|
+ defined by the currently set \a mode, not the mode that was set when the interaction started.
|
|
|
+
|
|
|
+ \see setInteractions, setSelectionRect, QCPSelectionRect
|
|
|
+*/
|
|
|
+void QCustomPlot::setSelectionRectMode(QCP::SelectionRectMode mode)
|
|
|
+{
|
|
|
+ if (mSelectionRect)
|
|
|
+ {
|
|
|
+ if (mode == QCP::srmNone)
|
|
|
+ mSelectionRect->cancel(); // when switching to none, we immediately want to abort a potentially active selection rect
|
|
|
+
|
|
|
+ // disconnect old connections:
|
|
|
+ if (mSelectionRectMode == QCP::srmSelect)
|
|
|
+ disconnect(mSelectionRect, SIGNAL(accepted(QRect,QMouseEvent*)), this, SLOT(processRectSelection(QRect,QMouseEvent*)));
|
|
|
+ else if (mSelectionRectMode == QCP::srmZoom)
|
|
|
+ disconnect(mSelectionRect, SIGNAL(accepted(QRect,QMouseEvent*)), this, SLOT(processRectZoom(QRect,QMouseEvent*)));
|
|
|
+
|
|
|
+ // establish new ones:
|
|
|
+ if (mode == QCP::srmSelect)
|
|
|
+ connect(mSelectionRect, SIGNAL(accepted(QRect,QMouseEvent*)), this, SLOT(processRectSelection(QRect,QMouseEvent*)));
|
|
|
+ else if (mode == QCP::srmZoom)
|
|
|
+ connect(mSelectionRect, SIGNAL(accepted(QRect,QMouseEvent*)), this, SLOT(processRectZoom(QRect,QMouseEvent*)));
|
|
|
+ }
|
|
|
+
|
|
|
+ mSelectionRectMode = mode;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the \ref QCPSelectionRect instance that QCustomPlot will use if \a mode is not \ref
|
|
|
+ QCP::srmNone and the user performs a click-and-drag interaction. QCustomPlot takes ownership of
|
|
|
+ the passed \a selectionRect. It can be accessed later via \ref selectionRect.
|
|
|
+
|
|
|
+ This method is useful if you wish to replace the default QCPSelectionRect instance with an
|
|
|
+ instance of a QCPSelectionRect subclass, to introduce custom behaviour of the selection rect.
|
|
|
+
|
|
|
+ \see setSelectionRectMode
|
|
|
+*/
|
|
|
+void QCustomPlot::setSelectionRect(QCPSelectionRect *selectionRect)
|
|
|
+{
|
|
|
+ if (mSelectionRect)
|
|
|
+ delete mSelectionRect;
|
|
|
+
|
|
|
+ mSelectionRect = selectionRect;
|
|
|
+
|
|
|
+ if (mSelectionRect)
|
|
|
+ {
|
|
|
+ // establish connections with new selection rect:
|
|
|
+ if (mSelectionRectMode == QCP::srmSelect)
|
|
|
+ connect(mSelectionRect, SIGNAL(accepted(QRect,QMouseEvent*)), this, SLOT(processRectSelection(QRect,QMouseEvent*)));
|
|
|
+ else if (mSelectionRectMode == QCP::srmZoom)
|
|
|
+ connect(mSelectionRect, SIGNAL(accepted(QRect,QMouseEvent*)), this, SLOT(processRectZoom(QRect,QMouseEvent*)));
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ \warning This is still an experimental feature and its performance depends on the system that it
|
|
|
+ runs on. Having multiple QCustomPlot widgets in one application with enabled OpenGL rendering
|
|
|
+ might cause context conflicts on some systems.
|
|
|
+
|
|
|
+ This method allows to enable OpenGL plot rendering, for increased plotting performance of
|
|
|
+ graphically demanding plots (thick lines, translucent fills, etc.).
|
|
|
+
|
|
|
+ If \a enabled is set to true, QCustomPlot will try to initialize OpenGL and, if successful,
|
|
|
+ continue plotting with hardware acceleration. The parameter \a multisampling controls how many
|
|
|
+ samples will be used per pixel, it essentially controls the antialiasing quality. If \a
|
|
|
+ multisampling is set too high for the current graphics hardware, the maximum allowed value will
|
|
|
+ be used.
|
|
|
+
|
|
|
+ You can test whether switching to OpenGL rendering was successful by checking whether the
|
|
|
+ according getter \a QCustomPlot::openGl() returns true. If the OpenGL initialization fails,
|
|
|
+ rendering continues with the regular software rasterizer, and an according qDebug output is
|
|
|
+ generated.
|
|
|
+
|
|
|
+ If switching to OpenGL was successful, this method disables label caching (\ref setPlottingHint
|
|
|
+ "setPlottingHint(QCP::phCacheLabels, false)") and turns on QCustomPlot's antialiasing override
|
|
|
+ for all elements (\ref setAntialiasedElements "setAntialiasedElements(QCP::aeAll)"), leading to a
|
|
|
+ higher quality output. The antialiasing override allows for pixel-grid aligned drawing in the
|
|
|
+ OpenGL paint device. As stated before, in OpenGL rendering the actual antialiasing of the plot is
|
|
|
+ controlled with \a multisampling. If \a enabled is set to false, the antialiasing/label caching
|
|
|
+ settings are restored to what they were before OpenGL was enabled, if they weren't altered in the
|
|
|
+ meantime.
|
|
|
+
|
|
|
+ \note OpenGL support is only enabled if QCustomPlot is compiled with the macro \c QCUSTOMPLOT_USE_OPENGL
|
|
|
+ defined. This define must be set before including the QCustomPlot header both during compilation
|
|
|
+ of the QCustomPlot library as well as when compiling your application. It is best to just include
|
|
|
+ the line <tt>DEFINES += QCUSTOMPLOT_USE_OPENGL</tt> in the respective qmake project files.
|
|
|
+ \note If you are using a Qt version before 5.0, you must also add the module "opengl" to your \c
|
|
|
+ QT variable in the qmake project files. For Qt versions 5.0 and higher, QCustomPlot switches to a
|
|
|
+ newer OpenGL interface which is already in the "gui" module.
|
|
|
+*/
|
|
|
+void QCustomPlot::setOpenGl(bool enabled, int multisampling)
|
|
|
+{
|
|
|
+ mOpenGlMultisamples = qMax(0, multisampling);
|
|
|
+#ifdef QCUSTOMPLOT_USE_OPENGL
|
|
|
+ mOpenGl = enabled;
|
|
|
+ if (mOpenGl)
|
|
|
+ {
|
|
|
+ if (setupOpenGl())
|
|
|
+ {
|
|
|
+ // backup antialiasing override and labelcaching setting so we can restore upon disabling OpenGL
|
|
|
+ mOpenGlAntialiasedElementsBackup = mAntialiasedElements;
|
|
|
+ mOpenGlCacheLabelsBackup = mPlottingHints.testFlag(QCP::phCacheLabels);
|
|
|
+ // set antialiasing override to antialias all (aligns gl pixel grid properly), and disable label caching (would use software rasterizer for pixmap caches):
|
|
|
+ setAntialiasedElements(QCP::aeAll);
|
|
|
+ setPlottingHint(QCP::phCacheLabels, false);
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "Failed to enable OpenGL, continuing plotting without hardware acceleration.";
|
|
|
+ mOpenGl = false;
|
|
|
+ }
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ // restore antialiasing override and labelcaching to what it was before enabling OpenGL, if nobody changed it in the meantime:
|
|
|
+ if (mAntialiasedElements == QCP::aeAll)
|
|
|
+ setAntialiasedElements(mOpenGlAntialiasedElementsBackup);
|
|
|
+ if (!mPlottingHints.testFlag(QCP::phCacheLabels))
|
|
|
+ setPlottingHint(QCP::phCacheLabels, mOpenGlCacheLabelsBackup);
|
|
|
+ freeOpenGl();
|
|
|
+ }
|
|
|
+ // recreate all paint buffers:
|
|
|
+ mPaintBuffers.clear();
|
|
|
+ setupPaintBuffers();
|
|
|
+#else
|
|
|
+ Q_UNUSED(enabled)
|
|
|
+ qDebug() << Q_FUNC_INFO << "QCustomPlot can't use OpenGL because QCUSTOMPLOT_USE_OPENGL was not defined during compilation (add 'DEFINES += QCUSTOMPLOT_USE_OPENGL' to your qmake .pro file)";
|
|
|
+#endif
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the viewport of this QCustomPlot. Usually users of QCustomPlot don't need to change the
|
|
|
+ viewport manually.
|
|
|
+
|
|
|
+ The viewport is the area in which the plot is drawn. All mechanisms, e.g. margin caluclation take
|
|
|
+ the viewport to be the outer border of the plot. The viewport normally is the rect() of the
|
|
|
+ QCustomPlot widget, i.e. a rect with top left (0, 0) and size of the QCustomPlot widget.
|
|
|
+
|
|
|
+ Don't confuse the viewport with the axis rect (QCustomPlot::axisRect). An axis rect is typically
|
|
|
+ an area enclosed by four axes, where the graphs/plottables are drawn in. The viewport is larger
|
|
|
+ and contains also the axes themselves, their tick numbers, their labels, or even additional axis
|
|
|
+ rects, color scales and other layout elements.
|
|
|
+
|
|
|
+ This function is used to allow arbitrary size exports with \ref toPixmap, \ref savePng, \ref
|
|
|
+ savePdf, etc. by temporarily changing the viewport size.
|
|
|
+*/
|
|
|
+void QCustomPlot::setViewport(const QRect &rect)
|
|
|
+{
|
|
|
+ mViewport = rect;
|
|
|
+ if (mPlotLayout)
|
|
|
+ mPlotLayout->setOuterRect(mViewport);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the device pixel ratio used by the paint buffers of this QCustomPlot instance.
|
|
|
+
|
|
|
+ Normally, this doesn't need to be set manually, because it is initialized with the regular \a
|
|
|
+ QWidget::devicePixelRatio which is configured by Qt to fit the display device (e.g. 1 for normal
|
|
|
+ displays, 2 for High-DPI displays).
|
|
|
+
|
|
|
+ Device pixel ratios are supported by Qt only for Qt versions since 5.4. If this method is called
|
|
|
+ when QCustomPlot is being used with older Qt versions, outputs an according qDebug message and
|
|
|
+ leaves the internal buffer device pixel ratio at 1.0.
|
|
|
+*/
|
|
|
+void QCustomPlot::setBufferDevicePixelRatio(double ratio)
|
|
|
+{
|
|
|
+ if (!qFuzzyCompare(ratio, mBufferDevicePixelRatio))
|
|
|
+ {
|
|
|
+#ifdef QCP_DEVICEPIXELRATIO_SUPPORTED
|
|
|
+ mBufferDevicePixelRatio = ratio;
|
|
|
+ for (int i=0; i<mPaintBuffers.size(); ++i)
|
|
|
+ mPaintBuffers.at(i)->setDevicePixelRatio(mBufferDevicePixelRatio);
|
|
|
+ // Note: axis label cache has devicePixelRatio as part of cache hash, so no need to manually clear cache here
|
|
|
+#else
|
|
|
+ qDebug() << Q_FUNC_INFO << "Device pixel ratios not supported for Qt versions before 5.4";
|
|
|
+ mBufferDevicePixelRatio = 1.0;
|
|
|
+#endif
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets \a pm as the viewport background pixmap (see \ref setViewport). The pixmap is always drawn
|
|
|
+ below all other objects in the plot.
|
|
|
+
|
|
|
+ For cases where the provided pixmap doesn't have the same size as the viewport, scaling can be
|
|
|
+ enabled with \ref setBackgroundScaled and the scaling mode (whether and how the aspect ratio is
|
|
|
+ preserved) can be set with \ref setBackgroundScaledMode. To set all these options in one call,
|
|
|
+ consider using the overloaded version of this function.
|
|
|
+
|
|
|
+ If a background brush was set with \ref setBackground(const QBrush &brush), the viewport will
|
|
|
+ first be filled with that brush, before drawing the background pixmap. This can be useful for
|
|
|
+ background pixmaps with translucent areas.
|
|
|
+
|
|
|
+ \see setBackgroundScaled, setBackgroundScaledMode
|
|
|
+*/
|
|
|
+void QCustomPlot::setBackground(const QPixmap &pm)
|
|
|
+{
|
|
|
+ mBackgroundPixmap = pm;
|
|
|
+ mScaledBackgroundPixmap = QPixmap();
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the background brush of the viewport (see \ref setViewport).
|
|
|
+
|
|
|
+ Before drawing everything else, the background is filled with \a brush. If a background pixmap
|
|
|
+ was set with \ref setBackground(const QPixmap &pm), this brush will be used to fill the viewport
|
|
|
+ before the background pixmap is drawn. This can be useful for background pixmaps with translucent
|
|
|
+ areas.
|
|
|
+
|
|
|
+ Set \a brush to Qt::NoBrush or Qt::Transparent to leave background transparent. This can be
|
|
|
+ useful for exporting to image formats which support transparency, e.g. \ref savePng.
|
|
|
+
|
|
|
+ \see setBackgroundScaled, setBackgroundScaledMode
|
|
|
+*/
|
|
|
+void QCustomPlot::setBackground(const QBrush &brush)
|
|
|
+{
|
|
|
+ mBackgroundBrush = brush;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Allows setting the background pixmap of the viewport, whether it shall be scaled and how it
|
|
|
+ shall be scaled in one call.
|
|
|
+
|
|
|
+ \see setBackground(const QPixmap &pm), setBackgroundScaled, setBackgroundScaledMode
|
|
|
+*/
|
|
|
+void QCustomPlot::setBackground(const QPixmap &pm, bool scaled, Qt::AspectRatioMode mode)
|
|
|
+{
|
|
|
+ mBackgroundPixmap = pm;
|
|
|
+ mScaledBackgroundPixmap = QPixmap();
|
|
|
+ mBackgroundScaled = scaled;
|
|
|
+ mBackgroundScaledMode = mode;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets whether the viewport background pixmap shall be scaled to fit the viewport. If \a scaled is
|
|
|
+ set to true, control whether and how the aspect ratio of the original pixmap is preserved with
|
|
|
+ \ref setBackgroundScaledMode.
|
|
|
+
|
|
|
+ Note that the scaled version of the original pixmap is buffered, so there is no performance
|
|
|
+ penalty on replots. (Except when the viewport dimensions are changed continuously.)
|
|
|
+
|
|
|
+ \see setBackground, setBackgroundScaledMode
|
|
|
+*/
|
|
|
+void QCustomPlot::setBackgroundScaled(bool scaled)
|
|
|
+{
|
|
|
+ mBackgroundScaled = scaled;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ If scaling of the viewport background pixmap is enabled (\ref setBackgroundScaled), use this
|
|
|
+ function to define whether and how the aspect ratio of the original pixmap is preserved.
|
|
|
+
|
|
|
+ \see setBackground, setBackgroundScaled
|
|
|
+*/
|
|
|
+void QCustomPlot::setBackgroundScaledMode(Qt::AspectRatioMode mode)
|
|
|
+{
|
|
|
+ mBackgroundScaledMode = mode;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns the plottable with \a index. If the index is invalid, returns 0.
|
|
|
+
|
|
|
+ There is an overloaded version of this function with no parameter which returns the last added
|
|
|
+ plottable, see QCustomPlot::plottable()
|
|
|
+
|
|
|
+ \see plottableCount
|
|
|
+*/
|
|
|
+QCPAbstractPlottable *QCustomPlot::plottable(int index)
|
|
|
+{
|
|
|
+ if (index >= 0 && index < mPlottables.size())
|
|
|
+ {
|
|
|
+ return mPlottables.at(index);
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "index out of bounds:" << index;
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Returns the last plottable that was added to the plot. If there are no plottables in the plot,
|
|
|
+ returns 0.
|
|
|
+
|
|
|
+ \see plottableCount
|
|
|
+*/
|
|
|
+QCPAbstractPlottable *QCustomPlot::plottable()
|
|
|
+{
|
|
|
+ if (!mPlottables.isEmpty())
|
|
|
+ {
|
|
|
+ return mPlottables.last();
|
|
|
+ } else
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Removes the specified plottable from the plot and deletes it. If necessary, the corresponding
|
|
|
+ legend item is also removed from the default legend (QCustomPlot::legend).
|
|
|
+
|
|
|
+ Returns true on success.
|
|
|
+
|
|
|
+ \see clearPlottables
|
|
|
+*/
|
|
|
+bool QCustomPlot::removePlottable(QCPAbstractPlottable *plottable)
|
|
|
+{
|
|
|
+ if (!mPlottables.contains(plottable))
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "plottable not in list:" << reinterpret_cast<quintptr>(plottable);
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ // remove plottable from legend:
|
|
|
+ plottable->removeFromLegend();
|
|
|
+ // special handling for QCPGraphs to maintain the simple graph interface:
|
|
|
+ if (QCPGraph *graph = qobject_cast<QCPGraph*>(plottable))
|
|
|
+ mGraphs.removeOne(graph);
|
|
|
+ // remove plottable:
|
|
|
+ delete plottable;
|
|
|
+ mPlottables.removeOne(plottable);
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Removes and deletes the plottable by its \a index.
|
|
|
+*/
|
|
|
+bool QCustomPlot::removePlottable(int index)
|
|
|
+{
|
|
|
+ if (index >= 0 && index < mPlottables.size())
|
|
|
+ return removePlottable(mPlottables[index]);
|
|
|
+ else
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "index out of bounds:" << index;
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Removes all plottables from the plot and deletes them. Corresponding legend items are also
|
|
|
+ removed from the default legend (QCustomPlot::legend).
|
|
|
+
|
|
|
+ Returns the number of plottables removed.
|
|
|
+
|
|
|
+ \see removePlottable
|
|
|
+*/
|
|
|
+int QCustomPlot::clearPlottables()
|
|
|
+{
|
|
|
+ int c = mPlottables.size();
|
|
|
+ for (int i=c-1; i >= 0; --i)
|
|
|
+ removePlottable(mPlottables[i]);
|
|
|
+ return c;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns the number of currently existing plottables in the plot
|
|
|
+
|
|
|
+ \see plottable
|
|
|
+*/
|
|
|
+int QCustomPlot::plottableCount() const
|
|
|
+{
|
|
|
+ return mPlottables.size();
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns a list of the selected plottables. If no plottables are currently selected, the list is empty.
|
|
|
+
|
|
|
+ There is a convenience function if you're only interested in selected graphs, see \ref selectedGraphs.
|
|
|
+
|
|
|
+ \see setInteractions, QCPAbstractPlottable::setSelectable, QCPAbstractPlottable::setSelection
|
|
|
+*/
|
|
|
+QList<QCPAbstractPlottable*> QCustomPlot::selectedPlottables() const
|
|
|
+{
|
|
|
+ QList<QCPAbstractPlottable*> result;
|
|
|
+ foreach (QCPAbstractPlottable *plottable, mPlottables)
|
|
|
+ {
|
|
|
+ if (plottable->selected())
|
|
|
+ result.append(plottable);
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns the plottable at the pixel position \a pos. Plottables that only consist of single lines
|
|
|
+ (like graphs) have a tolerance band around them, see \ref setSelectionTolerance. If multiple
|
|
|
+ plottables come into consideration, the one closest to \a pos is returned.
|
|
|
+
|
|
|
+ If \a onlySelectable is true, only plottables that are selectable
|
|
|
+ (QCPAbstractPlottable::setSelectable) are considered.
|
|
|
+
|
|
|
+ If there is no plottable at \a pos, the return value is 0.
|
|
|
+
|
|
|
+ \see itemAt, layoutElementAt
|
|
|
+*/
|
|
|
+QCPAbstractPlottable *QCustomPlot::plottableAt(const QPointF &pos, bool onlySelectable) const
|
|
|
+{
|
|
|
+ QCPAbstractPlottable *resultPlottable = 0;
|
|
|
+ double resultDistance = mSelectionTolerance; // only regard clicks with distances smaller than mSelectionTolerance as selections, so initialize with that value
|
|
|
+
|
|
|
+ foreach (QCPAbstractPlottable *plottable, mPlottables)
|
|
|
+ {
|
|
|
+ if (onlySelectable && !plottable->selectable()) // we could have also passed onlySelectable to the selectTest function, but checking here is faster, because we have access to QCPabstractPlottable::selectable
|
|
|
+ continue;
|
|
|
+ if ((plottable->keyAxis()->axisRect()->rect() & plottable->valueAxis()->axisRect()->rect()).contains(pos.toPoint())) // only consider clicks inside the rect that is spanned by the plottable's key/value axes
|
|
|
+ {
|
|
|
+ double currentDistance = plottable->selectTest(pos, false);
|
|
|
+ if (currentDistance >= 0 && currentDistance < resultDistance)
|
|
|
+ {
|
|
|
+ resultPlottable = plottable;
|
|
|
+ resultDistance = currentDistance;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return resultPlottable;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns whether this QCustomPlot instance contains the \a plottable.
|
|
|
+*/
|
|
|
+bool QCustomPlot::hasPlottable(QCPAbstractPlottable *plottable) const
|
|
|
+{
|
|
|
+ return mPlottables.contains(plottable);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns the graph with \a index. If the index is invalid, returns 0.
|
|
|
+
|
|
|
+ There is an overloaded version of this function with no parameter which returns the last created
|
|
|
+ graph, see QCustomPlot::graph()
|
|
|
+
|
|
|
+ \see graphCount, addGraph
|
|
|
+*/
|
|
|
+QCPGraph *QCustomPlot::graph(int index) const
|
|
|
+{
|
|
|
+ if (index >= 0 && index < mGraphs.size())
|
|
|
+ {
|
|
|
+ return mGraphs.at(index);
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "index out of bounds:" << index;
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Returns the last graph, that was created with \ref addGraph. If there are no graphs in the plot,
|
|
|
+ returns 0.
|
|
|
+
|
|
|
+ \see graphCount, addGraph
|
|
|
+*/
|
|
|
+QCPGraph *QCustomPlot::graph() const
|
|
|
+{
|
|
|
+ if (!mGraphs.isEmpty())
|
|
|
+ {
|
|
|
+ return mGraphs.last();
|
|
|
+ } else
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Creates a new graph inside the plot. If \a keyAxis and \a valueAxis are left unspecified (0), the
|
|
|
+ bottom (xAxis) is used as key and the left (yAxis) is used as value axis. If specified, \a
|
|
|
+ keyAxis and \a valueAxis must reside in this QCustomPlot.
|
|
|
+
|
|
|
+ \a keyAxis will be used as key axis (typically "x") and \a valueAxis as value axis (typically
|
|
|
+ "y") for the graph.
|
|
|
+
|
|
|
+ Returns a pointer to the newly created graph, or 0 if adding the graph failed.
|
|
|
+
|
|
|
+ \see graph, graphCount, removeGraph, clearGraphs
|
|
|
+*/
|
|
|
+QCPGraph *QCustomPlot::addGraph(QCPAxis *keyAxis, QCPAxis *valueAxis)
|
|
|
+{
|
|
|
+ if (!keyAxis) keyAxis = xAxis;
|
|
|
+ if (!valueAxis) valueAxis = yAxis;
|
|
|
+ if (!keyAxis || !valueAxis)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "can't use default QCustomPlot xAxis or yAxis, because at least one is invalid (has been deleted)";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ if (keyAxis->parentPlot() != this || valueAxis->parentPlot() != this)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "passed keyAxis or valueAxis doesn't have this QCustomPlot as parent";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ QCPGraph *newGraph = new QCPGraph(keyAxis, valueAxis);
|
|
|
+ newGraph->setName(QLatin1String("Graph ")+QString::number(mGraphs.size()));
|
|
|
+ return newGraph;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Removes the specified \a graph from the plot and deletes it. If necessary, the corresponding
|
|
|
+ legend item is also removed from the default legend (QCustomPlot::legend). If any other graphs in
|
|
|
+ the plot have a channel fill set towards the removed graph, the channel fill property of those
|
|
|
+ graphs is reset to zero (no channel fill).
|
|
|
+
|
|
|
+ Returns true on success.
|
|
|
+
|
|
|
+ \see clearGraphs
|
|
|
+*/
|
|
|
+bool QCustomPlot::removeGraph(QCPGraph *graph)
|
|
|
+{
|
|
|
+ return removePlottable(graph);
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Removes and deletes the graph by its \a index.
|
|
|
+*/
|
|
|
+bool QCustomPlot::removeGraph(int index)
|
|
|
+{
|
|
|
+ if (index >= 0 && index < mGraphs.size())
|
|
|
+ return removeGraph(mGraphs[index]);
|
|
|
+ else
|
|
|
+ return false;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Removes all graphs from the plot and deletes them. Corresponding legend items are also removed
|
|
|
+ from the default legend (QCustomPlot::legend).
|
|
|
+
|
|
|
+ Returns the number of graphs removed.
|
|
|
+
|
|
|
+ \see removeGraph
|
|
|
+*/
|
|
|
+int QCustomPlot::clearGraphs()
|
|
|
+{
|
|
|
+ int c = mGraphs.size();
|
|
|
+ for (int i=c-1; i >= 0; --i)
|
|
|
+ removeGraph(mGraphs[i]);
|
|
|
+ return c;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns the number of currently existing graphs in the plot
|
|
|
+
|
|
|
+ \see graph, addGraph
|
|
|
+*/
|
|
|
+int QCustomPlot::graphCount() const
|
|
|
+{
|
|
|
+ return mGraphs.size();
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns a list of the selected graphs. If no graphs are currently selected, the list is empty.
|
|
|
+
|
|
|
+ If you are not only interested in selected graphs but other plottables like QCPCurve, QCPBars,
|
|
|
+ etc., use \ref selectedPlottables.
|
|
|
+
|
|
|
+ \see setInteractions, selectedPlottables, QCPAbstractPlottable::setSelectable, QCPAbstractPlottable::setSelection
|
|
|
+*/
|
|
|
+QList<QCPGraph*> QCustomPlot::selectedGraphs() const
|
|
|
+{
|
|
|
+ QList<QCPGraph*> result;
|
|
|
+ foreach (QCPGraph *graph, mGraphs)
|
|
|
+ {
|
|
|
+ if (graph->selected())
|
|
|
+ result.append(graph);
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns the item with \a index. If the index is invalid, returns 0.
|
|
|
+
|
|
|
+ There is an overloaded version of this function with no parameter which returns the last added
|
|
|
+ item, see QCustomPlot::item()
|
|
|
+
|
|
|
+ \see itemCount
|
|
|
+*/
|
|
|
+QCPAbstractItem *QCustomPlot::item(int index) const
|
|
|
+{
|
|
|
+ if (index >= 0 && index < mItems.size())
|
|
|
+ {
|
|
|
+ return mItems.at(index);
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "index out of bounds:" << index;
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Returns the last item that was added to this plot. If there are no items in the plot,
|
|
|
+ returns 0.
|
|
|
+
|
|
|
+ \see itemCount
|
|
|
+*/
|
|
|
+QCPAbstractItem *QCustomPlot::item() const
|
|
|
+{
|
|
|
+ if (!mItems.isEmpty())
|
|
|
+ {
|
|
|
+ return mItems.last();
|
|
|
+ } else
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Removes the specified item from the plot and deletes it.
|
|
|
+
|
|
|
+ Returns true on success.
|
|
|
+
|
|
|
+ \see clearItems
|
|
|
+*/
|
|
|
+bool QCustomPlot::removeItem(QCPAbstractItem *item)
|
|
|
+{
|
|
|
+ if (mItems.contains(item))
|
|
|
+ {
|
|
|
+ delete item;
|
|
|
+ mItems.removeOne(item);
|
|
|
+ return true;
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "item not in list:" << reinterpret_cast<quintptr>(item);
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Removes and deletes the item by its \a index.
|
|
|
+*/
|
|
|
+bool QCustomPlot::removeItem(int index)
|
|
|
+{
|
|
|
+ if (index >= 0 && index < mItems.size())
|
|
|
+ return removeItem(mItems[index]);
|
|
|
+ else
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "index out of bounds:" << index;
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Removes all items from the plot and deletes them.
|
|
|
+
|
|
|
+ Returns the number of items removed.
|
|
|
+
|
|
|
+ \see removeItem
|
|
|
+*/
|
|
|
+int QCustomPlot::clearItems()
|
|
|
+{
|
|
|
+ int c = mItems.size();
|
|
|
+ for (int i=c-1; i >= 0; --i)
|
|
|
+ removeItem(mItems[i]);
|
|
|
+ return c;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns the number of currently existing items in the plot
|
|
|
+
|
|
|
+ \see item
|
|
|
+*/
|
|
|
+int QCustomPlot::itemCount() const
|
|
|
+{
|
|
|
+ return mItems.size();
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns a list of the selected items. If no items are currently selected, the list is empty.
|
|
|
+
|
|
|
+ \see setInteractions, QCPAbstractItem::setSelectable, QCPAbstractItem::setSelected
|
|
|
+*/
|
|
|
+QList<QCPAbstractItem*> QCustomPlot::selectedItems() const
|
|
|
+{
|
|
|
+ QList<QCPAbstractItem*> result;
|
|
|
+ foreach (QCPAbstractItem *item, mItems)
|
|
|
+ {
|
|
|
+ if (item->selected())
|
|
|
+ result.append(item);
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns the item at the pixel position \a pos. Items that only consist of single lines (e.g. \ref
|
|
|
+ QCPItemLine or \ref QCPItemCurve) have a tolerance band around them, see \ref
|
|
|
+ setSelectionTolerance. If multiple items come into consideration, the one closest to \a pos is
|
|
|
+ returned.
|
|
|
+
|
|
|
+ If \a onlySelectable is true, only items that are selectable (QCPAbstractItem::setSelectable) are
|
|
|
+ considered.
|
|
|
+
|
|
|
+ If there is no item at \a pos, the return value is 0.
|
|
|
+
|
|
|
+ \see plottableAt, layoutElementAt
|
|
|
+*/
|
|
|
+QCPAbstractItem *QCustomPlot::itemAt(const QPointF &pos, bool onlySelectable) const
|
|
|
+{
|
|
|
+ QCPAbstractItem *resultItem = 0;
|
|
|
+ double resultDistance = mSelectionTolerance; // only regard clicks with distances smaller than mSelectionTolerance as selections, so initialize with that value
|
|
|
+
|
|
|
+ foreach (QCPAbstractItem *item, mItems)
|
|
|
+ {
|
|
|
+ if (onlySelectable && !item->selectable()) // we could have also passed onlySelectable to the selectTest function, but checking here is faster, because we have access to QCPAbstractItem::selectable
|
|
|
+ continue;
|
|
|
+ if (!item->clipToAxisRect() || item->clipRect().contains(pos.toPoint())) // only consider clicks inside axis cliprect of the item if actually clipped to it
|
|
|
+ {
|
|
|
+ double currentDistance = item->selectTest(pos, false);
|
|
|
+ if (currentDistance >= 0 && currentDistance < resultDistance)
|
|
|
+ {
|
|
|
+ resultItem = item;
|
|
|
+ resultDistance = currentDistance;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return resultItem;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns whether this QCustomPlot contains the \a item.
|
|
|
+
|
|
|
+ \see item
|
|
|
+*/
|
|
|
+bool QCustomPlot::hasItem(QCPAbstractItem *item) const
|
|
|
+{
|
|
|
+ return mItems.contains(item);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns the layer with the specified \a name. If there is no layer with the specified name, 0 is
|
|
|
+ returned.
|
|
|
+
|
|
|
+ Layer names are case-sensitive.
|
|
|
+
|
|
|
+ \see addLayer, moveLayer, removeLayer
|
|
|
+*/
|
|
|
+QCPLayer *QCustomPlot::layer(const QString &name) const
|
|
|
+{
|
|
|
+ foreach (QCPLayer *layer, mLayers)
|
|
|
+ {
|
|
|
+ if (layer->name() == name)
|
|
|
+ return layer;
|
|
|
+ }
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Returns the layer by \a index. If the index is invalid, 0 is returned.
|
|
|
+
|
|
|
+ \see addLayer, moveLayer, removeLayer
|
|
|
+*/
|
|
|
+QCPLayer *QCustomPlot::layer(int index) const
|
|
|
+{
|
|
|
+ if (index >= 0 && index < mLayers.size())
|
|
|
+ {
|
|
|
+ return mLayers.at(index);
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "index out of bounds:" << index;
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns the layer that is set as current layer (see \ref setCurrentLayer).
|
|
|
+*/
|
|
|
+QCPLayer *QCustomPlot::currentLayer() const
|
|
|
+{
|
|
|
+ return mCurrentLayer;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the layer with the specified \a name to be the current layer. All layerables (\ref
|
|
|
+ QCPLayerable), e.g. plottables and items, are created on the current layer.
|
|
|
+
|
|
|
+ Returns true on success, i.e. if there is a layer with the specified \a name in the QCustomPlot.
|
|
|
+
|
|
|
+ Layer names are case-sensitive.
|
|
|
+
|
|
|
+ \see addLayer, moveLayer, removeLayer, QCPLayerable::setLayer
|
|
|
+*/
|
|
|
+bool QCustomPlot::setCurrentLayer(const QString &name)
|
|
|
+{
|
|
|
+ if (QCPLayer *newCurrentLayer = layer(name))
|
|
|
+ {
|
|
|
+ return setCurrentLayer(newCurrentLayer);
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "layer with name doesn't exist:" << name;
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Sets the provided \a layer to be the current layer.
|
|
|
+
|
|
|
+ Returns true on success, i.e. when \a layer is a valid layer in the QCustomPlot.
|
|
|
+
|
|
|
+ \see addLayer, moveLayer, removeLayer
|
|
|
+*/
|
|
|
+bool QCustomPlot::setCurrentLayer(QCPLayer *layer)
|
|
|
+{
|
|
|
+ if (!mLayers.contains(layer))
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "layer not a layer of this QCustomPlot:" << reinterpret_cast<quintptr>(layer);
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ mCurrentLayer = layer;
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns the number of currently existing layers in the plot
|
|
|
+
|
|
|
+ \see layer, addLayer
|
|
|
+*/
|
|
|
+int QCustomPlot::layerCount() const
|
|
|
+{
|
|
|
+ return mLayers.size();
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Adds a new layer to this QCustomPlot instance. The new layer will have the name \a name, which
|
|
|
+ must be unique. Depending on \a insertMode, it is positioned either below or above \a otherLayer.
|
|
|
+
|
|
|
+ Returns true on success, i.e. if there is no other layer named \a name and \a otherLayer is a
|
|
|
+ valid layer inside this QCustomPlot.
|
|
|
+
|
|
|
+ If \a otherLayer is 0, the highest layer in the QCustomPlot will be used.
|
|
|
+
|
|
|
+ For an explanation of what layers are in QCustomPlot, see the documentation of \ref QCPLayer.
|
|
|
+
|
|
|
+ \see layer, moveLayer, removeLayer
|
|
|
+*/
|
|
|
+bool QCustomPlot::addLayer(const QString &name, QCPLayer *otherLayer, QCustomPlot::LayerInsertMode insertMode)
|
|
|
+{
|
|
|
+ if (!otherLayer)
|
|
|
+ otherLayer = mLayers.last();
|
|
|
+ if (!mLayers.contains(otherLayer))
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "otherLayer not a layer of this QCustomPlot:" << reinterpret_cast<quintptr>(otherLayer);
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ if (layer(name))
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "A layer exists already with the name" << name;
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ QCPLayer *newLayer = new QCPLayer(this, name);
|
|
|
+ mLayers.insert(otherLayer->index() + (insertMode==limAbove ? 1:0), newLayer);
|
|
|
+ updateLayerIndices();
|
|
|
+ setupPaintBuffers(); // associates new layer with the appropriate paint buffer
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Removes the specified \a layer and returns true on success.
|
|
|
+
|
|
|
+ All layerables (e.g. plottables and items) on the removed layer will be moved to the layer below
|
|
|
+ \a layer. If \a layer is the bottom layer, the layerables are moved to the layer above. In both
|
|
|
+ cases, the total rendering order of all layerables in the QCustomPlot is preserved.
|
|
|
+
|
|
|
+ If \a layer is the current layer (\ref setCurrentLayer), the layer below (or above, if bottom
|
|
|
+ layer) becomes the new current layer.
|
|
|
+
|
|
|
+ It is not possible to remove the last layer of the plot.
|
|
|
+
|
|
|
+ \see layer, addLayer, moveLayer
|
|
|
+*/
|
|
|
+bool QCustomPlot::removeLayer(QCPLayer *layer)
|
|
|
+{
|
|
|
+ if (!mLayers.contains(layer))
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "layer not a layer of this QCustomPlot:" << reinterpret_cast<quintptr>(layer);
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ if (mLayers.size() < 2)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "can't remove last layer";
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ // append all children of this layer to layer below (if this is lowest layer, prepend to layer above)
|
|
|
+ int removedIndex = layer->index();
|
|
|
+ bool isFirstLayer = removedIndex==0;
|
|
|
+ QCPLayer *targetLayer = isFirstLayer ? mLayers.at(removedIndex+1) : mLayers.at(removedIndex-1);
|
|
|
+ QList<QCPLayerable*> children = layer->children();
|
|
|
+ if (isFirstLayer) // prepend in reverse order (so order relative to each other stays the same)
|
|
|
+ {
|
|
|
+ for (int i=children.size()-1; i>=0; --i)
|
|
|
+ children.at(i)->moveToLayer(targetLayer, true);
|
|
|
+ } else // append normally
|
|
|
+ {
|
|
|
+ for (int i=0; i<children.size(); ++i)
|
|
|
+ children.at(i)->moveToLayer(targetLayer, false);
|
|
|
+ }
|
|
|
+ // if removed layer is current layer, change current layer to layer below/above:
|
|
|
+ if (layer == mCurrentLayer)
|
|
|
+ setCurrentLayer(targetLayer);
|
|
|
+ // invalidate the paint buffer that was responsible for this layer:
|
|
|
+ if (!layer->mPaintBuffer.isNull())
|
|
|
+ layer->mPaintBuffer.data()->setInvalidated();
|
|
|
+ // remove layer:
|
|
|
+ delete layer;
|
|
|
+ mLayers.removeOne(layer);
|
|
|
+ updateLayerIndices();
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Moves the specified \a layer either above or below \a otherLayer. Whether it's placed above or
|
|
|
+ below is controlled with \a insertMode.
|
|
|
+
|
|
|
+ Returns true on success, i.e. when both \a layer and \a otherLayer are valid layers in the
|
|
|
+ QCustomPlot.
|
|
|
+
|
|
|
+ \see layer, addLayer, moveLayer
|
|
|
+*/
|
|
|
+bool QCustomPlot::moveLayer(QCPLayer *layer, QCPLayer *otherLayer, QCustomPlot::LayerInsertMode insertMode)
|
|
|
+{
|
|
|
+ if (!mLayers.contains(layer))
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "layer not a layer of this QCustomPlot:" << reinterpret_cast<quintptr>(layer);
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ if (!mLayers.contains(otherLayer))
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "otherLayer not a layer of this QCustomPlot:" << reinterpret_cast<quintptr>(otherLayer);
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (layer->index() > otherLayer->index())
|
|
|
+ mLayers.move(layer->index(), otherLayer->index() + (insertMode==limAbove ? 1:0));
|
|
|
+ else if (layer->index() < otherLayer->index())
|
|
|
+ mLayers.move(layer->index(), otherLayer->index() + (insertMode==limAbove ? 0:-1));
|
|
|
+
|
|
|
+ // invalidate the paint buffers that are responsible for the layers:
|
|
|
+ if (!layer->mPaintBuffer.isNull())
|
|
|
+ layer->mPaintBuffer.data()->setInvalidated();
|
|
|
+ if (!otherLayer->mPaintBuffer.isNull())
|
|
|
+ otherLayer->mPaintBuffer.data()->setInvalidated();
|
|
|
+
|
|
|
+ updateLayerIndices();
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns the number of axis rects in the plot.
|
|
|
+
|
|
|
+ All axis rects can be accessed via QCustomPlot::axisRect().
|
|
|
+
|
|
|
+ Initially, only one axis rect exists in the plot.
|
|
|
+
|
|
|
+ \see axisRect, axisRects
|
|
|
+*/
|
|
|
+int QCustomPlot::axisRectCount() const
|
|
|
+{
|
|
|
+ return axisRects().size();
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns the axis rect with \a index.
|
|
|
+
|
|
|
+ Initially, only one axis rect (with index 0) exists in the plot. If multiple axis rects were
|
|
|
+ added, all of them may be accessed with this function in a linear fashion (even when they are
|
|
|
+ nested in a layout hierarchy or inside other axis rects via QCPAxisRect::insetLayout).
|
|
|
+
|
|
|
+ \see axisRectCount, axisRects
|
|
|
+*/
|
|
|
+QCPAxisRect *QCustomPlot::axisRect(int index) const
|
|
|
+{
|
|
|
+ const QList<QCPAxisRect*> rectList = axisRects();
|
|
|
+ if (index >= 0 && index < rectList.size())
|
|
|
+ {
|
|
|
+ return rectList.at(index);
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "invalid axis rect index" << index;
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns all axis rects in the plot.
|
|
|
+
|
|
|
+ \see axisRectCount, axisRect
|
|
|
+*/
|
|
|
+QList<QCPAxisRect*> QCustomPlot::axisRects() const
|
|
|
+{
|
|
|
+ QList<QCPAxisRect*> result;
|
|
|
+ QStack<QCPLayoutElement*> elementStack;
|
|
|
+ if (mPlotLayout)
|
|
|
+ elementStack.push(mPlotLayout);
|
|
|
+
|
|
|
+ while (!elementStack.isEmpty())
|
|
|
+ {
|
|
|
+ foreach (QCPLayoutElement *element, elementStack.pop()->elements(false))
|
|
|
+ {
|
|
|
+ if (element)
|
|
|
+ {
|
|
|
+ elementStack.push(element);
|
|
|
+ if (QCPAxisRect *ar = qobject_cast<QCPAxisRect*>(element))
|
|
|
+ result.append(ar);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns the layout element at pixel position \a pos. If there is no element at that position,
|
|
|
+ returns 0.
|
|
|
+
|
|
|
+ Only visible elements are used. If \ref QCPLayoutElement::setVisible on the element itself or on
|
|
|
+ any of its parent elements is set to false, it will not be considered.
|
|
|
+
|
|
|
+ \see itemAt, plottableAt
|
|
|
+*/
|
|
|
+QCPLayoutElement *QCustomPlot::layoutElementAt(const QPointF &pos) const
|
|
|
+{
|
|
|
+ QCPLayoutElement *currentElement = mPlotLayout;
|
|
|
+ bool searchSubElements = true;
|
|
|
+ while (searchSubElements && currentElement)
|
|
|
+ {
|
|
|
+ searchSubElements = false;
|
|
|
+ foreach (QCPLayoutElement *subElement, currentElement->elements(false))
|
|
|
+ {
|
|
|
+ if (subElement && subElement->realVisibility() && subElement->selectTest(pos, false) >= 0)
|
|
|
+ {
|
|
|
+ currentElement = subElement;
|
|
|
+ searchSubElements = true;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return currentElement;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns the layout element of type \ref QCPAxisRect at pixel position \a pos. This method ignores
|
|
|
+ other layout elements even if they are visually in front of the axis rect (e.g. a \ref
|
|
|
+ QCPLegend). If there is no axis rect at that position, returns 0.
|
|
|
+
|
|
|
+ Only visible axis rects are used. If \ref QCPLayoutElement::setVisible on the axis rect itself or
|
|
|
+ on any of its parent elements is set to false, it will not be considered.
|
|
|
+
|
|
|
+ \see layoutElementAt
|
|
|
+*/
|
|
|
+QCPAxisRect *QCustomPlot::axisRectAt(const QPointF &pos) const
|
|
|
+{
|
|
|
+ QCPAxisRect *result = 0;
|
|
|
+ QCPLayoutElement *currentElement = mPlotLayout;
|
|
|
+ bool searchSubElements = true;
|
|
|
+ while (searchSubElements && currentElement)
|
|
|
+ {
|
|
|
+ searchSubElements = false;
|
|
|
+ foreach (QCPLayoutElement *subElement, currentElement->elements(false))
|
|
|
+ {
|
|
|
+ if (subElement && subElement->realVisibility() && subElement->selectTest(pos, false) >= 0)
|
|
|
+ {
|
|
|
+ currentElement = subElement;
|
|
|
+ searchSubElements = true;
|
|
|
+ if (QCPAxisRect *ar = qobject_cast<QCPAxisRect*>(currentElement))
|
|
|
+ result = ar;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns the axes that currently have selected parts, i.e. whose selection state is not \ref
|
|
|
+ QCPAxis::spNone.
|
|
|
+
|
|
|
+ \see selectedPlottables, selectedLegends, setInteractions, QCPAxis::setSelectedParts,
|
|
|
+ QCPAxis::setSelectableParts
|
|
|
+*/
|
|
|
+QList<QCPAxis*> QCustomPlot::selectedAxes() const
|
|
|
+{
|
|
|
+ QList<QCPAxis*> result, allAxes;
|
|
|
+ foreach (QCPAxisRect *rect, axisRects())
|
|
|
+ allAxes << rect->axes();
|
|
|
+
|
|
|
+ foreach (QCPAxis *axis, allAxes)
|
|
|
+ {
|
|
|
+ if (axis->selectedParts() != QCPAxis::spNone)
|
|
|
+ result.append(axis);
|
|
|
+ }
|
|
|
+
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns the legends that currently have selected parts, i.e. whose selection state is not \ref
|
|
|
+ QCPLegend::spNone.
|
|
|
+
|
|
|
+ \see selectedPlottables, selectedAxes, setInteractions, QCPLegend::setSelectedParts,
|
|
|
+ QCPLegend::setSelectableParts, QCPLegend::selectedItems
|
|
|
+*/
|
|
|
+QList<QCPLegend*> QCustomPlot::selectedLegends() const
|
|
|
+{
|
|
|
+ QList<QCPLegend*> result;
|
|
|
+
|
|
|
+ QStack<QCPLayoutElement*> elementStack;
|
|
|
+ if (mPlotLayout)
|
|
|
+ elementStack.push(mPlotLayout);
|
|
|
+
|
|
|
+ while (!elementStack.isEmpty())
|
|
|
+ {
|
|
|
+ foreach (QCPLayoutElement *subElement, elementStack.pop()->elements(false))
|
|
|
+ {
|
|
|
+ if (subElement)
|
|
|
+ {
|
|
|
+ elementStack.push(subElement);
|
|
|
+ if (QCPLegend *leg = qobject_cast<QCPLegend*>(subElement))
|
|
|
+ {
|
|
|
+ if (leg->selectedParts() != QCPLegend::spNone)
|
|
|
+ result.append(leg);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Deselects all layerables (plottables, items, axes, legends,...) of the QCustomPlot.
|
|
|
+
|
|
|
+ Since calling this function is not a user interaction, this does not emit the \ref
|
|
|
+ selectionChangedByUser signal. The individual selectionChanged signals are emitted though, if the
|
|
|
+ objects were previously selected.
|
|
|
+
|
|
|
+ \see setInteractions, selectedPlottables, selectedItems, selectedAxes, selectedLegends
|
|
|
+*/
|
|
|
+void QCustomPlot::deselectAll()
|
|
|
+{
|
|
|
+ foreach (QCPLayer *layer, mLayers)
|
|
|
+ {
|
|
|
+ foreach (QCPLayerable *layerable, layer->children())
|
|
|
+ layerable->deselectEvent(0);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Causes a complete replot into the internal paint buffer(s). Finally, the widget surface is
|
|
|
+ refreshed with the new buffer contents. This is the method that must be called to make changes to
|
|
|
+ the plot, e.g. on the axis ranges or data points of graphs, visible.
|
|
|
+
|
|
|
+ The parameter \a refreshPriority can be used to fine-tune the timing of the replot. For example
|
|
|
+ if your application calls \ref replot very quickly in succession (e.g. multiple independent
|
|
|
+ functions change some aspects of the plot and each wants to make sure the change gets replotted),
|
|
|
+ it is advisable to set \a refreshPriority to \ref QCustomPlot::rpQueuedReplot. This way, the
|
|
|
+ actual replotting is deferred to the next event loop iteration. Multiple successive calls of \ref
|
|
|
+ replot with this priority will only cause a single replot, avoiding redundant replots and
|
|
|
+ improving performance.
|
|
|
+
|
|
|
+ Under a few circumstances, QCustomPlot causes a replot by itself. Those are resize events of the
|
|
|
+ QCustomPlot widget and user interactions (object selection and range dragging/zooming).
|
|
|
+
|
|
|
+ Before the replot happens, the signal \ref beforeReplot is emitted. After the replot, \ref
|
|
|
+ afterReplot is emitted. It is safe to mutually connect the replot slot with any of those two
|
|
|
+ signals on two QCustomPlots to make them replot synchronously, it won't cause an infinite
|
|
|
+ recursion.
|
|
|
+
|
|
|
+ If a layer is in mode \ref QCPLayer::lmBuffered (\ref QCPLayer::setMode), it is also possible to
|
|
|
+ replot only that specific layer via \ref QCPLayer::replot. See the documentation there for
|
|
|
+ details.
|
|
|
+*/
|
|
|
+void QCustomPlot::replot(QCustomPlot::RefreshPriority refreshPriority)
|
|
|
+{
|
|
|
+ if (refreshPriority == QCustomPlot::rpQueuedReplot)
|
|
|
+ {
|
|
|
+ if (!mReplotQueued)
|
|
|
+ {
|
|
|
+ mReplotQueued = true;
|
|
|
+ QTimer::singleShot(0, this, SLOT(replot()));
|
|
|
+ }
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (mReplotting) // incase signals loop back to replot slot
|
|
|
+ return;
|
|
|
+ mReplotting = true;
|
|
|
+ mReplotQueued = false;
|
|
|
+ emit beforeReplot();
|
|
|
+
|
|
|
+ updateLayout();
|
|
|
+ // draw all layered objects (grid, axes, plottables, items, legend,...) into their buffers:
|
|
|
+ setupPaintBuffers();
|
|
|
+ foreach (QCPLayer *layer, mLayers)
|
|
|
+ layer->drawToPaintBuffer();
|
|
|
+ for (int i=0; i<mPaintBuffers.size(); ++i)
|
|
|
+ mPaintBuffers.at(i)->setInvalidated(false);
|
|
|
+
|
|
|
+ if ((refreshPriority == rpRefreshHint && mPlottingHints.testFlag(QCP::phImmediateRefresh)) || refreshPriority==rpImmediateRefresh)
|
|
|
+ repaint();
|
|
|
+ else
|
|
|
+ update();
|
|
|
+
|
|
|
+ emit afterReplot();
|
|
|
+ mReplotting = false;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Rescales the axes such that all plottables (like graphs) in the plot are fully visible.
|
|
|
+
|
|
|
+ if \a onlyVisiblePlottables is set to true, only the plottables that have their visibility set to true
|
|
|
+ (QCPLayerable::setVisible), will be used to rescale the axes.
|
|
|
+
|
|
|
+ \see QCPAbstractPlottable::rescaleAxes, QCPAxis::rescale
|
|
|
+*/
|
|
|
+void QCustomPlot::rescaleAxes(bool onlyVisiblePlottables)
|
|
|
+{
|
|
|
+ QList<QCPAxis*> allAxes;
|
|
|
+ foreach (QCPAxisRect *rect, axisRects())
|
|
|
+ allAxes << rect->axes();
|
|
|
+
|
|
|
+ foreach (QCPAxis *axis, allAxes)
|
|
|
+ axis->rescale(onlyVisiblePlottables);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Saves a PDF with the vectorized plot to the file \a fileName. The axis ratio as well as the scale
|
|
|
+ of texts and lines will be derived from the specified \a width and \a height. This means, the
|
|
|
+ output will look like the normal on-screen output of a QCustomPlot widget with the corresponding
|
|
|
+ pixel width and height. If either \a width or \a height is zero, the exported image will have the
|
|
|
+ same dimensions as the QCustomPlot widget currently has.
|
|
|
+
|
|
|
+ Setting \a exportPen to \ref QCP::epNoCosmetic allows to disable the use of cosmetic pens when
|
|
|
+ drawing to the PDF file. Cosmetic pens are pens with numerical width 0, which are always drawn as
|
|
|
+ a one pixel wide line, no matter what zoom factor is set in the PDF-Viewer. For more information
|
|
|
+ about cosmetic pens, see the QPainter and QPen documentation.
|
|
|
+
|
|
|
+ The objects of the plot will appear in the current selection state. If you don't want any
|
|
|
+ selected objects to be painted in their selected look, deselect everything with \ref deselectAll
|
|
|
+ before calling this function.
|
|
|
+
|
|
|
+ Returns true on success.
|
|
|
+
|
|
|
+ \warning
|
|
|
+ \li If you plan on editing the exported PDF file with a vector graphics editor like Inkscape, it
|
|
|
+ is advised to set \a exportPen to \ref QCP::epNoCosmetic to avoid losing those cosmetic lines
|
|
|
+ (which might be quite many, because cosmetic pens are the default for e.g. axes and tick marks).
|
|
|
+ \li If calling this function inside the constructor of the parent of the QCustomPlot widget
|
|
|
+ (i.e. the MainWindow constructor, if QCustomPlot is inside the MainWindow), always provide
|
|
|
+ explicit non-zero widths and heights. If you leave \a width or \a height as 0 (default), this
|
|
|
+ function uses the current width and height of the QCustomPlot widget. However, in Qt, these
|
|
|
+ aren't defined yet inside the constructor, so you would get an image that has strange
|
|
|
+ widths/heights.
|
|
|
+
|
|
|
+ \a pdfCreator and \a pdfTitle may be used to set the according metadata fields in the resulting
|
|
|
+ PDF file.
|
|
|
+
|
|
|
+ \note On Android systems, this method does nothing and issues an according qDebug warning
|
|
|
+ message. This is also the case if for other reasons the define flag \c QT_NO_PRINTER is set.
|
|
|
+
|
|
|
+ \see savePng, saveBmp, saveJpg, saveRastered
|
|
|
+*/
|
|
|
+bool QCustomPlot::savePdf(const QString &fileName, int width, int height, QCP::ExportPen exportPen, const QString &pdfCreator, const QString &pdfTitle)
|
|
|
+{
|
|
|
+ bool success = false;
|
|
|
+#ifdef QT_NO_PRINTER
|
|
|
+ Q_UNUSED(fileName)
|
|
|
+ Q_UNUSED(exportPen)
|
|
|
+ Q_UNUSED(width)
|
|
|
+ Q_UNUSED(height)
|
|
|
+ Q_UNUSED(pdfCreator)
|
|
|
+ Q_UNUSED(pdfTitle)
|
|
|
+ qDebug() << Q_FUNC_INFO << "Qt was built without printer support (QT_NO_PRINTER). PDF not created.";
|
|
|
+#else
|
|
|
+ int newWidth, newHeight;
|
|
|
+ if (width == 0 || height == 0)
|
|
|
+ {
|
|
|
+ newWidth = this->width();
|
|
|
+ newHeight = this->height();
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ newWidth = width;
|
|
|
+ newHeight = height;
|
|
|
+ }
|
|
|
+
|
|
|
+ QPrinter printer(QPrinter::ScreenResolution);
|
|
|
+ printer.setOutputFileName(fileName);
|
|
|
+ printer.setOutputFormat(QPrinter::PdfFormat);
|
|
|
+ printer.setColorMode(QPrinter::Color);
|
|
|
+ printer.printEngine()->setProperty(QPrintEngine::PPK_Creator, pdfCreator);
|
|
|
+ printer.printEngine()->setProperty(QPrintEngine::PPK_DocumentName, pdfTitle);
|
|
|
+ QRect oldViewport = viewport();
|
|
|
+ setViewport(QRect(0, 0, newWidth, newHeight));
|
|
|
+#if QT_VERSION < QT_VERSION_CHECK(5, 3, 0)
|
|
|
+ printer.setFullPage(true);
|
|
|
+ printer.setPaperSize(viewport().size(), QPrinter::DevicePixel);
|
|
|
+#else
|
|
|
+ QPageLayout pageLayout;
|
|
|
+ pageLayout.setMode(QPageLayout::FullPageMode);
|
|
|
+ pageLayout.setOrientation(QPageLayout::Portrait);
|
|
|
+ pageLayout.setMargins(QMarginsF(0, 0, 0, 0));
|
|
|
+ pageLayout.setPageSize(QPageSize(viewport().size(), QPageSize::Point, QString(), QPageSize::ExactMatch));
|
|
|
+ printer.setPageLayout(pageLayout);
|
|
|
+#endif
|
|
|
+ QCPPainter printpainter;
|
|
|
+ if (printpainter.begin(&printer))
|
|
|
+ {
|
|
|
+ printpainter.setMode(QCPPainter::pmVectorized);
|
|
|
+ printpainter.setMode(QCPPainter::pmNoCaching);
|
|
|
+ printpainter.setMode(QCPPainter::pmNonCosmetic, exportPen==QCP::epNoCosmetic);
|
|
|
+ printpainter.setWindow(mViewport);
|
|
|
+ if (mBackgroundBrush.style() != Qt::NoBrush &&
|
|
|
+ mBackgroundBrush.color() != Qt::white &&
|
|
|
+ mBackgroundBrush.color() != Qt::transparent &&
|
|
|
+ mBackgroundBrush.color().alpha() > 0) // draw pdf background color if not white/transparent
|
|
|
+ printpainter.fillRect(viewport(), mBackgroundBrush);
|
|
|
+ draw(&printpainter);
|
|
|
+ printpainter.end();
|
|
|
+ success = true;
|
|
|
+ }
|
|
|
+ setViewport(oldViewport);
|
|
|
+#endif // QT_NO_PRINTER
|
|
|
+ return success;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Saves a PNG image file to \a fileName on disc. The output plot will have the dimensions \a width
|
|
|
+ and \a height in pixels, multiplied by \a scale. If either \a width or \a height is zero, the
|
|
|
+ current width and height of the QCustomPlot widget is used instead. Line widths and texts etc.
|
|
|
+ are not scaled up when larger widths/heights are used. If you want that effect, use the \a scale
|
|
|
+ parameter.
|
|
|
+
|
|
|
+ For example, if you set both \a width and \a height to 100 and \a scale to 2, you will end up with an
|
|
|
+ image file of size 200*200 in which all graphical elements are scaled up by factor 2 (line widths,
|
|
|
+ texts, etc.). This scaling is not done by stretching a 100*100 image, the result will have full
|
|
|
+ 200*200 pixel resolution.
|
|
|
+
|
|
|
+ If you use a high scaling factor, it is recommended to enable antialiasing for all elements by
|
|
|
+ temporarily setting \ref QCustomPlot::setAntialiasedElements to \ref QCP::aeAll as this allows
|
|
|
+ QCustomPlot to place objects with sub-pixel accuracy.
|
|
|
+
|
|
|
+ image compression can be controlled with the \a quality parameter which must be between 0 and 100
|
|
|
+ or -1 to use the default setting.
|
|
|
+
|
|
|
+ The \a resolution will be written to the image file header and has no direct consequence for the
|
|
|
+ quality or the pixel size. However, if opening the image with a tool which respects the metadata,
|
|
|
+ it will be able to scale the image to match either a given size in real units of length (inch,
|
|
|
+ centimeters, etc.), or the target display DPI. You can specify in which units \a resolution is
|
|
|
+ given, by setting \a resolutionUnit. The \a resolution is converted to the format's expected
|
|
|
+ resolution unit internally.
|
|
|
+
|
|
|
+ Returns true on success. If this function fails, most likely the PNG format isn't supported by
|
|
|
+ the system, see Qt docs about QImageWriter::supportedImageFormats().
|
|
|
+
|
|
|
+ The objects of the plot will appear in the current selection state. If you don't want any selected
|
|
|
+ objects to be painted in their selected look, deselect everything with \ref deselectAll before calling
|
|
|
+ this function.
|
|
|
+
|
|
|
+ If you want the PNG to have a transparent background, call \ref setBackground(const QBrush &brush)
|
|
|
+ with no brush (Qt::NoBrush) or a transparent color (Qt::transparent), before saving.
|
|
|
+
|
|
|
+ \warning If calling this function inside the constructor of the parent of the QCustomPlot widget
|
|
|
+ (i.e. the MainWindow constructor, if QCustomPlot is inside the MainWindow), always provide
|
|
|
+ explicit non-zero widths and heights. If you leave \a width or \a height as 0 (default), this
|
|
|
+ function uses the current width and height of the QCustomPlot widget. However, in Qt, these
|
|
|
+ aren't defined yet inside the constructor, so you would get an image that has strange
|
|
|
+ widths/heights.
|
|
|
+
|
|
|
+ \see savePdf, saveBmp, saveJpg, saveRastered
|
|
|
+*/
|
|
|
+bool QCustomPlot::savePng(const QString &fileName, int width, int height, double scale, int quality, int resolution, QCP::ResolutionUnit resolutionUnit)
|
|
|
+{
|
|
|
+ return saveRastered(fileName, width, height, scale, "PNG", quality, resolution, resolutionUnit);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Saves a JPEG image file to \a fileName on disc. The output plot will have the dimensions \a width
|
|
|
+ and \a height in pixels, multiplied by \a scale. If either \a width or \a height is zero, the
|
|
|
+ current width and height of the QCustomPlot widget is used instead. Line widths and texts etc.
|
|
|
+ are not scaled up when larger widths/heights are used. If you want that effect, use the \a scale
|
|
|
+ parameter.
|
|
|
+
|
|
|
+ For example, if you set both \a width and \a height to 100 and \a scale to 2, you will end up with an
|
|
|
+ image file of size 200*200 in which all graphical elements are scaled up by factor 2 (line widths,
|
|
|
+ texts, etc.). This scaling is not done by stretching a 100*100 image, the result will have full
|
|
|
+ 200*200 pixel resolution.
|
|
|
+
|
|
|
+ If you use a high scaling factor, it is recommended to enable antialiasing for all elements by
|
|
|
+ temporarily setting \ref QCustomPlot::setAntialiasedElements to \ref QCP::aeAll as this allows
|
|
|
+ QCustomPlot to place objects with sub-pixel accuracy.
|
|
|
+
|
|
|
+ image compression can be controlled with the \a quality parameter which must be between 0 and 100
|
|
|
+ or -1 to use the default setting.
|
|
|
+
|
|
|
+ The \a resolution will be written to the image file header and has no direct consequence for the
|
|
|
+ quality or the pixel size. However, if opening the image with a tool which respects the metadata,
|
|
|
+ it will be able to scale the image to match either a given size in real units of length (inch,
|
|
|
+ centimeters, etc.), or the target display DPI. You can specify in which units \a resolution is
|
|
|
+ given, by setting \a resolutionUnit. The \a resolution is converted to the format's expected
|
|
|
+ resolution unit internally.
|
|
|
+
|
|
|
+ Returns true on success. If this function fails, most likely the JPEG format isn't supported by
|
|
|
+ the system, see Qt docs about QImageWriter::supportedImageFormats().
|
|
|
+
|
|
|
+ The objects of the plot will appear in the current selection state. If you don't want any selected
|
|
|
+ objects to be painted in their selected look, deselect everything with \ref deselectAll before calling
|
|
|
+ this function.
|
|
|
+
|
|
|
+ \warning If calling this function inside the constructor of the parent of the QCustomPlot widget
|
|
|
+ (i.e. the MainWindow constructor, if QCustomPlot is inside the MainWindow), always provide
|
|
|
+ explicit non-zero widths and heights. If you leave \a width or \a height as 0 (default), this
|
|
|
+ function uses the current width and height of the QCustomPlot widget. However, in Qt, these
|
|
|
+ aren't defined yet inside the constructor, so you would get an image that has strange
|
|
|
+ widths/heights.
|
|
|
+
|
|
|
+ \see savePdf, savePng, saveBmp, saveRastered
|
|
|
+*/
|
|
|
+bool QCustomPlot::saveJpg(const QString &fileName, int width, int height, double scale, int quality, int resolution, QCP::ResolutionUnit resolutionUnit)
|
|
|
+{
|
|
|
+ return saveRastered(fileName, width, height, scale, "JPG", quality, resolution, resolutionUnit);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Saves a BMP image file to \a fileName on disc. The output plot will have the dimensions \a width
|
|
|
+ and \a height in pixels, multiplied by \a scale. If either \a width or \a height is zero, the
|
|
|
+ current width and height of the QCustomPlot widget is used instead. Line widths and texts etc.
|
|
|
+ are not scaled up when larger widths/heights are used. If you want that effect, use the \a scale
|
|
|
+ parameter.
|
|
|
+
|
|
|
+ For example, if you set both \a width and \a height to 100 and \a scale to 2, you will end up with an
|
|
|
+ image file of size 200*200 in which all graphical elements are scaled up by factor 2 (line widths,
|
|
|
+ texts, etc.). This scaling is not done by stretching a 100*100 image, the result will have full
|
|
|
+ 200*200 pixel resolution.
|
|
|
+
|
|
|
+ If you use a high scaling factor, it is recommended to enable antialiasing for all elements by
|
|
|
+ temporarily setting \ref QCustomPlot::setAntialiasedElements to \ref QCP::aeAll as this allows
|
|
|
+ QCustomPlot to place objects with sub-pixel accuracy.
|
|
|
+
|
|
|
+ The \a resolution will be written to the image file header and has no direct consequence for the
|
|
|
+ quality or the pixel size. However, if opening the image with a tool which respects the metadata,
|
|
|
+ it will be able to scale the image to match either a given size in real units of length (inch,
|
|
|
+ centimeters, etc.), or the target display DPI. You can specify in which units \a resolution is
|
|
|
+ given, by setting \a resolutionUnit. The \a resolution is converted to the format's expected
|
|
|
+ resolution unit internally.
|
|
|
+
|
|
|
+ Returns true on success. If this function fails, most likely the BMP format isn't supported by
|
|
|
+ the system, see Qt docs about QImageWriter::supportedImageFormats().
|
|
|
+
|
|
|
+ The objects of the plot will appear in the current selection state. If you don't want any selected
|
|
|
+ objects to be painted in their selected look, deselect everything with \ref deselectAll before calling
|
|
|
+ this function.
|
|
|
+
|
|
|
+ \warning If calling this function inside the constructor of the parent of the QCustomPlot widget
|
|
|
+ (i.e. the MainWindow constructor, if QCustomPlot is inside the MainWindow), always provide
|
|
|
+ explicit non-zero widths and heights. If you leave \a width or \a height as 0 (default), this
|
|
|
+ function uses the current width and height of the QCustomPlot widget. However, in Qt, these
|
|
|
+ aren't defined yet inside the constructor, so you would get an image that has strange
|
|
|
+ widths/heights.
|
|
|
+
|
|
|
+ \see savePdf, savePng, saveJpg, saveRastered
|
|
|
+*/
|
|
|
+bool QCustomPlot::saveBmp(const QString &fileName, int width, int height, double scale, int resolution, QCP::ResolutionUnit resolutionUnit)
|
|
|
+{
|
|
|
+ return saveRastered(fileName, width, height, scale, "BMP", -1, resolution, resolutionUnit);
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns a minimum size hint that corresponds to the minimum size of the top level layout
|
|
|
+ (\ref plotLayout). To prevent QCustomPlot from being collapsed to size/width zero, set a minimum
|
|
|
+ size (setMinimumSize) either on the whole QCustomPlot or on any layout elements inside the plot.
|
|
|
+ This is especially important, when placed in a QLayout where other components try to take in as
|
|
|
+ much space as possible (e.g. QMdiArea).
|
|
|
+*/
|
|
|
+QSize QCustomPlot::minimumSizeHint() const
|
|
|
+{
|
|
|
+ return mPlotLayout->minimumOuterSizeHint();
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns a size hint that is the same as \ref minimumSizeHint.
|
|
|
+
|
|
|
+*/
|
|
|
+QSize QCustomPlot::sizeHint() const
|
|
|
+{
|
|
|
+ return mPlotLayout->minimumOuterSizeHint();
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Event handler for when the QCustomPlot widget needs repainting. This does not cause a \ref replot, but
|
|
|
+ draws the internal buffer on the widget surface.
|
|
|
+*/
|
|
|
+void QCustomPlot::paintEvent(QPaintEvent *event)
|
|
|
+{
|
|
|
+ Q_UNUSED(event);
|
|
|
+ QCPPainter painter(this);
|
|
|
+ if (painter.isActive())
|
|
|
+ {
|
|
|
+ painter.setRenderHint(QPainter::HighQualityAntialiasing); // to make Antialiasing look good if using the OpenGL graphicssystem
|
|
|
+ if (mBackgroundBrush.style() != Qt::NoBrush)
|
|
|
+ painter.fillRect(mViewport, mBackgroundBrush);
|
|
|
+ drawBackground(&painter);
|
|
|
+ for (int bufferIndex = 0; bufferIndex < mPaintBuffers.size(); ++bufferIndex)
|
|
|
+ mPaintBuffers.at(bufferIndex)->draw(&painter);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Event handler for a resize of the QCustomPlot widget. The viewport (which becomes the outer rect
|
|
|
+ of mPlotLayout) is resized appropriately. Finally a \ref replot is performed.
|
|
|
+*/
|
|
|
+void QCustomPlot::resizeEvent(QResizeEvent *event)
|
|
|
+{
|
|
|
+ Q_UNUSED(event)
|
|
|
+ // resize and repaint the buffer:
|
|
|
+ setViewport(rect());
|
|
|
+ replot(rpQueuedRefresh); // queued refresh is important here, to prevent painting issues in some contexts (e.g. MDI subwindow)
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Event handler for when a double click occurs. Emits the \ref mouseDoubleClick signal, then
|
|
|
+ determines the layerable under the cursor and forwards the event to it. Finally, emits the
|
|
|
+ specialized signals when certain objecs are clicked (e.g. \ref plottableDoubleClick, \ref
|
|
|
+ axisDoubleClick, etc.).
|
|
|
+
|
|
|
+ \see mousePressEvent, mouseReleaseEvent
|
|
|
+*/
|
|
|
+void QCustomPlot::mouseDoubleClickEvent(QMouseEvent *event)
|
|
|
+{
|
|
|
+ emit mouseDoubleClick(event);
|
|
|
+ mMouseHasMoved = false;
|
|
|
+ mMousePressPos = event->pos();
|
|
|
+
|
|
|
+ // determine layerable under the cursor (this event is called instead of the second press event in a double-click):
|
|
|
+ QList<QVariant> details;
|
|
|
+ QList<QCPLayerable*> candidates = layerableListAt(mMousePressPos, false, &details);
|
|
|
+ for (int i=0; i<candidates.size(); ++i)
|
|
|
+ {
|
|
|
+ event->accept(); // default impl of QCPLayerable's mouse events ignore the event, in that case propagate to next candidate in list
|
|
|
+ candidates.at(i)->mouseDoubleClickEvent(event, details.at(i));
|
|
|
+ if (event->isAccepted())
|
|
|
+ {
|
|
|
+ mMouseEventLayerable = candidates.at(i);
|
|
|
+ mMouseEventLayerableDetails = details.at(i);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // emit specialized object double click signals:
|
|
|
+ if (!candidates.isEmpty())
|
|
|
+ {
|
|
|
+ if (QCPAbstractPlottable *ap = qobject_cast<QCPAbstractPlottable*>(candidates.first()))
|
|
|
+ {
|
|
|
+ int dataIndex = 0;
|
|
|
+ if (!details.first().value<QCPDataSelection>().isEmpty())
|
|
|
+ dataIndex = details.first().value<QCPDataSelection>().dataRange().begin();
|
|
|
+ emit plottableDoubleClick(ap, dataIndex, event);
|
|
|
+ } else if (QCPAxis *ax = qobject_cast<QCPAxis*>(candidates.first()))
|
|
|
+ emit axisDoubleClick(ax, details.first().value<QCPAxis::SelectablePart>(), event);
|
|
|
+ else if (QCPAbstractItem *ai = qobject_cast<QCPAbstractItem*>(candidates.first()))
|
|
|
+ emit itemDoubleClick(ai, event);
|
|
|
+ else if (QCPLegend *lg = qobject_cast<QCPLegend*>(candidates.first()))
|
|
|
+ emit legendDoubleClick(lg, 0, event);
|
|
|
+ else if (QCPAbstractLegendItem *li = qobject_cast<QCPAbstractLegendItem*>(candidates.first()))
|
|
|
+ emit legendDoubleClick(li->parentLegend(), li, event);
|
|
|
+ }
|
|
|
+
|
|
|
+ event->accept(); // in case QCPLayerable reimplementation manipulates event accepted state. In QWidget event system, QCustomPlot wants to accept the event.
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Event handler for when a mouse button is pressed. Emits the mousePress signal.
|
|
|
+
|
|
|
+ If the current \ref setSelectionRectMode is not \ref QCP::srmNone, passes the event to the
|
|
|
+ selection rect. Otherwise determines the layerable under the cursor and forwards the event to it.
|
|
|
+
|
|
|
+ \see mouseMoveEvent, mouseReleaseEvent
|
|
|
+*/
|
|
|
+void QCustomPlot::mousePressEvent(QMouseEvent *event)
|
|
|
+{
|
|
|
+ emit mousePress(event);
|
|
|
+ // save some state to tell in releaseEvent whether it was a click:
|
|
|
+ mMouseHasMoved = false;
|
|
|
+ mMousePressPos = event->pos();
|
|
|
+
|
|
|
+ if (mSelectionRect && mSelectionRectMode != QCP::srmNone)
|
|
|
+ {
|
|
|
+ if (mSelectionRectMode != QCP::srmZoom || qobject_cast<QCPAxisRect*>(axisRectAt(mMousePressPos))) // in zoom mode only activate selection rect if on an axis rect
|
|
|
+ mSelectionRect->startSelection(event);
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ // no selection rect interaction, prepare for click signal emission and forward event to layerable under the cursor:
|
|
|
+ QList<QVariant> details;
|
|
|
+ QList<QCPLayerable*> candidates = layerableListAt(mMousePressPos, false, &details);
|
|
|
+ if (!candidates.isEmpty())
|
|
|
+ {
|
|
|
+ mMouseSignalLayerable = candidates.first(); // candidate for signal emission is always topmost hit layerable (signal emitted in release event)
|
|
|
+ mMouseSignalLayerableDetails = details.first();
|
|
|
+ }
|
|
|
+ // forward event to topmost candidate which accepts the event:
|
|
|
+ for (int i=0; i<candidates.size(); ++i)
|
|
|
+ {
|
|
|
+ event->accept(); // default impl of QCPLayerable's mouse events call ignore() on the event, in that case propagate to next candidate in list
|
|
|
+ candidates.at(i)->mousePressEvent(event, details.at(i));
|
|
|
+ if (event->isAccepted())
|
|
|
+ {
|
|
|
+ mMouseEventLayerable = candidates.at(i);
|
|
|
+ mMouseEventLayerableDetails = details.at(i);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ event->accept(); // in case QCPLayerable reimplementation manipulates event accepted state. In QWidget event system, QCustomPlot wants to accept the event.
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Event handler for when the cursor is moved. Emits the \ref mouseMove signal.
|
|
|
+
|
|
|
+ If the selection rect (\ref setSelectionRect) is currently active, the event is forwarded to it
|
|
|
+ in order to update the rect geometry.
|
|
|
+
|
|
|
+ Otherwise, if a layout element has mouse capture focus (a mousePressEvent happened on top of the
|
|
|
+ layout element before), the mouseMoveEvent is forwarded to that element.
|
|
|
+
|
|
|
+ \see mousePressEvent, mouseReleaseEvent
|
|
|
+*/
|
|
|
+void QCustomPlot::mouseMoveEvent(QMouseEvent *event)
|
|
|
+{
|
|
|
+ emit mouseMove(event);
|
|
|
+
|
|
|
+ if (!mMouseHasMoved && (mMousePressPos-event->pos()).manhattanLength() > 3)
|
|
|
+ mMouseHasMoved = true; // moved too far from mouse press position, don't handle as click on mouse release
|
|
|
+
|
|
|
+ if (mSelectionRect && mSelectionRect->isActive())
|
|
|
+ mSelectionRect->moveSelection(event);
|
|
|
+ else if (mMouseEventLayerable) // call event of affected layerable:
|
|
|
+ mMouseEventLayerable->mouseMoveEvent(event, mMousePressPos);
|
|
|
+
|
|
|
+ event->accept(); // in case QCPLayerable reimplementation manipulates event accepted state. In QWidget event system, QCustomPlot wants to accept the event.
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Event handler for when a mouse button is released. Emits the \ref mouseRelease signal.
|
|
|
+
|
|
|
+ If the mouse was moved less than a certain threshold in any direction since the \ref
|
|
|
+ mousePressEvent, it is considered a click which causes the selection mechanism (if activated via
|
|
|
+ \ref setInteractions) to possibly change selection states accordingly. Further, specialized mouse
|
|
|
+ click signals are emitted (e.g. \ref plottableClick, \ref axisClick, etc.)
|
|
|
+
|
|
|
+ If a layerable is the mouse capturer (a \ref mousePressEvent happened on top of the layerable
|
|
|
+ before), the \ref mouseReleaseEvent is forwarded to that element.
|
|
|
+
|
|
|
+ \see mousePressEvent, mouseMoveEvent
|
|
|
+*/
|
|
|
+void QCustomPlot::mouseReleaseEvent(QMouseEvent *event)
|
|
|
+{
|
|
|
+ emit mouseRelease(event);
|
|
|
+
|
|
|
+ if (!mMouseHasMoved) // mouse hasn't moved (much) between press and release, so handle as click
|
|
|
+ {
|
|
|
+ if (mSelectionRect && mSelectionRect->isActive()) // a simple click shouldn't successfully finish a selection rect, so cancel it here
|
|
|
+ mSelectionRect->cancel();
|
|
|
+ if (event->button() == Qt::LeftButton)
|
|
|
+ processPointSelection(event);
|
|
|
+
|
|
|
+ // emit specialized click signals of QCustomPlot instance:
|
|
|
+ if (QCPAbstractPlottable *ap = qobject_cast<QCPAbstractPlottable*>(mMouseSignalLayerable))
|
|
|
+ {
|
|
|
+ int dataIndex = 0;
|
|
|
+ if (!mMouseSignalLayerableDetails.value<QCPDataSelection>().isEmpty())
|
|
|
+ dataIndex = mMouseSignalLayerableDetails.value<QCPDataSelection>().dataRange().begin();
|
|
|
+ emit plottableClick(ap, dataIndex, event);
|
|
|
+ } else if (QCPAxis *ax = qobject_cast<QCPAxis*>(mMouseSignalLayerable))
|
|
|
+ emit axisClick(ax, mMouseSignalLayerableDetails.value<QCPAxis::SelectablePart>(), event);
|
|
|
+ else if (QCPAbstractItem *ai = qobject_cast<QCPAbstractItem*>(mMouseSignalLayerable))
|
|
|
+ emit itemClick(ai, event);
|
|
|
+ else if (QCPLegend *lg = qobject_cast<QCPLegend*>(mMouseSignalLayerable))
|
|
|
+ emit legendClick(lg, 0, event);
|
|
|
+ else if (QCPAbstractLegendItem *li = qobject_cast<QCPAbstractLegendItem*>(mMouseSignalLayerable))
|
|
|
+ emit legendClick(li->parentLegend(), li, event);
|
|
|
+ mMouseSignalLayerable = 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (mSelectionRect && mSelectionRect->isActive()) // Note: if a click was detected above, the selection rect is canceled there
|
|
|
+ {
|
|
|
+ // finish selection rect, the appropriate action will be taken via signal-slot connection:
|
|
|
+ mSelectionRect->endSelection(event);
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ // call event of affected layerable:
|
|
|
+ if (mMouseEventLayerable)
|
|
|
+ {
|
|
|
+ mMouseEventLayerable->mouseReleaseEvent(event, mMousePressPos);
|
|
|
+ mMouseEventLayerable = 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (noAntialiasingOnDrag())
|
|
|
+ replot(rpQueuedReplot);
|
|
|
+
|
|
|
+ event->accept(); // in case QCPLayerable reimplementation manipulates event accepted state. In QWidget event system, QCustomPlot wants to accept the event.
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Event handler for mouse wheel events. First, the \ref mouseWheel signal is emitted. Then
|
|
|
+ determines the affected layerable and forwards the event to it.
|
|
|
+*/
|
|
|
+void QCustomPlot::wheelEvent(QWheelEvent *event)
|
|
|
+{
|
|
|
+ emit mouseWheel(event);
|
|
|
+ // forward event to layerable under cursor:
|
|
|
+ QList<QCPLayerable*> candidates = layerableListAt(event->pos(), false);
|
|
|
+ for (int i=0; i<candidates.size(); ++i)
|
|
|
+ {
|
|
|
+ event->accept(); // default impl of QCPLayerable's mouse events ignore the event, in that case propagate to next candidate in list
|
|
|
+ candidates.at(i)->wheelEvent(event);
|
|
|
+ if (event->isAccepted())
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ event->accept(); // in case QCPLayerable reimplementation manipulates event accepted state. In QWidget event system, QCustomPlot wants to accept the event.
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ This function draws the entire plot, including background pixmap, with the specified \a painter.
|
|
|
+ It does not make use of the paint buffers like \ref replot, so this is the function typically
|
|
|
+ used by saving/exporting methods such as \ref savePdf or \ref toPainter.
|
|
|
+
|
|
|
+ Note that it does not fill the background with the background brush (as the user may specify with
|
|
|
+ \ref setBackground(const QBrush &brush)), this is up to the respective functions calling this
|
|
|
+ method.
|
|
|
+*/
|
|
|
+void QCustomPlot::draw(QCPPainter *painter)
|
|
|
+{
|
|
|
+ updateLayout();
|
|
|
+
|
|
|
+ // draw viewport background pixmap:
|
|
|
+ drawBackground(painter);
|
|
|
+
|
|
|
+ // draw all layered objects (grid, axes, plottables, items, legend,...):
|
|
|
+ foreach (QCPLayer *layer, mLayers)
|
|
|
+ layer->draw(painter);
|
|
|
+
|
|
|
+ /* Debug code to draw all layout element rects
|
|
|
+ foreach (QCPLayoutElement* el, findChildren<QCPLayoutElement*>())
|
|
|
+ {
|
|
|
+ painter->setBrush(Qt::NoBrush);
|
|
|
+ painter->setPen(QPen(QColor(0, 0, 0, 100), 0, Qt::DashLine));
|
|
|
+ painter->drawRect(el->rect());
|
|
|
+ painter->setPen(QPen(QColor(255, 0, 0, 100), 0, Qt::DashLine));
|
|
|
+ painter->drawRect(el->outerRect());
|
|
|
+ }
|
|
|
+ */
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Performs the layout update steps defined by \ref QCPLayoutElement::UpdatePhase, by calling \ref
|
|
|
+ QCPLayoutElement::update on the main plot layout.
|
|
|
+
|
|
|
+ Here, the layout elements calculate their positions and margins, and prepare for the following
|
|
|
+ draw call.
|
|
|
+*/
|
|
|
+void QCustomPlot::updateLayout()
|
|
|
+{
|
|
|
+ // run through layout phases:
|
|
|
+ mPlotLayout->update(QCPLayoutElement::upPreparation);
|
|
|
+ mPlotLayout->update(QCPLayoutElement::upMargins);
|
|
|
+ mPlotLayout->update(QCPLayoutElement::upLayout);
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Draws the viewport background pixmap of the plot.
|
|
|
+
|
|
|
+ If a pixmap was provided via \ref setBackground, this function buffers the scaled version
|
|
|
+ depending on \ref setBackgroundScaled and \ref setBackgroundScaledMode and then draws it inside
|
|
|
+ the viewport with the provided \a painter. The scaled version is buffered in
|
|
|
+ mScaledBackgroundPixmap to prevent expensive rescaling at every redraw. It is only updated, when
|
|
|
+ the axis rect has changed in a way that requires a rescale of the background pixmap (this is
|
|
|
+ dependent on the \ref setBackgroundScaledMode), or when a differend axis background pixmap was
|
|
|
+ set.
|
|
|
+
|
|
|
+ Note that this function does not draw a fill with the background brush
|
|
|
+ (\ref setBackground(const QBrush &brush)) beneath the pixmap.
|
|
|
+
|
|
|
+ \see setBackground, setBackgroundScaled, setBackgroundScaledMode
|
|
|
+*/
|
|
|
+void QCustomPlot::drawBackground(QCPPainter *painter)
|
|
|
+{
|
|
|
+ // Note: background color is handled in individual replot/save functions
|
|
|
+
|
|
|
+ // draw background pixmap (on top of fill, if brush specified):
|
|
|
+ if (!mBackgroundPixmap.isNull())
|
|
|
+ {
|
|
|
+ if (mBackgroundScaled)
|
|
|
+ {
|
|
|
+ // check whether mScaledBackground needs to be updated:
|
|
|
+ QSize scaledSize(mBackgroundPixmap.size());
|
|
|
+ scaledSize.scale(mViewport.size(), mBackgroundScaledMode);
|
|
|
+ if (mScaledBackgroundPixmap.size() != scaledSize)
|
|
|
+ mScaledBackgroundPixmap = mBackgroundPixmap.scaled(mViewport.size(), mBackgroundScaledMode, Qt::SmoothTransformation);
|
|
|
+ painter->drawPixmap(mViewport.topLeft(), mScaledBackgroundPixmap, QRect(0, 0, mViewport.width(), mViewport.height()) & mScaledBackgroundPixmap.rect());
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ painter->drawPixmap(mViewport.topLeft(), mBackgroundPixmap, QRect(0, 0, mViewport.width(), mViewport.height()));
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Goes through the layers and makes sure this QCustomPlot instance holds the correct number of
|
|
|
+ paint buffers and that they have the correct configuration (size, pixel ratio, etc.).
|
|
|
+ Allocations, reallocations and deletions of paint buffers are performed as necessary. It also
|
|
|
+ associates the paint buffers with the layers, so they draw themselves into the right buffer when
|
|
|
+ \ref QCPLayer::drawToPaintBuffer is called. This means it associates adjacent \ref
|
|
|
+ QCPLayer::lmLogical layers to a mutual paint buffer and creates dedicated paint buffers for
|
|
|
+ layers in \ref QCPLayer::lmBuffered mode.
|
|
|
+
|
|
|
+ This method uses \ref createPaintBuffer to create new paint buffers.
|
|
|
+
|
|
|
+ After this method, the paint buffers are empty (filled with \c Qt::transparent) and invalidated
|
|
|
+ (so an attempt to replot only a single buffered layer causes a full replot).
|
|
|
+
|
|
|
+ This method is called in every \ref replot call, prior to actually drawing the layers (into their
|
|
|
+ associated paint buffer). If the paint buffers don't need changing/reallocating, this method
|
|
|
+ basically leaves them alone and thus finishes very fast.
|
|
|
+*/
|
|
|
+void QCustomPlot::setupPaintBuffers()
|
|
|
+{
|
|
|
+ int bufferIndex = 0;
|
|
|
+ if (mPaintBuffers.isEmpty())
|
|
|
+ mPaintBuffers.append(QSharedPointer<QCPAbstractPaintBuffer>(createPaintBuffer()));
|
|
|
+
|
|
|
+ for (int layerIndex = 0; layerIndex < mLayers.size(); ++layerIndex)
|
|
|
+ {
|
|
|
+ QCPLayer *layer = mLayers.at(layerIndex);
|
|
|
+ if (layer->mode() == QCPLayer::lmLogical)
|
|
|
+ {
|
|
|
+ layer->mPaintBuffer = mPaintBuffers.at(bufferIndex).toWeakRef();
|
|
|
+ } else if (layer->mode() == QCPLayer::lmBuffered)
|
|
|
+ {
|
|
|
+ ++bufferIndex;
|
|
|
+ if (bufferIndex >= mPaintBuffers.size())
|
|
|
+ mPaintBuffers.append(QSharedPointer<QCPAbstractPaintBuffer>(createPaintBuffer()));
|
|
|
+ layer->mPaintBuffer = mPaintBuffers.at(bufferIndex).toWeakRef();
|
|
|
+ if (layerIndex < mLayers.size()-1 && mLayers.at(layerIndex+1)->mode() == QCPLayer::lmLogical) // not last layer, and next one is logical, so prepare another buffer for next layerables
|
|
|
+ {
|
|
|
+ ++bufferIndex;
|
|
|
+ if (bufferIndex >= mPaintBuffers.size())
|
|
|
+ mPaintBuffers.append(QSharedPointer<QCPAbstractPaintBuffer>(createPaintBuffer()));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ // remove unneeded buffers:
|
|
|
+ while (mPaintBuffers.size()-1 > bufferIndex)
|
|
|
+ mPaintBuffers.removeLast();
|
|
|
+ // resize buffers to viewport size and clear contents:
|
|
|
+ for (int i=0; i<mPaintBuffers.size(); ++i)
|
|
|
+ {
|
|
|
+ mPaintBuffers.at(i)->setSize(viewport().size()); // won't do anything if already correct size
|
|
|
+ mPaintBuffers.at(i)->clear(Qt::transparent);
|
|
|
+ mPaintBuffers.at(i)->setInvalidated();
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ This method is used by \ref setupPaintBuffers when it needs to create new paint buffers.
|
|
|
+
|
|
|
+ Depending on the current setting of \ref setOpenGl, and the current Qt version, different
|
|
|
+ backends (subclasses of \ref QCPAbstractPaintBuffer) are created, initialized with the proper
|
|
|
+ size and device pixel ratio, and returned.
|
|
|
+*/
|
|
|
+QCPAbstractPaintBuffer *QCustomPlot::createPaintBuffer()
|
|
|
+{
|
|
|
+ if (mOpenGl)
|
|
|
+ {
|
|
|
+#if defined(QCP_OPENGL_FBO)
|
|
|
+ return new QCPPaintBufferGlFbo(viewport().size(), mBufferDevicePixelRatio, mGlContext, mGlPaintDevice);
|
|
|
+#elif defined(QCP_OPENGL_PBUFFER)
|
|
|
+ return new QCPPaintBufferGlPbuffer(viewport().size(), mBufferDevicePixelRatio, mOpenGlMultisamples);
|
|
|
+#else
|
|
|
+ qDebug() << Q_FUNC_INFO << "OpenGL enabled even though no support for it compiled in, this shouldn't have happened. Falling back to pixmap paint buffer.";
|
|
|
+ return new QCPPaintBufferPixmap(viewport().size(), mBufferDevicePixelRatio);
|
|
|
+#endif
|
|
|
+ } else
|
|
|
+ return new QCPPaintBufferPixmap(viewport().size(), mBufferDevicePixelRatio);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ This method returns whether any of the paint buffers held by this QCustomPlot instance are
|
|
|
+ invalidated.
|
|
|
+
|
|
|
+ If any buffer is invalidated, a partial replot (\ref QCPLayer::replot) is not allowed and always
|
|
|
+ causes a full replot (\ref QCustomPlot::replot) of all layers. This is the case when for example
|
|
|
+ the layer order has changed, new layers were added, layers were removed, or layer modes were
|
|
|
+ changed (\ref QCPLayer::setMode).
|
|
|
+
|
|
|
+ \see QCPAbstractPaintBuffer::setInvalidated
|
|
|
+*/
|
|
|
+bool QCustomPlot::hasInvalidatedPaintBuffers()
|
|
|
+{
|
|
|
+ for (int i=0; i<mPaintBuffers.size(); ++i)
|
|
|
+ {
|
|
|
+ if (mPaintBuffers.at(i)->invalidated())
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ return false;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ When \ref setOpenGl is set to true, this method is used to initialize OpenGL (create a context,
|
|
|
+ surface, paint device).
|
|
|
+
|
|
|
+ Returns true on success.
|
|
|
+
|
|
|
+ If this method is successful, all paint buffers should be deleted and then reallocated by calling
|
|
|
+ \ref setupPaintBuffers, so the OpenGL-based paint buffer subclasses (\ref
|
|
|
+ QCPPaintBufferGlPbuffer, \ref QCPPaintBufferGlFbo) are used for subsequent replots.
|
|
|
+
|
|
|
+ \see freeOpenGl
|
|
|
+*/
|
|
|
+bool QCustomPlot::setupOpenGl()
|
|
|
+{
|
|
|
+#ifdef QCP_OPENGL_FBO
|
|
|
+ freeOpenGl();
|
|
|
+ QSurfaceFormat proposedSurfaceFormat;
|
|
|
+ proposedSurfaceFormat.setSamples(mOpenGlMultisamples);
|
|
|
+#ifdef QCP_OPENGL_OFFSCREENSURFACE
|
|
|
+ QOffscreenSurface *surface = new QOffscreenSurface;
|
|
|
+#else
|
|
|
+ QWindow *surface = new QWindow;
|
|
|
+ surface->setSurfaceType(QSurface::OpenGLSurface);
|
|
|
+#endif
|
|
|
+ surface->setFormat(proposedSurfaceFormat);
|
|
|
+ surface->create();
|
|
|
+ mGlSurface = QSharedPointer<QSurface>(surface);
|
|
|
+ mGlContext = QSharedPointer<QOpenGLContext>(new QOpenGLContext);
|
|
|
+ mGlContext->setFormat(mGlSurface->format());
|
|
|
+ if (!mGlContext->create())
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "Failed to create OpenGL context";
|
|
|
+ mGlContext.clear();
|
|
|
+ mGlSurface.clear();
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ if (!mGlContext->makeCurrent(mGlSurface.data())) // context needs to be current to create paint device
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "Failed to make opengl context current";
|
|
|
+ mGlContext.clear();
|
|
|
+ mGlSurface.clear();
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ if (!QOpenGLFramebufferObject::hasOpenGLFramebufferObjects())
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "OpenGL of this system doesn't support frame buffer objects";
|
|
|
+ mGlContext.clear();
|
|
|
+ mGlSurface.clear();
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ mGlPaintDevice = QSharedPointer<QOpenGLPaintDevice>(new QOpenGLPaintDevice);
|
|
|
+ return true;
|
|
|
+#elif defined(QCP_OPENGL_PBUFFER)
|
|
|
+ return QGLFormat::hasOpenGL();
|
|
|
+#else
|
|
|
+ return false;
|
|
|
+#endif
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ When \ref setOpenGl is set to false, this method is used to deinitialize OpenGL (releases the
|
|
|
+ context and frees resources).
|
|
|
+
|
|
|
+ After OpenGL is disabled, all paint buffers should be deleted and then reallocated by calling
|
|
|
+ \ref setupPaintBuffers, so the standard software rendering paint buffer subclass (\ref
|
|
|
+ QCPPaintBufferPixmap) is used for subsequent replots.
|
|
|
+
|
|
|
+ \see setupOpenGl
|
|
|
+*/
|
|
|
+void QCustomPlot::freeOpenGl()
|
|
|
+{
|
|
|
+#ifdef QCP_OPENGL_FBO
|
|
|
+ mGlPaintDevice.clear();
|
|
|
+ mGlContext.clear();
|
|
|
+ mGlSurface.clear();
|
|
|
+#endif
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ This method is used by \ref QCPAxisRect::removeAxis to report removed axes to the QCustomPlot
|
|
|
+ so it may clear its QCustomPlot::xAxis, yAxis, xAxis2 and yAxis2 members accordingly.
|
|
|
+*/
|
|
|
+void QCustomPlot::axisRemoved(QCPAxis *axis)
|
|
|
+{
|
|
|
+ if (xAxis == axis)
|
|
|
+ xAxis = 0;
|
|
|
+ if (xAxis2 == axis)
|
|
|
+ xAxis2 = 0;
|
|
|
+ if (yAxis == axis)
|
|
|
+ yAxis = 0;
|
|
|
+ if (yAxis2 == axis)
|
|
|
+ yAxis2 = 0;
|
|
|
+
|
|
|
+ // Note: No need to take care of range drag axes and range zoom axes, because they are stored in smart pointers
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ This method is used by the QCPLegend destructor to report legend removal to the QCustomPlot so
|
|
|
+ it may clear its QCustomPlot::legend member accordingly.
|
|
|
+*/
|
|
|
+void QCustomPlot::legendRemoved(QCPLegend *legend)
|
|
|
+{
|
|
|
+ if (this->legend == legend)
|
|
|
+ this->legend = 0;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ This slot is connected to the selection rect's \ref QCPSelectionRect::accepted signal when \ref
|
|
|
+ setSelectionRectMode is set to \ref QCP::srmSelect.
|
|
|
+
|
|
|
+ First, it determines which axis rect was the origin of the selection rect judging by the starting
|
|
|
+ point of the selection. Then it goes through the plottables (\ref QCPAbstractPlottable1D to be
|
|
|
+ precise) associated with that axis rect and finds the data points that are in \a rect. It does
|
|
|
+ this by querying their \ref QCPAbstractPlottable1D::selectTestRect method.
|
|
|
+
|
|
|
+ Then, the actual selection is done by calling the plottables' \ref
|
|
|
+ QCPAbstractPlottable::selectEvent, placing the found selected data points in the \a details
|
|
|
+ parameter as <tt>QVariant(\ref QCPDataSelection)</tt>. All plottables that weren't touched by \a
|
|
|
+ rect receive a \ref QCPAbstractPlottable::deselectEvent.
|
|
|
+
|
|
|
+ \see processRectZoom
|
|
|
+*/
|
|
|
+void QCustomPlot::processRectSelection(QRect rect, QMouseEvent *event)
|
|
|
+{
|
|
|
+ bool selectionStateChanged = false;
|
|
|
+
|
|
|
+ if (mInteractions.testFlag(QCP::iSelectPlottables))
|
|
|
+ {
|
|
|
+ QMap<int, QPair<QCPAbstractPlottable*, QCPDataSelection> > potentialSelections; // map key is number of selected data points, so we have selections sorted by size
|
|
|
+ QRectF rectF(rect.normalized());
|
|
|
+ if (QCPAxisRect *affectedAxisRect = axisRectAt(rectF.topLeft()))
|
|
|
+ {
|
|
|
+ // determine plottables that were hit by the rect and thus are candidates for selection:
|
|
|
+ foreach (QCPAbstractPlottable *plottable, affectedAxisRect->plottables())
|
|
|
+ {
|
|
|
+ if (QCPPlottableInterface1D *plottableInterface = plottable->interface1D())
|
|
|
+ {
|
|
|
+ QCPDataSelection dataSel = plottableInterface->selectTestRect(rectF, true);
|
|
|
+ if (!dataSel.isEmpty())
|
|
|
+ potentialSelections.insertMulti(dataSel.dataPointCount(), QPair<QCPAbstractPlottable*, QCPDataSelection>(plottable, dataSel));
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!mInteractions.testFlag(QCP::iMultiSelect))
|
|
|
+ {
|
|
|
+ // only leave plottable with most selected points in map, since we will only select a single plottable:
|
|
|
+ if (!potentialSelections.isEmpty())
|
|
|
+ {
|
|
|
+ QMap<int, QPair<QCPAbstractPlottable*, QCPDataSelection> >::iterator it = potentialSelections.begin();
|
|
|
+ while (it != potentialSelections.end()-1) // erase all except last element
|
|
|
+ it = potentialSelections.erase(it);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ bool additive = event->modifiers().testFlag(mMultiSelectModifier);
|
|
|
+ // deselect all other layerables if not additive selection:
|
|
|
+ if (!additive)
|
|
|
+ {
|
|
|
+ // emit deselection except to those plottables who will be selected afterwards:
|
|
|
+ foreach (QCPLayer *layer, mLayers)
|
|
|
+ {
|
|
|
+ foreach (QCPLayerable *layerable, layer->children())
|
|
|
+ {
|
|
|
+ if ((potentialSelections.isEmpty() || potentialSelections.constBegin()->first != layerable) && mInteractions.testFlag(layerable->selectionCategory()))
|
|
|
+ {
|
|
|
+ bool selChanged = false;
|
|
|
+ layerable->deselectEvent(&selChanged);
|
|
|
+ selectionStateChanged |= selChanged;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // go through selections in reverse (largest selection first) and emit select events:
|
|
|
+ QMap<int, QPair<QCPAbstractPlottable*, QCPDataSelection> >::const_iterator it = potentialSelections.constEnd();
|
|
|
+ while (it != potentialSelections.constBegin())
|
|
|
+ {
|
|
|
+ --it;
|
|
|
+ if (mInteractions.testFlag(it.value().first->selectionCategory()))
|
|
|
+ {
|
|
|
+ bool selChanged = false;
|
|
|
+ it.value().first->selectEvent(event, additive, QVariant::fromValue(it.value().second), &selChanged);
|
|
|
+ selectionStateChanged |= selChanged;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (selectionStateChanged)
|
|
|
+ {
|
|
|
+ emit selectionChangedByUser();
|
|
|
+ replot(rpQueuedReplot);
|
|
|
+ } else if (mSelectionRect)
|
|
|
+ mSelectionRect->layer()->replot();
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ This slot is connected to the selection rect's \ref QCPSelectionRect::accepted signal when \ref
|
|
|
+ setSelectionRectMode is set to \ref QCP::srmZoom.
|
|
|
+
|
|
|
+ It determines which axis rect was the origin of the selection rect judging by the starting point
|
|
|
+ of the selection, and then zooms the axes defined via \ref QCPAxisRect::setRangeZoomAxes to the
|
|
|
+ provided \a rect (see \ref QCPAxisRect::zoom).
|
|
|
+
|
|
|
+ \see processRectSelection
|
|
|
+*/
|
|
|
+void QCustomPlot::processRectZoom(QRect rect, QMouseEvent *event)
|
|
|
+{
|
|
|
+ Q_UNUSED(event)
|
|
|
+ if (QCPAxisRect *axisRect = axisRectAt(rect.topLeft()))
|
|
|
+ {
|
|
|
+ QList<QCPAxis*> affectedAxes = QList<QCPAxis*>() << axisRect->rangeZoomAxes(Qt::Horizontal) << axisRect->rangeZoomAxes(Qt::Vertical);
|
|
|
+ affectedAxes.removeAll(static_cast<QCPAxis*>(0));
|
|
|
+ axisRect->zoom(QRectF(rect), affectedAxes);
|
|
|
+ }
|
|
|
+ replot(rpQueuedReplot); // always replot to make selection rect disappear
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ This method is called when a simple left mouse click was detected on the QCustomPlot surface.
|
|
|
+
|
|
|
+ It first determines the layerable that was hit by the click, and then calls its \ref
|
|
|
+ QCPLayerable::selectEvent. All other layerables receive a QCPLayerable::deselectEvent (unless the
|
|
|
+ multi-select modifier was pressed, see \ref setMultiSelectModifier).
|
|
|
+
|
|
|
+ In this method the hit layerable is determined a second time using \ref layerableAt (after the
|
|
|
+ one in \ref mousePressEvent), because we want \a onlySelectable set to true this time. This
|
|
|
+ implies that the mouse event grabber (mMouseEventLayerable) may be a different one from the
|
|
|
+ clicked layerable determined here. For example, if a non-selectable layerable is in front of a
|
|
|
+ selectable layerable at the click position, the front layerable will receive mouse events but the
|
|
|
+ selectable one in the back will receive the \ref QCPLayerable::selectEvent.
|
|
|
+
|
|
|
+ \see processRectSelection, QCPLayerable::selectTest
|
|
|
+*/
|
|
|
+void QCustomPlot::processPointSelection(QMouseEvent *event)
|
|
|
+{
|
|
|
+ QVariant details;
|
|
|
+ QCPLayerable *clickedLayerable = layerableAt(event->pos(), true, &details);
|
|
|
+ bool selectionStateChanged = false;
|
|
|
+ bool additive = mInteractions.testFlag(QCP::iMultiSelect) && event->modifiers().testFlag(mMultiSelectModifier);
|
|
|
+ // deselect all other layerables if not additive selection:
|
|
|
+ if (!additive)
|
|
|
+ {
|
|
|
+ foreach (QCPLayer *layer, mLayers)
|
|
|
+ {
|
|
|
+ foreach (QCPLayerable *layerable, layer->children())
|
|
|
+ {
|
|
|
+ if (layerable != clickedLayerable && mInteractions.testFlag(layerable->selectionCategory()))
|
|
|
+ {
|
|
|
+ bool selChanged = false;
|
|
|
+ layerable->deselectEvent(&selChanged);
|
|
|
+ selectionStateChanged |= selChanged;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (clickedLayerable && mInteractions.testFlag(clickedLayerable->selectionCategory()))
|
|
|
+ {
|
|
|
+ // a layerable was actually clicked, call its selectEvent:
|
|
|
+ bool selChanged = false;
|
|
|
+ clickedLayerable->selectEvent(event, additive, details, &selChanged);
|
|
|
+ selectionStateChanged |= selChanged;
|
|
|
+ }
|
|
|
+ if (selectionStateChanged)
|
|
|
+ {
|
|
|
+ emit selectionChangedByUser();
|
|
|
+ replot(rpQueuedReplot);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Registers the specified plottable with this QCustomPlot and, if \ref setAutoAddPlottableToLegend
|
|
|
+ is enabled, adds it to the legend (QCustomPlot::legend). QCustomPlot takes ownership of the
|
|
|
+ plottable.
|
|
|
+
|
|
|
+ Returns true on success, i.e. when \a plottable isn't already in this plot and the parent plot of
|
|
|
+ \a plottable is this QCustomPlot.
|
|
|
+
|
|
|
+ This method is called automatically in the QCPAbstractPlottable base class constructor.
|
|
|
+*/
|
|
|
+bool QCustomPlot::registerPlottable(QCPAbstractPlottable *plottable)
|
|
|
+{
|
|
|
+ if (mPlottables.contains(plottable))
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "plottable already added to this QCustomPlot:" << reinterpret_cast<quintptr>(plottable);
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ if (plottable->parentPlot() != this)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "plottable not created with this QCustomPlot as parent:" << reinterpret_cast<quintptr>(plottable);
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ mPlottables.append(plottable);
|
|
|
+ // possibly add plottable to legend:
|
|
|
+ if (mAutoAddPlottableToLegend)
|
|
|
+ plottable->addToLegend();
|
|
|
+ if (!plottable->layer()) // usually the layer is already set in the constructor of the plottable (via QCPLayerable constructor)
|
|
|
+ plottable->setLayer(currentLayer());
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ In order to maintain the simplified graph interface of QCustomPlot, this method is called by the
|
|
|
+ QCPGraph constructor to register itself with this QCustomPlot's internal graph list. Returns true
|
|
|
+ on success, i.e. if \a graph is valid and wasn't already registered with this QCustomPlot.
|
|
|
+
|
|
|
+ This graph specific registration happens in addition to the call to \ref registerPlottable by the
|
|
|
+ QCPAbstractPlottable base class.
|
|
|
+*/
|
|
|
+bool QCustomPlot::registerGraph(QCPGraph *graph)
|
|
|
+{
|
|
|
+ if (!graph)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "passed graph is zero";
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ if (mGraphs.contains(graph))
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "graph already registered with this QCustomPlot";
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ mGraphs.append(graph);
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Registers the specified item with this QCustomPlot. QCustomPlot takes ownership of the item.
|
|
|
+
|
|
|
+ Returns true on success, i.e. when \a item wasn't already in the plot and the parent plot of \a
|
|
|
+ item is this QCustomPlot.
|
|
|
+
|
|
|
+ This method is called automatically in the QCPAbstractItem base class constructor.
|
|
|
+*/
|
|
|
+bool QCustomPlot::registerItem(QCPAbstractItem *item)
|
|
|
+{
|
|
|
+ if (mItems.contains(item))
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "item already added to this QCustomPlot:" << reinterpret_cast<quintptr>(item);
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ if (item->parentPlot() != this)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "item not created with this QCustomPlot as parent:" << reinterpret_cast<quintptr>(item);
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ mItems.append(item);
|
|
|
+ if (!item->layer()) // usually the layer is already set in the constructor of the item (via QCPLayerable constructor)
|
|
|
+ item->setLayer(currentLayer());
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Assigns all layers their index (QCPLayer::mIndex) in the mLayers list. This method is thus called
|
|
|
+ after every operation that changes the layer indices, like layer removal, layer creation, layer
|
|
|
+ moving.
|
|
|
+*/
|
|
|
+void QCustomPlot::updateLayerIndices() const
|
|
|
+{
|
|
|
+ for (int i=0; i<mLayers.size(); ++i)
|
|
|
+ mLayers.at(i)->mIndex = i;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the top-most layerable at pixel position \a pos. If \a onlySelectable is set to true,
|
|
|
+ only those layerables that are selectable will be considered. (Layerable subclasses communicate
|
|
|
+ their selectability via the QCPLayerable::selectTest method, by returning -1.)
|
|
|
+
|
|
|
+ \a selectionDetails is an output parameter that contains selection specifics of the affected
|
|
|
+ layerable. This is useful if the respective layerable shall be given a subsequent
|
|
|
+ QCPLayerable::selectEvent (like in \ref mouseReleaseEvent). \a selectionDetails usually contains
|
|
|
+ information about which part of the layerable was hit, in multi-part layerables (e.g.
|
|
|
+ QCPAxis::SelectablePart). If the layerable is a plottable, \a selectionDetails contains a \ref
|
|
|
+ QCPDataSelection instance with the single data point which is closest to \a pos.
|
|
|
+
|
|
|
+ \see layerableListAt, layoutElementAt, axisRectAt
|
|
|
+*/
|
|
|
+QCPLayerable *QCustomPlot::layerableAt(const QPointF &pos, bool onlySelectable, QVariant *selectionDetails) const
|
|
|
+{
|
|
|
+ QList<QVariant> details;
|
|
|
+ QList<QCPLayerable*> candidates = layerableListAt(pos, onlySelectable, selectionDetails ? &details : 0);
|
|
|
+ if (selectionDetails && !details.isEmpty())
|
|
|
+ *selectionDetails = details.first();
|
|
|
+ if (!candidates.isEmpty())
|
|
|
+ return candidates.first();
|
|
|
+ else
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the layerables at pixel position \a pos. If \a onlySelectable is set to true, only those
|
|
|
+ layerables that are selectable will be considered. (Layerable subclasses communicate their
|
|
|
+ selectability via the QCPLayerable::selectTest method, by returning -1.)
|
|
|
+
|
|
|
+ The returned list is sorted by the layerable/drawing order. If you only need to know the top-most
|
|
|
+ layerable, rather use \ref layerableAt.
|
|
|
+
|
|
|
+ \a selectionDetails is an output parameter that contains selection specifics of the affected
|
|
|
+ layerable. This is useful if the respective layerable shall be given a subsequent
|
|
|
+ QCPLayerable::selectEvent (like in \ref mouseReleaseEvent). \a selectionDetails usually contains
|
|
|
+ information about which part of the layerable was hit, in multi-part layerables (e.g.
|
|
|
+ QCPAxis::SelectablePart). If the layerable is a plottable, \a selectionDetails contains a \ref
|
|
|
+ QCPDataSelection instance with the single data point which is closest to \a pos.
|
|
|
+
|
|
|
+ \see layerableAt, layoutElementAt, axisRectAt
|
|
|
+*/
|
|
|
+QList<QCPLayerable*> QCustomPlot::layerableListAt(const QPointF &pos, bool onlySelectable, QList<QVariant> *selectionDetails) const
|
|
|
+{
|
|
|
+ QList<QCPLayerable*> result;
|
|
|
+ for (int layerIndex=mLayers.size()-1; layerIndex>=0; --layerIndex)
|
|
|
+ {
|
|
|
+ const QList<QCPLayerable*> layerables = mLayers.at(layerIndex)->children();
|
|
|
+ for (int i=layerables.size()-1; i>=0; --i)
|
|
|
+ {
|
|
|
+ if (!layerables.at(i)->realVisibility())
|
|
|
+ continue;
|
|
|
+ QVariant details;
|
|
|
+ double dist = layerables.at(i)->selectTest(pos, onlySelectable, selectionDetails ? &details : 0);
|
|
|
+ if (dist >= 0 && dist < selectionTolerance())
|
|
|
+ {
|
|
|
+ result.append(layerables.at(i));
|
|
|
+ if (selectionDetails)
|
|
|
+ selectionDetails->append(details);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Saves the plot to a rastered image file \a fileName in the image format \a format. The plot is
|
|
|
+ sized to \a width and \a height in pixels and scaled with \a scale. (width 100 and scale 2.0 lead
|
|
|
+ to a full resolution file with width 200.) If the \a format supports compression, \a quality may
|
|
|
+ be between 0 and 100 to control it.
|
|
|
+
|
|
|
+ Returns true on success. If this function fails, most likely the given \a format isn't supported
|
|
|
+ by the system, see Qt docs about QImageWriter::supportedImageFormats().
|
|
|
+
|
|
|
+ The \a resolution will be written to the image file header (if the file format supports this) and
|
|
|
+ has no direct consequence for the quality or the pixel size. However, if opening the image with a
|
|
|
+ tool which respects the metadata, it will be able to scale the image to match either a given size
|
|
|
+ in real units of length (inch, centimeters, etc.), or the target display DPI. You can specify in
|
|
|
+ which units \a resolution is given, by setting \a resolutionUnit. The \a resolution is converted
|
|
|
+ to the format's expected resolution unit internally.
|
|
|
+
|
|
|
+ \see saveBmp, saveJpg, savePng, savePdf
|
|
|
+*/
|
|
|
+bool QCustomPlot::saveRastered(const QString &fileName, int width, int height, double scale, const char *format, int quality, int resolution, QCP::ResolutionUnit resolutionUnit)
|
|
|
+{
|
|
|
+ QImage buffer = toPixmap(width, height, scale).toImage();
|
|
|
+
|
|
|
+ int dotsPerMeter = 0;
|
|
|
+ switch (resolutionUnit)
|
|
|
+ {
|
|
|
+ case QCP::ruDotsPerMeter: dotsPerMeter = resolution; break;
|
|
|
+ case QCP::ruDotsPerCentimeter: dotsPerMeter = resolution*100; break;
|
|
|
+ case QCP::ruDotsPerInch: dotsPerMeter = resolution/0.0254; break;
|
|
|
+ }
|
|
|
+ buffer.setDotsPerMeterX(dotsPerMeter); // this is saved together with some image formats, e.g. PNG, and is relevant when opening image in other tools
|
|
|
+ buffer.setDotsPerMeterY(dotsPerMeter); // this is saved together with some image formats, e.g. PNG, and is relevant when opening image in other tools
|
|
|
+ if (!buffer.isNull())
|
|
|
+ return buffer.save(fileName, format, quality);
|
|
|
+ else
|
|
|
+ return false;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Renders the plot to a pixmap and returns it.
|
|
|
+
|
|
|
+ The plot is sized to \a width and \a height in pixels and scaled with \a scale. (width 100 and
|
|
|
+ scale 2.0 lead to a full resolution pixmap with width 200.)
|
|
|
+
|
|
|
+ \see toPainter, saveRastered, saveBmp, savePng, saveJpg, savePdf
|
|
|
+*/
|
|
|
+QPixmap QCustomPlot::toPixmap(int width, int height, double scale)
|
|
|
+{
|
|
|
+ // this method is somewhat similar to toPainter. Change something here, and a change in toPainter might be necessary, too.
|
|
|
+ int newWidth, newHeight;
|
|
|
+ if (width == 0 || height == 0)
|
|
|
+ {
|
|
|
+ newWidth = this->width();
|
|
|
+ newHeight = this->height();
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ newWidth = width;
|
|
|
+ newHeight = height;
|
|
|
+ }
|
|
|
+ int scaledWidth = qRound(scale*newWidth);
|
|
|
+ int scaledHeight = qRound(scale*newHeight);
|
|
|
+
|
|
|
+ QPixmap result(scaledWidth, scaledHeight);
|
|
|
+ result.fill(mBackgroundBrush.style() == Qt::SolidPattern ? mBackgroundBrush.color() : Qt::transparent); // if using non-solid pattern, make transparent now and draw brush pattern later
|
|
|
+ QCPPainter painter;
|
|
|
+ painter.begin(&result);
|
|
|
+ if (painter.isActive())
|
|
|
+ {
|
|
|
+ QRect oldViewport = viewport();
|
|
|
+ setViewport(QRect(0, 0, newWidth, newHeight));
|
|
|
+ painter.setMode(QCPPainter::pmNoCaching);
|
|
|
+ if (!qFuzzyCompare(scale, 1.0))
|
|
|
+ {
|
|
|
+ if (scale > 1.0) // for scale < 1 we always want cosmetic pens where possible, because else lines might disappear for very small scales
|
|
|
+ painter.setMode(QCPPainter::pmNonCosmetic);
|
|
|
+ painter.scale(scale, scale);
|
|
|
+ }
|
|
|
+ if (mBackgroundBrush.style() != Qt::SolidPattern && mBackgroundBrush.style() != Qt::NoBrush) // solid fills were done a few lines above with QPixmap::fill
|
|
|
+ painter.fillRect(mViewport, mBackgroundBrush);
|
|
|
+ draw(&painter);
|
|
|
+ setViewport(oldViewport);
|
|
|
+ painter.end();
|
|
|
+ } else // might happen if pixmap has width or height zero
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "Couldn't activate painter on pixmap";
|
|
|
+ return QPixmap();
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Renders the plot using the passed \a painter.
|
|
|
+
|
|
|
+ The plot is sized to \a width and \a height in pixels. If the \a painter's scale is not 1.0, the resulting plot will
|
|
|
+ appear scaled accordingly.
|
|
|
+
|
|
|
+ \note If you are restricted to using a QPainter (instead of QCPPainter), create a temporary QPicture and open a QCPPainter
|
|
|
+ on it. Then call \ref toPainter with this QCPPainter. After ending the paint operation on the picture, draw it with
|
|
|
+ the QPainter. This will reproduce the painter actions the QCPPainter took, with a QPainter.
|
|
|
+
|
|
|
+ \see toPixmap
|
|
|
+*/
|
|
|
+void QCustomPlot::toPainter(QCPPainter *painter, int width, int height)
|
|
|
+{
|
|
|
+ // this method is somewhat similar to toPixmap. Change something here, and a change in toPixmap might be necessary, too.
|
|
|
+ int newWidth, newHeight;
|
|
|
+ if (width == 0 || height == 0)
|
|
|
+ {
|
|
|
+ newWidth = this->width();
|
|
|
+ newHeight = this->height();
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ newWidth = width;
|
|
|
+ newHeight = height;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (painter->isActive())
|
|
|
+ {
|
|
|
+ QRect oldViewport = viewport();
|
|
|
+ setViewport(QRect(0, 0, newWidth, newHeight));
|
|
|
+ painter->setMode(QCPPainter::pmNoCaching);
|
|
|
+ if (mBackgroundBrush.style() != Qt::NoBrush) // unlike in toPixmap, we can't do QPixmap::fill for Qt::SolidPattern brush style, so we also draw solid fills with fillRect here
|
|
|
+ painter->fillRect(mViewport, mBackgroundBrush);
|
|
|
+ draw(painter);
|
|
|
+ setViewport(oldViewport);
|
|
|
+ } else
|
|
|
+ qDebug() << Q_FUNC_INFO << "Passed painter is not active";
|
|
|
+}
|
|
|
+/* end of 'src/core.cpp' */
|
|
|
+
|
|
|
+//amalgamation: add plottable1d.cpp
|
|
|
+
|
|
|
+/* including file 'src/colorgradient.cpp', size 24646 */
|
|
|
+/* commit 9868e55d3b412f2f89766bb482fcf299e93a0988 2017-09-04 01:56:22 +0200 */
|
|
|
+
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPColorGradient
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+/*! \class QCPColorGradient
|
|
|
+ \brief Defines a color gradient for use with e.g. \ref QCPColorMap
|
|
|
+
|
|
|
+ This class describes a color gradient which can be used to encode data with color. For example,
|
|
|
+ QCPColorMap and QCPColorScale have \ref QCPColorMap::setGradient "setGradient" methods which
|
|
|
+ take an instance of this class. Colors are set with \ref setColorStopAt(double position, const QColor &color)
|
|
|
+ with a \a position from 0 to 1. In between these defined color positions, the
|
|
|
+ color will be interpolated linearly either in RGB or HSV space, see \ref setColorInterpolation.
|
|
|
+
|
|
|
+ Alternatively, load one of the preset color gradients shown in the image below, with \ref
|
|
|
+ loadPreset, or by directly specifying the preset in the constructor.
|
|
|
+
|
|
|
+ Apart from red, green and blue components, the gradient also interpolates the alpha values of the
|
|
|
+ configured color stops. This allows to display some portions of the data range as transparent in
|
|
|
+ the plot.
|
|
|
+
|
|
|
+ \image html QCPColorGradient.png
|
|
|
+
|
|
|
+ The \ref QCPColorGradient(GradientPreset preset) constructor allows directly converting a \ref
|
|
|
+ GradientPreset to a QCPColorGradient. This means that you can directly pass \ref GradientPreset
|
|
|
+ to all the \a setGradient methods, e.g.:
|
|
|
+ \snippet documentation/doc-code-snippets/mainwindow.cpp qcpcolorgradient-setgradient
|
|
|
+
|
|
|
+ The total number of levels used in the gradient can be set with \ref setLevelCount. Whether the
|
|
|
+ color gradient shall be applied periodically (wrapping around) to data values that lie outside
|
|
|
+ the data range specified on the plottable instance can be controlled with \ref setPeriodic.
|
|
|
+*/
|
|
|
+
|
|
|
+/*!
|
|
|
+ Constructs a new, empty QCPColorGradient with no predefined color stops. You can add own color
|
|
|
+ stops with \ref setColorStopAt.
|
|
|
+
|
|
|
+ The color level count is initialized to 350.
|
|
|
+*/
|
|
|
+QCPColorGradient::QCPColorGradient() :
|
|
|
+ mLevelCount(350),
|
|
|
+ mColorInterpolation(ciRGB),
|
|
|
+ mPeriodic(false),
|
|
|
+ mColorBufferInvalidated(true)
|
|
|
+{
|
|
|
+ mColorBuffer.fill(qRgb(0, 0, 0), mLevelCount);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Constructs a new QCPColorGradient initialized with the colors and color interpolation according
|
|
|
+ to \a preset.
|
|
|
+
|
|
|
+ The color level count is initialized to 350.
|
|
|
+*/
|
|
|
+QCPColorGradient::QCPColorGradient(GradientPreset preset) :
|
|
|
+ mLevelCount(350),
|
|
|
+ mColorInterpolation(ciRGB),
|
|
|
+ mPeriodic(false),
|
|
|
+ mColorBufferInvalidated(true)
|
|
|
+{
|
|
|
+ mColorBuffer.fill(qRgb(0, 0, 0), mLevelCount);
|
|
|
+ loadPreset(preset);
|
|
|
+}
|
|
|
+
|
|
|
+/* undocumented operator */
|
|
|
+bool QCPColorGradient::operator==(const QCPColorGradient &other) const
|
|
|
+{
|
|
|
+ return ((other.mLevelCount == this->mLevelCount) &&
|
|
|
+ (other.mColorInterpolation == this->mColorInterpolation) &&
|
|
|
+ (other.mPeriodic == this->mPeriodic) &&
|
|
|
+ (other.mColorStops == this->mColorStops));
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the number of discretization levels of the color gradient to \a n. The default is 350 which
|
|
|
+ is typically enough to create a smooth appearance. The minimum number of levels is 2.
|
|
|
+
|
|
|
+ \image html QCPColorGradient-levelcount.png
|
|
|
+*/
|
|
|
+void QCPColorGradient::setLevelCount(int n)
|
|
|
+{
|
|
|
+ if (n < 2)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "n must be greater or equal 2 but was" << n;
|
|
|
+ n = 2;
|
|
|
+ }
|
|
|
+ if (n != mLevelCount)
|
|
|
+ {
|
|
|
+ mLevelCount = n;
|
|
|
+ mColorBufferInvalidated = true;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets at which positions from 0 to 1 which color shall occur. The positions are the keys, the
|
|
|
+ colors are the values of the passed QMap \a colorStops. In between these color stops, the color
|
|
|
+ is interpolated according to \ref setColorInterpolation.
|
|
|
+
|
|
|
+ A more convenient way to create a custom gradient may be to clear all color stops with \ref
|
|
|
+ clearColorStops (or creating a new, empty QCPColorGradient) and then adding them one by one with
|
|
|
+ \ref setColorStopAt.
|
|
|
+
|
|
|
+ \see clearColorStops
|
|
|
+*/
|
|
|
+void QCPColorGradient::setColorStops(const QMap<double, QColor> &colorStops)
|
|
|
+{
|
|
|
+ mColorStops = colorStops;
|
|
|
+ mColorBufferInvalidated = true;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the \a color the gradient will have at the specified \a position (from 0 to 1). In between
|
|
|
+ these color stops, the color is interpolated according to \ref setColorInterpolation.
|
|
|
+
|
|
|
+ \see setColorStops, clearColorStops
|
|
|
+*/
|
|
|
+void QCPColorGradient::setColorStopAt(double position, const QColor &color)
|
|
|
+{
|
|
|
+ mColorStops.insert(position, color);
|
|
|
+ mColorBufferInvalidated = true;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets whether the colors in between the configured color stops (see \ref setColorStopAt) shall be
|
|
|
+ interpolated linearly in RGB or in HSV color space.
|
|
|
+
|
|
|
+ For example, a sweep in RGB space from red to green will have a muddy brown intermediate color,
|
|
|
+ whereas in HSV space the intermediate color is yellow.
|
|
|
+*/
|
|
|
+void QCPColorGradient::setColorInterpolation(QCPColorGradient::ColorInterpolation interpolation)
|
|
|
+{
|
|
|
+ if (interpolation != mColorInterpolation)
|
|
|
+ {
|
|
|
+ mColorInterpolation = interpolation;
|
|
|
+ mColorBufferInvalidated = true;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets whether data points that are outside the configured data range (e.g. \ref
|
|
|
+ QCPColorMap::setDataRange) are colored by periodically repeating the color gradient or whether
|
|
|
+ they all have the same color, corresponding to the respective gradient boundary color.
|
|
|
+
|
|
|
+ \image html QCPColorGradient-periodic.png
|
|
|
+
|
|
|
+ As shown in the image above, gradients that have the same start and end color are especially
|
|
|
+ suitable for a periodic gradient mapping, since they produce smooth color transitions throughout
|
|
|
+ the color map. A preset that has this property is \ref gpHues.
|
|
|
+
|
|
|
+ In practice, using periodic color gradients makes sense when the data corresponds to a periodic
|
|
|
+ dimension, such as an angle or a phase. If this is not the case, the color encoding might become
|
|
|
+ ambiguous, because multiple different data values are shown as the same color.
|
|
|
+*/
|
|
|
+void QCPColorGradient::setPeriodic(bool enabled)
|
|
|
+{
|
|
|
+ mPeriodic = enabled;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ This method is used to quickly convert a \a data array to colors. The colors will be output in
|
|
|
+ the array \a scanLine. Both \a data and \a scanLine must have the length \a n when passed to this
|
|
|
+ function. The data range that shall be used for mapping the data value to the gradient is passed
|
|
|
+ in \a range. \a logarithmic indicates whether the data values shall be mapped to colors
|
|
|
+ logarithmically.
|
|
|
+
|
|
|
+ if \a data actually contains 2D-data linearized via <tt>[row*columnCount + column]</tt>, you can
|
|
|
+ set \a dataIndexFactor to <tt>columnCount</tt> to convert a column instead of a row of the data
|
|
|
+ array, in \a scanLine. \a scanLine will remain a regular (1D) array. This works because \a data
|
|
|
+ is addressed <tt>data[i*dataIndexFactor]</tt>.
|
|
|
+
|
|
|
+ Use the overloaded method to additionally provide alpha map data.
|
|
|
+
|
|
|
+ The QRgb values that are placed in \a scanLine have their r, g and b components premultiplied
|
|
|
+ with alpha (see QImage::Format_ARGB32_Premultiplied).
|
|
|
+*/
|
|
|
+void QCPColorGradient::colorize(const double *data, const QCPRange &range, QRgb *scanLine, int n, int dataIndexFactor, bool logarithmic)
|
|
|
+{
|
|
|
+ // If you change something here, make sure to also adapt color() and the other colorize() overload
|
|
|
+ if (!data)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "null pointer given as data";
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ if (!scanLine)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "null pointer given as scanLine";
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ if (mColorBufferInvalidated)
|
|
|
+ updateColorBuffer();
|
|
|
+
|
|
|
+ if (!logarithmic)
|
|
|
+ {
|
|
|
+ const double posToIndexFactor = (mLevelCount-1)/range.size();
|
|
|
+ if (mPeriodic)
|
|
|
+ {
|
|
|
+ for (int i=0; i<n; ++i)
|
|
|
+ {
|
|
|
+ int index = (int)((data[dataIndexFactor*i]-range.lower)*posToIndexFactor) % mLevelCount;
|
|
|
+ if (index < 0)
|
|
|
+ index += mLevelCount;
|
|
|
+ scanLine[i] = mColorBuffer.at(index);
|
|
|
+ }
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ for (int i=0; i<n; ++i)
|
|
|
+ {
|
|
|
+ int index = (data[dataIndexFactor*i]-range.lower)*posToIndexFactor;
|
|
|
+ if (index < 0)
|
|
|
+ index = 0;
|
|
|
+ else if (index >= mLevelCount)
|
|
|
+ index = mLevelCount-1;
|
|
|
+ scanLine[i] = mColorBuffer.at(index);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } else // logarithmic == true
|
|
|
+ {
|
|
|
+ if (mPeriodic)
|
|
|
+ {
|
|
|
+ for (int i=0; i<n; ++i)
|
|
|
+ {
|
|
|
+ int index = (int)(qLn(data[dataIndexFactor*i]/range.lower)/qLn(range.upper/range.lower)*(mLevelCount-1)) % mLevelCount;
|
|
|
+ if (index < 0)
|
|
|
+ index += mLevelCount;
|
|
|
+ scanLine[i] = mColorBuffer.at(index);
|
|
|
+ }
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ for (int i=0; i<n; ++i)
|
|
|
+ {
|
|
|
+ int index = qLn(data[dataIndexFactor*i]/range.lower)/qLn(range.upper/range.lower)*(mLevelCount-1);
|
|
|
+ if (index < 0)
|
|
|
+ index = 0;
|
|
|
+ else if (index >= mLevelCount)
|
|
|
+ index = mLevelCount-1;
|
|
|
+ scanLine[i] = mColorBuffer.at(index);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Additionally to the other overload of \ref colorize, this method takes the array \a alpha, which
|
|
|
+ has the same size and structure as \a data and encodes the alpha information per data point.
|
|
|
+
|
|
|
+ The QRgb values that are placed in \a scanLine have their r, g and b components premultiplied
|
|
|
+ with alpha (see QImage::Format_ARGB32_Premultiplied).
|
|
|
+*/
|
|
|
+void QCPColorGradient::colorize(const double *data, const unsigned char *alpha, const QCPRange &range, QRgb *scanLine, int n, int dataIndexFactor, bool logarithmic)
|
|
|
+{
|
|
|
+ // If you change something here, make sure to also adapt color() and the other colorize() overload
|
|
|
+ if (!data)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "null pointer given as data";
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ if (!alpha)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "null pointer given as alpha";
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ if (!scanLine)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "null pointer given as scanLine";
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ if (mColorBufferInvalidated)
|
|
|
+ updateColorBuffer();
|
|
|
+
|
|
|
+ if (!logarithmic)
|
|
|
+ {
|
|
|
+ const double posToIndexFactor = (mLevelCount-1)/range.size();
|
|
|
+ if (mPeriodic)
|
|
|
+ {
|
|
|
+ for (int i=0; i<n; ++i)
|
|
|
+ {
|
|
|
+ int index = (int)((data[dataIndexFactor*i]-range.lower)*posToIndexFactor) % mLevelCount;
|
|
|
+ if (index < 0)
|
|
|
+ index += mLevelCount;
|
|
|
+ if (alpha[dataIndexFactor*i] == 255)
|
|
|
+ {
|
|
|
+ scanLine[i] = mColorBuffer.at(index);
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ const QRgb rgb = mColorBuffer.at(index);
|
|
|
+ const float alphaF = alpha[dataIndexFactor*i]/255.0f;
|
|
|
+ scanLine[i] = qRgba(qRed(rgb)*alphaF, qGreen(rgb)*alphaF, qBlue(rgb)*alphaF, qAlpha(rgb)*alphaF);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ for (int i=0; i<n; ++i)
|
|
|
+ {
|
|
|
+ int index = (data[dataIndexFactor*i]-range.lower)*posToIndexFactor;
|
|
|
+ if (index < 0)
|
|
|
+ index = 0;
|
|
|
+ else if (index >= mLevelCount)
|
|
|
+ index = mLevelCount-1;
|
|
|
+ if (alpha[dataIndexFactor*i] == 255)
|
|
|
+ {
|
|
|
+ scanLine[i] = mColorBuffer.at(index);
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ const QRgb rgb = mColorBuffer.at(index);
|
|
|
+ const float alphaF = alpha[dataIndexFactor*i]/255.0f;
|
|
|
+ scanLine[i] = qRgba(qRed(rgb)*alphaF, qGreen(rgb)*alphaF, qBlue(rgb)*alphaF, qAlpha(rgb)*alphaF);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } else // logarithmic == true
|
|
|
+ {
|
|
|
+ if (mPeriodic)
|
|
|
+ {
|
|
|
+ for (int i=0; i<n; ++i)
|
|
|
+ {
|
|
|
+ int index = (int)(qLn(data[dataIndexFactor*i]/range.lower)/qLn(range.upper/range.lower)*(mLevelCount-1)) % mLevelCount;
|
|
|
+ if (index < 0)
|
|
|
+ index += mLevelCount;
|
|
|
+ if (alpha[dataIndexFactor*i] == 255)
|
|
|
+ {
|
|
|
+ scanLine[i] = mColorBuffer.at(index);
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ const QRgb rgb = mColorBuffer.at(index);
|
|
|
+ const float alphaF = alpha[dataIndexFactor*i]/255.0f;
|
|
|
+ scanLine[i] = qRgba(qRed(rgb)*alphaF, qGreen(rgb)*alphaF, qBlue(rgb)*alphaF, qAlpha(rgb)*alphaF);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ for (int i=0; i<n; ++i)
|
|
|
+ {
|
|
|
+ int index = qLn(data[dataIndexFactor*i]/range.lower)/qLn(range.upper/range.lower)*(mLevelCount-1);
|
|
|
+ if (index < 0)
|
|
|
+ index = 0;
|
|
|
+ else if (index >= mLevelCount)
|
|
|
+ index = mLevelCount-1;
|
|
|
+ if (alpha[dataIndexFactor*i] == 255)
|
|
|
+ {
|
|
|
+ scanLine[i] = mColorBuffer.at(index);
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ const QRgb rgb = mColorBuffer.at(index);
|
|
|
+ const float alphaF = alpha[dataIndexFactor*i]/255.0f;
|
|
|
+ scanLine[i] = qRgba(qRed(rgb)*alphaF, qGreen(rgb)*alphaF, qBlue(rgb)*alphaF, qAlpha(rgb)*alphaF);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ This method is used to colorize a single data value given in \a position, to colors. The data
|
|
|
+ range that shall be used for mapping the data value to the gradient is passed in \a range. \a
|
|
|
+ logarithmic indicates whether the data value shall be mapped to a color logarithmically.
|
|
|
+
|
|
|
+ If an entire array of data values shall be converted, rather use \ref colorize, for better
|
|
|
+ performance.
|
|
|
+
|
|
|
+ The returned QRgb has its r, g and b components premultiplied with alpha (see
|
|
|
+ QImage::Format_ARGB32_Premultiplied).
|
|
|
+*/
|
|
|
+QRgb QCPColorGradient::color(double position, const QCPRange &range, bool logarithmic)
|
|
|
+{
|
|
|
+ // If you change something here, make sure to also adapt ::colorize()
|
|
|
+ if (mColorBufferInvalidated)
|
|
|
+ updateColorBuffer();
|
|
|
+ int index = 0;
|
|
|
+ if (!logarithmic)
|
|
|
+ index = (position-range.lower)*(mLevelCount-1)/range.size();
|
|
|
+ else
|
|
|
+ index = qLn(position/range.lower)/qLn(range.upper/range.lower)*(mLevelCount-1);
|
|
|
+ if (mPeriodic)
|
|
|
+ {
|
|
|
+ index = index % mLevelCount;
|
|
|
+ if (index < 0)
|
|
|
+ index += mLevelCount;
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ if (index < 0)
|
|
|
+ index = 0;
|
|
|
+ else if (index >= mLevelCount)
|
|
|
+ index = mLevelCount-1;
|
|
|
+ }
|
|
|
+ return mColorBuffer.at(index);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Clears the current color stops and loads the specified \a preset. A preset consists of predefined
|
|
|
+ color stops and the corresponding color interpolation method.
|
|
|
+
|
|
|
+ The available presets are:
|
|
|
+ \image html QCPColorGradient.png
|
|
|
+*/
|
|
|
+void QCPColorGradient::loadPreset(GradientPreset preset)
|
|
|
+{
|
|
|
+ clearColorStops();
|
|
|
+ switch (preset)
|
|
|
+ {
|
|
|
+ case gpGrayscale:
|
|
|
+ setColorInterpolation(ciRGB);
|
|
|
+ setColorStopAt(0, Qt::black);
|
|
|
+ setColorStopAt(1, Qt::white);
|
|
|
+ break;
|
|
|
+ case gpHot:
|
|
|
+ setColorInterpolation(ciRGB);
|
|
|
+ setColorStopAt(0, QColor(50, 0, 0));
|
|
|
+ setColorStopAt(0.2, QColor(180, 10, 0));
|
|
|
+ setColorStopAt(0.4, QColor(245, 50, 0));
|
|
|
+ setColorStopAt(0.6, QColor(255, 150, 10));
|
|
|
+ setColorStopAt(0.8, QColor(255, 255, 50));
|
|
|
+ setColorStopAt(1, QColor(255, 255, 255));
|
|
|
+ break;
|
|
|
+ case gpCold:
|
|
|
+ setColorInterpolation(ciRGB);
|
|
|
+ setColorStopAt(0, QColor(0, 0, 50));
|
|
|
+ setColorStopAt(0.2, QColor(0, 10, 180));
|
|
|
+ setColorStopAt(0.4, QColor(0, 50, 245));
|
|
|
+ setColorStopAt(0.6, QColor(10, 150, 255));
|
|
|
+ setColorStopAt(0.8, QColor(50, 255, 255));
|
|
|
+ setColorStopAt(1, QColor(255, 255, 255));
|
|
|
+ break;
|
|
|
+ case gpNight:
|
|
|
+ setColorInterpolation(ciHSV);
|
|
|
+ setColorStopAt(0, QColor(10, 20, 30));
|
|
|
+ setColorStopAt(1, QColor(250, 255, 250));
|
|
|
+ break;
|
|
|
+ case gpCandy:
|
|
|
+ setColorInterpolation(ciHSV);
|
|
|
+ setColorStopAt(0, QColor(0, 0, 255));
|
|
|
+ setColorStopAt(1, QColor(255, 250, 250));
|
|
|
+ break;
|
|
|
+ case gpGeography:
|
|
|
+ setColorInterpolation(ciRGB);
|
|
|
+ setColorStopAt(0, QColor(70, 170, 210));
|
|
|
+ setColorStopAt(0.20, QColor(90, 160, 180));
|
|
|
+ setColorStopAt(0.25, QColor(45, 130, 175));
|
|
|
+ setColorStopAt(0.30, QColor(100, 140, 125));
|
|
|
+ setColorStopAt(0.5, QColor(100, 140, 100));
|
|
|
+ setColorStopAt(0.6, QColor(130, 145, 120));
|
|
|
+ setColorStopAt(0.7, QColor(140, 130, 120));
|
|
|
+ setColorStopAt(0.9, QColor(180, 190, 190));
|
|
|
+ setColorStopAt(1, QColor(210, 210, 230));
|
|
|
+ break;
|
|
|
+ case gpIon:
|
|
|
+ setColorInterpolation(ciHSV);
|
|
|
+ setColorStopAt(0, QColor(50, 10, 10));
|
|
|
+ setColorStopAt(0.45, QColor(0, 0, 255));
|
|
|
+ setColorStopAt(0.8, QColor(0, 255, 255));
|
|
|
+ setColorStopAt(1, QColor(0, 255, 0));
|
|
|
+ break;
|
|
|
+ case gpThermal:
|
|
|
+ setColorInterpolation(ciRGB);
|
|
|
+ setColorStopAt(0, QColor(0, 0, 50));
|
|
|
+ setColorStopAt(0.15, QColor(20, 0, 120));
|
|
|
+ setColorStopAt(0.33, QColor(200, 30, 140));
|
|
|
+ setColorStopAt(0.6, QColor(255, 100, 0));
|
|
|
+ setColorStopAt(0.85, QColor(255, 255, 40));
|
|
|
+ setColorStopAt(1, QColor(255, 255, 255));
|
|
|
+ break;
|
|
|
+ case gpPolar:
|
|
|
+ setColorInterpolation(ciRGB);
|
|
|
+ setColorStopAt(0, QColor(50, 255, 255));
|
|
|
+ setColorStopAt(0.18, QColor(10, 70, 255));
|
|
|
+ setColorStopAt(0.28, QColor(10, 10, 190));
|
|
|
+ setColorStopAt(0.5, QColor(0, 0, 0));
|
|
|
+ setColorStopAt(0.72, QColor(190, 10, 10));
|
|
|
+ setColorStopAt(0.82, QColor(255, 70, 10));
|
|
|
+ setColorStopAt(1, QColor(255, 255, 50));
|
|
|
+ break;
|
|
|
+ case gpSpectrum:
|
|
|
+ setColorInterpolation(ciHSV);
|
|
|
+ setColorStopAt(0, QColor(50, 0, 50));
|
|
|
+ setColorStopAt(0.15, QColor(0, 0, 255));
|
|
|
+ setColorStopAt(0.35, QColor(0, 255, 255));
|
|
|
+ setColorStopAt(0.6, QColor(255, 255, 0));
|
|
|
+ setColorStopAt(0.75, QColor(255, 30, 0));
|
|
|
+ setColorStopAt(1, QColor(50, 0, 0));
|
|
|
+ break;
|
|
|
+ case gpJet:
|
|
|
+ setColorInterpolation(ciRGB);
|
|
|
+ setColorStopAt(0, QColor(0, 0, 100));
|
|
|
+ setColorStopAt(0.15, QColor(0, 50, 255));
|
|
|
+ setColorStopAt(0.35, QColor(0, 255, 255));
|
|
|
+ setColorStopAt(0.65, QColor(255, 255, 0));
|
|
|
+ setColorStopAt(0.85, QColor(255, 30, 0));
|
|
|
+ setColorStopAt(1, QColor(100, 0, 0));
|
|
|
+ break;
|
|
|
+ case gpHues:
|
|
|
+ setColorInterpolation(ciHSV);
|
|
|
+ setColorStopAt(0, QColor(255, 0, 0));
|
|
|
+ setColorStopAt(1.0/3.0, QColor(0, 0, 255));
|
|
|
+ setColorStopAt(2.0/3.0, QColor(0, 255, 0));
|
|
|
+ setColorStopAt(1, QColor(255, 0, 0));
|
|
|
+ break;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Clears all color stops.
|
|
|
+
|
|
|
+ \see setColorStops, setColorStopAt
|
|
|
+*/
|
|
|
+void QCPColorGradient::clearColorStops()
|
|
|
+{
|
|
|
+ mColorStops.clear();
|
|
|
+ mColorBufferInvalidated = true;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns an inverted gradient. The inverted gradient has all properties as this \ref
|
|
|
+ QCPColorGradient, but the order of the color stops is inverted.
|
|
|
+
|
|
|
+ \see setColorStops, setColorStopAt
|
|
|
+*/
|
|
|
+QCPColorGradient QCPColorGradient::inverted() const
|
|
|
+{
|
|
|
+ QCPColorGradient result(*this);
|
|
|
+ result.clearColorStops();
|
|
|
+ for (QMap<double, QColor>::const_iterator it=mColorStops.constBegin(); it!=mColorStops.constEnd(); ++it)
|
|
|
+ result.setColorStopAt(1.0-it.key(), it.value());
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns true if the color gradient uses transparency, i.e. if any of the configured color stops
|
|
|
+ has an alpha value below 255.
|
|
|
+*/
|
|
|
+bool QCPColorGradient::stopsUseAlpha() const
|
|
|
+{
|
|
|
+ for (QMap<double, QColor>::const_iterator it=mColorStops.constBegin(); it!=mColorStops.constEnd(); ++it)
|
|
|
+ {
|
|
|
+ if (it.value().alpha() < 255)
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ return false;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Updates the internal color buffer which will be used by \ref colorize and \ref color, to quickly
|
|
|
+ convert positions to colors. This is where the interpolation between color stops is calculated.
|
|
|
+*/
|
|
|
+void QCPColorGradient::updateColorBuffer()
|
|
|
+{
|
|
|
+ if (mColorBuffer.size() != mLevelCount)
|
|
|
+ mColorBuffer.resize(mLevelCount);
|
|
|
+ if (mColorStops.size() > 1)
|
|
|
+ {
|
|
|
+ double indexToPosFactor = 1.0/(double)(mLevelCount-1);
|
|
|
+ const bool useAlpha = stopsUseAlpha();
|
|
|
+ for (int i=0; i<mLevelCount; ++i)
|
|
|
+ {
|
|
|
+ double position = i*indexToPosFactor;
|
|
|
+ QMap<double, QColor>::const_iterator it = mColorStops.lowerBound(position);
|
|
|
+ if (it == mColorStops.constEnd()) // position is on or after last stop, use color of last stop
|
|
|
+ {
|
|
|
+ mColorBuffer[i] = (it-1).value().rgba();
|
|
|
+ } else if (it == mColorStops.constBegin()) // position is on or before first stop, use color of first stop
|
|
|
+ {
|
|
|
+ mColorBuffer[i] = it.value().rgba();
|
|
|
+ } else // position is in between stops (or on an intermediate stop), interpolate color
|
|
|
+ {
|
|
|
+ QMap<double, QColor>::const_iterator high = it;
|
|
|
+ QMap<double, QColor>::const_iterator low = it-1;
|
|
|
+ double t = (position-low.key())/(high.key()-low.key()); // interpolation factor 0..1
|
|
|
+ switch (mColorInterpolation)
|
|
|
+ {
|
|
|
+ case ciRGB:
|
|
|
+ {
|
|
|
+ if (useAlpha)
|
|
|
+ {
|
|
|
+ const int alpha = (1-t)*low.value().alpha() + t*high.value().alpha();
|
|
|
+ const float alphaPremultiplier = alpha/255.0f; // since we use QImage::Format_ARGB32_Premultiplied
|
|
|
+ mColorBuffer[i] = qRgba(((1-t)*low.value().red() + t*high.value().red())*alphaPremultiplier,
|
|
|
+ ((1-t)*low.value().green() + t*high.value().green())*alphaPremultiplier,
|
|
|
+ ((1-t)*low.value().blue() + t*high.value().blue())*alphaPremultiplier,
|
|
|
+ alpha);
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ mColorBuffer[i] = qRgb(((1-t)*low.value().red() + t*high.value().red()),
|
|
|
+ ((1-t)*low.value().green() + t*high.value().green()),
|
|
|
+ ((1-t)*low.value().blue() + t*high.value().blue()));
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case ciHSV:
|
|
|
+ {
|
|
|
+ QColor lowHsv = low.value().toHsv();
|
|
|
+ QColor highHsv = high.value().toHsv();
|
|
|
+ double hue = 0;
|
|
|
+ double hueDiff = highHsv.hueF()-lowHsv.hueF();
|
|
|
+ if (hueDiff > 0.5)
|
|
|
+ hue = lowHsv.hueF() - t*(1.0-hueDiff);
|
|
|
+ else if (hueDiff < -0.5)
|
|
|
+ hue = lowHsv.hueF() + t*(1.0+hueDiff);
|
|
|
+ else
|
|
|
+ hue = lowHsv.hueF() + t*hueDiff;
|
|
|
+ if (hue < 0) hue += 1.0;
|
|
|
+ else if (hue >= 1.0) hue -= 1.0;
|
|
|
+ if (useAlpha)
|
|
|
+ {
|
|
|
+ const QRgb rgb = QColor::fromHsvF(hue,
|
|
|
+ (1-t)*lowHsv.saturationF() + t*highHsv.saturationF(),
|
|
|
+ (1-t)*lowHsv.valueF() + t*highHsv.valueF()).rgb();
|
|
|
+ const float alpha = (1-t)*lowHsv.alphaF() + t*highHsv.alphaF();
|
|
|
+ mColorBuffer[i] = qRgba(qRed(rgb)*alpha, qGreen(rgb)*alpha, qBlue(rgb)*alpha, 255*alpha);
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ mColorBuffer[i] = QColor::fromHsvF(hue,
|
|
|
+ (1-t)*lowHsv.saturationF() + t*highHsv.saturationF(),
|
|
|
+ (1-t)*lowHsv.valueF() + t*highHsv.valueF()).rgb();
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } else if (mColorStops.size() == 1)
|
|
|
+ {
|
|
|
+ const QRgb rgb = mColorStops.constBegin().value().rgb();
|
|
|
+ const float alpha = mColorStops.constBegin().value().alphaF();
|
|
|
+ mColorBuffer.fill(qRgba(qRed(rgb)*alpha, qGreen(rgb)*alpha, qBlue(rgb)*alpha, 255*alpha));
|
|
|
+ } else // mColorStops is empty, fill color buffer with black
|
|
|
+ {
|
|
|
+ mColorBuffer.fill(qRgb(0, 0, 0));
|
|
|
+ }
|
|
|
+ mColorBufferInvalidated = false;
|
|
|
+}
|
|
|
+/* end of 'src/colorgradient.cpp' */
|
|
|
+
|
|
|
+
|
|
|
+/* including file 'src/selectiondecorator-bracket.cpp', size 12313 */
|
|
|
+/* commit 9868e55d3b412f2f89766bb482fcf299e93a0988 2017-09-04 01:56:22 +0200 */
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPSelectionDecoratorBracket
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+/*! \class QCPSelectionDecoratorBracket
|
|
|
+ \brief A selection decorator which draws brackets around each selected data segment
|
|
|
+
|
|
|
+ Additionally to the regular highlighting of selected segments via color, fill and scatter style,
|
|
|
+ this \ref QCPSelectionDecorator subclass draws markers at the begin and end of each selected data
|
|
|
+ segment of the plottable.
|
|
|
+
|
|
|
+ The shape of the markers can be controlled with \ref setBracketStyle, \ref setBracketWidth and
|
|
|
+ \ref setBracketHeight. The color/fill can be controlled with \ref setBracketPen and \ref
|
|
|
+ setBracketBrush.
|
|
|
+
|
|
|
+ To introduce custom bracket styles, it is only necessary to sublcass \ref
|
|
|
+ QCPSelectionDecoratorBracket and reimplement \ref drawBracket. The rest will be managed by the
|
|
|
+ base class.
|
|
|
+*/
|
|
|
+
|
|
|
+/*!
|
|
|
+ Creates a new QCPSelectionDecoratorBracket instance with default values.
|
|
|
+*/
|
|
|
+QCPSelectionDecoratorBracket::QCPSelectionDecoratorBracket() :
|
|
|
+ mBracketPen(QPen(Qt::black)),
|
|
|
+ mBracketBrush(Qt::NoBrush),
|
|
|
+ mBracketWidth(5),
|
|
|
+ mBracketHeight(50),
|
|
|
+ mBracketStyle(bsSquareBracket),
|
|
|
+ mTangentToData(false),
|
|
|
+ mTangentAverage(2)
|
|
|
+{
|
|
|
+
|
|
|
+}
|
|
|
+
|
|
|
+QCPSelectionDecoratorBracket::~QCPSelectionDecoratorBracket()
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the pen that will be used to draw the brackets at the beginning and end of each selected
|
|
|
+ data segment.
|
|
|
+*/
|
|
|
+void QCPSelectionDecoratorBracket::setBracketPen(const QPen &pen)
|
|
|
+{
|
|
|
+ mBracketPen = pen;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the brush that will be used to draw the brackets at the beginning and end of each selected
|
|
|
+ data segment.
|
|
|
+*/
|
|
|
+void QCPSelectionDecoratorBracket::setBracketBrush(const QBrush &brush)
|
|
|
+{
|
|
|
+ mBracketBrush = brush;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the width of the drawn bracket. The width dimension is always parallel to the key axis of
|
|
|
+ the data, or the tangent direction of the current data slope, if \ref setTangentToData is
|
|
|
+ enabled.
|
|
|
+*/
|
|
|
+void QCPSelectionDecoratorBracket::setBracketWidth(int width)
|
|
|
+{
|
|
|
+ mBracketWidth = width;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the height of the drawn bracket. The height dimension is always perpendicular to the key axis
|
|
|
+ of the data, or the tangent direction of the current data slope, if \ref setTangentToData is
|
|
|
+ enabled.
|
|
|
+*/
|
|
|
+void QCPSelectionDecoratorBracket::setBracketHeight(int height)
|
|
|
+{
|
|
|
+ mBracketHeight = height;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the shape that the bracket/marker will have.
|
|
|
+
|
|
|
+ \see setBracketWidth, setBracketHeight
|
|
|
+*/
|
|
|
+void QCPSelectionDecoratorBracket::setBracketStyle(QCPSelectionDecoratorBracket::BracketStyle style)
|
|
|
+{
|
|
|
+ mBracketStyle = style;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets whether the brackets will be rotated such that they align with the slope of the data at the
|
|
|
+ position that they appear in.
|
|
|
+
|
|
|
+ For noisy data, it might be more visually appealing to average the slope over multiple data
|
|
|
+ points. This can be configured via \ref setTangentAverage.
|
|
|
+*/
|
|
|
+void QCPSelectionDecoratorBracket::setTangentToData(bool enabled)
|
|
|
+{
|
|
|
+ mTangentToData = enabled;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Controls over how many data points the slope shall be averaged, when brackets shall be aligned
|
|
|
+ with the data (if \ref setTangentToData is true).
|
|
|
+
|
|
|
+ From the position of the bracket, \a pointCount points towards the selected data range will be
|
|
|
+ taken into account. The smallest value of \a pointCount is 1, which is effectively equivalent to
|
|
|
+ disabling \ref setTangentToData.
|
|
|
+*/
|
|
|
+void QCPSelectionDecoratorBracket::setTangentAverage(int pointCount)
|
|
|
+{
|
|
|
+ mTangentAverage = pointCount;
|
|
|
+ if (mTangentAverage < 1)
|
|
|
+ mTangentAverage = 1;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Draws the bracket shape with \a painter. The parameter \a direction is either -1 or 1 and
|
|
|
+ indicates whether the bracket shall point to the left or the right (i.e. is a closing or opening
|
|
|
+ bracket, respectively).
|
|
|
+
|
|
|
+ The passed \a painter already contains all transformations that are necessary to position and
|
|
|
+ rotate the bracket appropriately. Painting operations can be performed as if drawing upright
|
|
|
+ brackets on flat data with horizontal key axis, with (0, 0) being the center of the bracket.
|
|
|
+
|
|
|
+ If you wish to sublcass \ref QCPSelectionDecoratorBracket in order to provide custom bracket
|
|
|
+ shapes (see \ref QCPSelectionDecoratorBracket::bsUserStyle), this is the method you should
|
|
|
+ reimplement.
|
|
|
+*/
|
|
|
+void QCPSelectionDecoratorBracket::drawBracket(QCPPainter *painter, int direction) const
|
|
|
+{
|
|
|
+ switch (mBracketStyle)
|
|
|
+ {
|
|
|
+ case bsSquareBracket:
|
|
|
+ {
|
|
|
+ painter->drawLine(QLineF(mBracketWidth*direction, -mBracketHeight*0.5, 0, -mBracketHeight*0.5));
|
|
|
+ painter->drawLine(QLineF(mBracketWidth*direction, mBracketHeight*0.5, 0, mBracketHeight*0.5));
|
|
|
+ painter->drawLine(QLineF(0, -mBracketHeight*0.5, 0, mBracketHeight*0.5));
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case bsHalfEllipse:
|
|
|
+ {
|
|
|
+ painter->drawArc(-mBracketWidth*0.5, -mBracketHeight*0.5, mBracketWidth, mBracketHeight, -90*16, -180*16*direction);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case bsEllipse:
|
|
|
+ {
|
|
|
+ painter->drawEllipse(-mBracketWidth*0.5, -mBracketHeight*0.5, mBracketWidth, mBracketHeight);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case bsPlus:
|
|
|
+ {
|
|
|
+ painter->drawLine(QLineF(0, -mBracketHeight*0.5, 0, mBracketHeight*0.5));
|
|
|
+ painter->drawLine(QLineF(-mBracketWidth*0.5, 0, mBracketWidth*0.5, 0));
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ default:
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "unknown/custom bracket style can't be handeld by default implementation:" << static_cast<int>(mBracketStyle);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Draws the bracket decoration on the data points at the begin and end of each selected data
|
|
|
+ segment given in \a seletion.
|
|
|
+
|
|
|
+ It uses the method \ref drawBracket to actually draw the shapes.
|
|
|
+
|
|
|
+ \seebaseclassmethod
|
|
|
+*/
|
|
|
+void QCPSelectionDecoratorBracket::drawDecoration(QCPPainter *painter, QCPDataSelection selection)
|
|
|
+{
|
|
|
+ if (!mPlottable || selection.isEmpty()) return;
|
|
|
+
|
|
|
+ if (QCPPlottableInterface1D *interface1d = mPlottable->interface1D())
|
|
|
+ {
|
|
|
+ foreach (const QCPDataRange &dataRange, selection.dataRanges())
|
|
|
+ {
|
|
|
+ // determine position and (if tangent mode is enabled) angle of brackets:
|
|
|
+ int openBracketDir = (mPlottable->keyAxis() && !mPlottable->keyAxis()->rangeReversed()) ? 1 : -1;
|
|
|
+ int closeBracketDir = -openBracketDir;
|
|
|
+ QPointF openBracketPos = getPixelCoordinates(interface1d, dataRange.begin());
|
|
|
+ QPointF closeBracketPos = getPixelCoordinates(interface1d, dataRange.end()-1);
|
|
|
+ double openBracketAngle = 0;
|
|
|
+ double closeBracketAngle = 0;
|
|
|
+ if (mTangentToData)
|
|
|
+ {
|
|
|
+ openBracketAngle = getTangentAngle(interface1d, dataRange.begin(), openBracketDir);
|
|
|
+ closeBracketAngle = getTangentAngle(interface1d, dataRange.end()-1, closeBracketDir);
|
|
|
+ }
|
|
|
+ // draw opening bracket:
|
|
|
+ QTransform oldTransform = painter->transform();
|
|
|
+ painter->setPen(mBracketPen);
|
|
|
+ painter->setBrush(mBracketBrush);
|
|
|
+ painter->translate(openBracketPos);
|
|
|
+ painter->rotate(openBracketAngle/M_PI*180.0);
|
|
|
+ drawBracket(painter, openBracketDir);
|
|
|
+ painter->setTransform(oldTransform);
|
|
|
+ // draw closing bracket:
|
|
|
+ painter->setPen(mBracketPen);
|
|
|
+ painter->setBrush(mBracketBrush);
|
|
|
+ painter->translate(closeBracketPos);
|
|
|
+ painter->rotate(closeBracketAngle/M_PI*180.0);
|
|
|
+ drawBracket(painter, closeBracketDir);
|
|
|
+ painter->setTransform(oldTransform);
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ If \ref setTangentToData is enabled, brackets need to be rotated according to the data slope.
|
|
|
+ This method returns the angle in radians by which a bracket at the given \a dataIndex must be
|
|
|
+ rotated.
|
|
|
+
|
|
|
+ The parameter \a direction must be set to either -1 or 1, representing whether it is an opening
|
|
|
+ or closing bracket. Since for slope calculation multiple data points are required, this defines
|
|
|
+ the direction in which the algorithm walks, starting at \a dataIndex, to average those data
|
|
|
+ points. (see \ref setTangentToData and \ref setTangentAverage)
|
|
|
+
|
|
|
+ \a interface1d is the interface to the plottable's data which is used to query data coordinates.
|
|
|
+*/
|
|
|
+double QCPSelectionDecoratorBracket::getTangentAngle(const QCPPlottableInterface1D *interface1d, int dataIndex, int direction) const
|
|
|
+{
|
|
|
+ if (!interface1d || dataIndex < 0 || dataIndex >= interface1d->dataCount())
|
|
|
+ return 0;
|
|
|
+ direction = direction < 0 ? -1 : 1; // enforce direction is either -1 or 1
|
|
|
+
|
|
|
+ // how many steps we can actually go from index in the given direction without exceeding data bounds:
|
|
|
+ int averageCount;
|
|
|
+ if (direction < 0)
|
|
|
+ averageCount = qMin(mTangentAverage, dataIndex);
|
|
|
+ else
|
|
|
+ averageCount = qMin(mTangentAverage, interface1d->dataCount()-1-dataIndex);
|
|
|
+ qDebug() << averageCount;
|
|
|
+ // calculate point average of averageCount points:
|
|
|
+ QVector<QPointF> points(averageCount);
|
|
|
+ QPointF pointsAverage;
|
|
|
+ int currentIndex = dataIndex;
|
|
|
+ for (int i=0; i<averageCount; ++i)
|
|
|
+ {
|
|
|
+ points[i] = getPixelCoordinates(interface1d, currentIndex);
|
|
|
+ pointsAverage += points[i];
|
|
|
+ currentIndex += direction;
|
|
|
+ }
|
|
|
+ pointsAverage /= (double)averageCount;
|
|
|
+
|
|
|
+ // calculate slope of linear regression through points:
|
|
|
+ double numSum = 0;
|
|
|
+ double denomSum = 0;
|
|
|
+ for (int i=0; i<averageCount; ++i)
|
|
|
+ {
|
|
|
+ const double dx = points.at(i).x()-pointsAverage.x();
|
|
|
+ const double dy = points.at(i).y()-pointsAverage.y();
|
|
|
+ numSum += dx*dy;
|
|
|
+ denomSum += dx*dx;
|
|
|
+ }
|
|
|
+ if (!qFuzzyIsNull(denomSum) && !qFuzzyIsNull(numSum))
|
|
|
+ {
|
|
|
+ return qAtan2(numSum, denomSum);
|
|
|
+ } else // undetermined angle, probably mTangentAverage == 1, so using only one data point
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the pixel coordinates of the data point at \a dataIndex, using \a interface1d to access
|
|
|
+ the data points.
|
|
|
+*/
|
|
|
+QPointF QCPSelectionDecoratorBracket::getPixelCoordinates(const QCPPlottableInterface1D *interface1d, int dataIndex) const
|
|
|
+{
|
|
|
+ QCPAxis *keyAxis = mPlottable->keyAxis();
|
|
|
+ QCPAxis *valueAxis = mPlottable->valueAxis();
|
|
|
+ if (!keyAxis || !valueAxis) { qDebug() << Q_FUNC_INFO << "invalid key or value axis"; return QPointF(0, 0); }
|
|
|
+
|
|
|
+ if (keyAxis->orientation() == Qt::Horizontal)
|
|
|
+ return QPointF(keyAxis->coordToPixel(interface1d->dataMainKey(dataIndex)), valueAxis->coordToPixel(interface1d->dataMainValue(dataIndex)));
|
|
|
+ else
|
|
|
+ return QPointF(valueAxis->coordToPixel(interface1d->dataMainValue(dataIndex)), keyAxis->coordToPixel(interface1d->dataMainKey(dataIndex)));
|
|
|
+}
|
|
|
+/* end of 'src/selectiondecorator-bracket.cpp' */
|
|
|
+
|
|
|
+
|
|
|
+/* including file 'src/layoutelements/layoutelement-axisrect.cpp', size 47584 */
|
|
|
+/* commit 9868e55d3b412f2f89766bb482fcf299e93a0988 2017-09-04 01:56:22 +0200 */
|
|
|
+
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPAxisRect
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+/*! \class QCPAxisRect
|
|
|
+ \brief Holds multiple axes and arranges them in a rectangular shape.
|
|
|
+
|
|
|
+ This class represents an axis rect, a rectangular area that is bounded on all sides with an
|
|
|
+ arbitrary number of axes.
|
|
|
+
|
|
|
+ Initially QCustomPlot has one axis rect, accessible via QCustomPlot::axisRect(). However, the
|
|
|
+ layout system allows to have multiple axis rects, e.g. arranged in a grid layout
|
|
|
+ (QCustomPlot::plotLayout).
|
|
|
+
|
|
|
+ By default, QCPAxisRect comes with four axes, at bottom, top, left and right. They can be
|
|
|
+ accessed via \ref axis by providing the respective axis type (\ref QCPAxis::AxisType) and index.
|
|
|
+ If you need all axes in the axis rect, use \ref axes. The top and right axes are set to be
|
|
|
+ invisible initially (QCPAxis::setVisible). To add more axes to a side, use \ref addAxis or \ref
|
|
|
+ addAxes. To remove an axis, use \ref removeAxis.
|
|
|
+
|
|
|
+ The axis rect layerable itself only draws a background pixmap or color, if specified (\ref
|
|
|
+ setBackground). It is placed on the "background" layer initially (see \ref QCPLayer for an
|
|
|
+ explanation of the QCustomPlot layer system). The axes that are held by the axis rect can be
|
|
|
+ placed on other layers, independently of the axis rect.
|
|
|
+
|
|
|
+ Every axis rect has a child layout of type \ref QCPLayoutInset. It is accessible via \ref
|
|
|
+ insetLayout and can be used to have other layout elements (or even other layouts with multiple
|
|
|
+ elements) hovering inside the axis rect.
|
|
|
+
|
|
|
+ If an axis rect is clicked and dragged, it processes this by moving certain axis ranges. The
|
|
|
+ behaviour can be controlled with \ref setRangeDrag and \ref setRangeDragAxes. If the mouse wheel
|
|
|
+ is scrolled while the cursor is on the axis rect, certain axes are scaled. This is controllable
|
|
|
+ via \ref setRangeZoom, \ref setRangeZoomAxes and \ref setRangeZoomFactor. These interactions are
|
|
|
+ only enabled if \ref QCustomPlot::setInteractions contains \ref QCP::iRangeDrag and \ref
|
|
|
+ QCP::iRangeZoom.
|
|
|
+
|
|
|
+ \image html AxisRectSpacingOverview.png
|
|
|
+ <center>Overview of the spacings and paddings that define the geometry of an axis. The dashed
|
|
|
+ line on the far left indicates the viewport/widget border.</center>
|
|
|
+*/
|
|
|
+
|
|
|
+/* start documentation of inline functions */
|
|
|
+
|
|
|
+/*! \fn QCPLayoutInset *QCPAxisRect::insetLayout() const
|
|
|
+
|
|
|
+ Returns the inset layout of this axis rect. It can be used to place other layout elements (or
|
|
|
+ even layouts with multiple other elements) inside/on top of an axis rect.
|
|
|
+
|
|
|
+ \see QCPLayoutInset
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn int QCPAxisRect::left() const
|
|
|
+
|
|
|
+ Returns the pixel position of the left border of this axis rect. Margins are not taken into
|
|
|
+ account here, so the returned value is with respect to the inner \ref rect.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn int QCPAxisRect::right() const
|
|
|
+
|
|
|
+ Returns the pixel position of the right border of this axis rect. Margins are not taken into
|
|
|
+ account here, so the returned value is with respect to the inner \ref rect.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn int QCPAxisRect::top() const
|
|
|
+
|
|
|
+ Returns the pixel position of the top border of this axis rect. Margins are not taken into
|
|
|
+ account here, so the returned value is with respect to the inner \ref rect.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn int QCPAxisRect::bottom() const
|
|
|
+
|
|
|
+ Returns the pixel position of the bottom border of this axis rect. Margins are not taken into
|
|
|
+ account here, so the returned value is with respect to the inner \ref rect.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn int QCPAxisRect::width() const
|
|
|
+
|
|
|
+ Returns the pixel width of this axis rect. Margins are not taken into account here, so the
|
|
|
+ returned value is with respect to the inner \ref rect.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn int QCPAxisRect::height() const
|
|
|
+
|
|
|
+ Returns the pixel height of this axis rect. Margins are not taken into account here, so the
|
|
|
+ returned value is with respect to the inner \ref rect.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn QSize QCPAxisRect::size() const
|
|
|
+
|
|
|
+ Returns the pixel size of this axis rect. Margins are not taken into account here, so the
|
|
|
+ returned value is with respect to the inner \ref rect.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn QPoint QCPAxisRect::topLeft() const
|
|
|
+
|
|
|
+ Returns the top left corner of this axis rect in pixels. Margins are not taken into account here,
|
|
|
+ so the returned value is with respect to the inner \ref rect.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn QPoint QCPAxisRect::topRight() const
|
|
|
+
|
|
|
+ Returns the top right corner of this axis rect in pixels. Margins are not taken into account
|
|
|
+ here, so the returned value is with respect to the inner \ref rect.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn QPoint QCPAxisRect::bottomLeft() const
|
|
|
+
|
|
|
+ Returns the bottom left corner of this axis rect in pixels. Margins are not taken into account
|
|
|
+ here, so the returned value is with respect to the inner \ref rect.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn QPoint QCPAxisRect::bottomRight() const
|
|
|
+
|
|
|
+ Returns the bottom right corner of this axis rect in pixels. Margins are not taken into account
|
|
|
+ here, so the returned value is with respect to the inner \ref rect.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn QPoint QCPAxisRect::center() const
|
|
|
+
|
|
|
+ Returns the center of this axis rect in pixels. Margins are not taken into account here, so the
|
|
|
+ returned value is with respect to the inner \ref rect.
|
|
|
+*/
|
|
|
+
|
|
|
+/* end documentation of inline functions */
|
|
|
+
|
|
|
+/*!
|
|
|
+ Creates a QCPAxisRect instance and sets default values. An axis is added for each of the four
|
|
|
+ sides, the top and right axes are set invisible initially.
|
|
|
+*/
|
|
|
+QCPAxisRect::QCPAxisRect(QCustomPlot *parentPlot, bool setupDefaultAxes) :
|
|
|
+ QCPLayoutElement(parentPlot),
|
|
|
+ mBackgroundBrush(Qt::NoBrush),
|
|
|
+ mBackgroundScaled(true),
|
|
|
+ mBackgroundScaledMode(Qt::KeepAspectRatioByExpanding),
|
|
|
+ mInsetLayout(new QCPLayoutInset),
|
|
|
+ mRangeDrag(Qt::Horizontal|Qt::Vertical),
|
|
|
+ mRangeZoom(Qt::Horizontal|Qt::Vertical),
|
|
|
+ mRangeZoomFactorHorz(0.85),
|
|
|
+ mRangeZoomFactorVert(0.85),
|
|
|
+ mDragging(false)
|
|
|
+{
|
|
|
+ mInsetLayout->initializeParentPlot(mParentPlot);
|
|
|
+ mInsetLayout->setParentLayerable(this);
|
|
|
+ mInsetLayout->setParent(this);
|
|
|
+
|
|
|
+ setMinimumSize(50, 50);
|
|
|
+ setMinimumMargins(QMargins(15, 15, 15, 15));
|
|
|
+ mAxes.insert(QCPAxis::atLeft, QList<QCPAxis*>());
|
|
|
+ mAxes.insert(QCPAxis::atRight, QList<QCPAxis*>());
|
|
|
+ mAxes.insert(QCPAxis::atTop, QList<QCPAxis*>());
|
|
|
+ mAxes.insert(QCPAxis::atBottom, QList<QCPAxis*>());
|
|
|
+
|
|
|
+ if (setupDefaultAxes)
|
|
|
+ {
|
|
|
+ QCPAxis *xAxis = addAxis(QCPAxis::atBottom);
|
|
|
+ QCPAxis *yAxis = addAxis(QCPAxis::atLeft);
|
|
|
+ QCPAxis *xAxis2 = addAxis(QCPAxis::atTop);
|
|
|
+ QCPAxis *yAxis2 = addAxis(QCPAxis::atRight);
|
|
|
+ setRangeDragAxes(xAxis, yAxis);
|
|
|
+ setRangeZoomAxes(xAxis, yAxis);
|
|
|
+ xAxis2->setVisible(false);
|
|
|
+ yAxis2->setVisible(false);
|
|
|
+ xAxis->grid()->setVisible(true);
|
|
|
+ yAxis->grid()->setVisible(true);
|
|
|
+ xAxis2->grid()->setVisible(false);
|
|
|
+ yAxis2->grid()->setVisible(false);
|
|
|
+ xAxis2->grid()->setZeroLinePen(Qt::NoPen);
|
|
|
+ yAxis2->grid()->setZeroLinePen(Qt::NoPen);
|
|
|
+ xAxis2->grid()->setVisible(false);
|
|
|
+ yAxis2->grid()->setVisible(false);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+QCPAxisRect::~QCPAxisRect()
|
|
|
+{
|
|
|
+ delete mInsetLayout;
|
|
|
+ mInsetLayout = 0;
|
|
|
+
|
|
|
+ QList<QCPAxis*> axesList = axes();
|
|
|
+ for (int i=0; i<axesList.size(); ++i)
|
|
|
+ removeAxis(axesList.at(i));
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns the number of axes on the axis rect side specified with \a type.
|
|
|
+
|
|
|
+ \see axis
|
|
|
+*/
|
|
|
+int QCPAxisRect::axisCount(QCPAxis::AxisType type) const
|
|
|
+{
|
|
|
+ return mAxes.value(type).size();
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns the axis with the given \a index on the axis rect side specified with \a type.
|
|
|
+
|
|
|
+ \see axisCount, axes
|
|
|
+*/
|
|
|
+QCPAxis *QCPAxisRect::axis(QCPAxis::AxisType type, int index) const
|
|
|
+{
|
|
|
+ QList<QCPAxis*> ax(mAxes.value(type));
|
|
|
+ if (index >= 0 && index < ax.size())
|
|
|
+ {
|
|
|
+ return ax.at(index);
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "Axis index out of bounds:" << index;
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns all axes on the axis rect sides specified with \a types.
|
|
|
+
|
|
|
+ \a types may be a single \ref QCPAxis::AxisType or an <tt>or</tt>-combination, to get the axes of
|
|
|
+ multiple sides.
|
|
|
+
|
|
|
+ \see axis
|
|
|
+*/
|
|
|
+QList<QCPAxis*> QCPAxisRect::axes(QCPAxis::AxisTypes types) const
|
|
|
+{
|
|
|
+ QList<QCPAxis*> result;
|
|
|
+ if (types.testFlag(QCPAxis::atLeft))
|
|
|
+ result << mAxes.value(QCPAxis::atLeft);
|
|
|
+ if (types.testFlag(QCPAxis::atRight))
|
|
|
+ result << mAxes.value(QCPAxis::atRight);
|
|
|
+ if (types.testFlag(QCPAxis::atTop))
|
|
|
+ result << mAxes.value(QCPAxis::atTop);
|
|
|
+ if (types.testFlag(QCPAxis::atBottom))
|
|
|
+ result << mAxes.value(QCPAxis::atBottom);
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Returns all axes of this axis rect.
|
|
|
+*/
|
|
|
+QList<QCPAxis*> QCPAxisRect::axes() const
|
|
|
+{
|
|
|
+ QList<QCPAxis*> result;
|
|
|
+ QHashIterator<QCPAxis::AxisType, QList<QCPAxis*> > it(mAxes);
|
|
|
+ while (it.hasNext())
|
|
|
+ {
|
|
|
+ it.next();
|
|
|
+ result << it.value();
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Adds a new axis to the axis rect side specified with \a type, and returns it. If \a axis is 0, a
|
|
|
+ new QCPAxis instance is created internally. QCustomPlot owns the returned axis, so if you want to
|
|
|
+ remove an axis, use \ref removeAxis instead of deleting it manually.
|
|
|
+
|
|
|
+ You may inject QCPAxis instances (or subclasses of QCPAxis) by setting \a axis to an axis that was
|
|
|
+ previously created outside QCustomPlot. It is important to note that QCustomPlot takes ownership
|
|
|
+ of the axis, so you may not delete it afterwards. Further, the \a axis must have been created
|
|
|
+ with this axis rect as parent and with the same axis type as specified in \a type. If this is not
|
|
|
+ the case, a debug output is generated, the axis is not added, and the method returns 0.
|
|
|
+
|
|
|
+ This method can not be used to move \a axis between axis rects. The same \a axis instance must
|
|
|
+ not be added multiple times to the same or different axis rects.
|
|
|
+
|
|
|
+ If an axis rect side already contains one or more axes, the lower and upper endings of the new
|
|
|
+ axis (\ref QCPAxis::setLowerEnding, \ref QCPAxis::setUpperEnding) are set to \ref
|
|
|
+ QCPLineEnding::esHalfBar.
|
|
|
+
|
|
|
+ \see addAxes, setupFullAxesBox
|
|
|
+*/
|
|
|
+QCPAxis *QCPAxisRect::addAxis(QCPAxis::AxisType type, QCPAxis *axis)
|
|
|
+{
|
|
|
+ QCPAxis *newAxis = axis;
|
|
|
+ if (!newAxis)
|
|
|
+ {
|
|
|
+ newAxis = new QCPAxis(this, type);
|
|
|
+ } else // user provided existing axis instance, do some sanity checks
|
|
|
+ {
|
|
|
+ if (newAxis->axisType() != type)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "passed axis has different axis type than specified in type parameter";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ if (newAxis->axisRect() != this)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "passed axis doesn't have this axis rect as parent axis rect";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ if (axes().contains(newAxis))
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "passed axis is already owned by this axis rect";
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (mAxes[type].size() > 0) // multiple axes on one side, add half-bar axis ending to additional axes with offset
|
|
|
+ {
|
|
|
+ bool invert = (type == QCPAxis::atRight) || (type == QCPAxis::atBottom);
|
|
|
+ newAxis->setLowerEnding(QCPLineEnding(QCPLineEnding::esHalfBar, 6, 10, !invert));
|
|
|
+ newAxis->setUpperEnding(QCPLineEnding(QCPLineEnding::esHalfBar, 6, 10, invert));
|
|
|
+ }
|
|
|
+ mAxes[type].append(newAxis);
|
|
|
+
|
|
|
+ // reset convenience axis pointers on parent QCustomPlot if they are unset:
|
|
|
+ if (mParentPlot && mParentPlot->axisRectCount() > 0 && mParentPlot->axisRect(0) == this)
|
|
|
+ {
|
|
|
+ switch (type)
|
|
|
+ {
|
|
|
+ case QCPAxis::atBottom: { if (!mParentPlot->xAxis) mParentPlot->xAxis = newAxis; break; }
|
|
|
+ case QCPAxis::atLeft: { if (!mParentPlot->yAxis) mParentPlot->yAxis = newAxis; break; }
|
|
|
+ case QCPAxis::atTop: { if (!mParentPlot->xAxis2) mParentPlot->xAxis2 = newAxis; break; }
|
|
|
+ case QCPAxis::atRight: { if (!mParentPlot->yAxis2) mParentPlot->yAxis2 = newAxis; break; }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return newAxis;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Adds a new axis with \ref addAxis to each axis rect side specified in \a types. This may be an
|
|
|
+ <tt>or</tt>-combination of QCPAxis::AxisType, so axes can be added to multiple sides at once.
|
|
|
+
|
|
|
+ Returns a list of the added axes.
|
|
|
+
|
|
|
+ \see addAxis, setupFullAxesBox
|
|
|
+*/
|
|
|
+QList<QCPAxis*> QCPAxisRect::addAxes(QCPAxis::AxisTypes types)
|
|
|
+{
|
|
|
+ QList<QCPAxis*> result;
|
|
|
+ if (types.testFlag(QCPAxis::atLeft))
|
|
|
+ result << addAxis(QCPAxis::atLeft);
|
|
|
+ if (types.testFlag(QCPAxis::atRight))
|
|
|
+ result << addAxis(QCPAxis::atRight);
|
|
|
+ if (types.testFlag(QCPAxis::atTop))
|
|
|
+ result << addAxis(QCPAxis::atTop);
|
|
|
+ if (types.testFlag(QCPAxis::atBottom))
|
|
|
+ result << addAxis(QCPAxis::atBottom);
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Removes the specified \a axis from the axis rect and deletes it.
|
|
|
+
|
|
|
+ Returns true on success, i.e. if \a axis was a valid axis in this axis rect.
|
|
|
+
|
|
|
+ \see addAxis
|
|
|
+*/
|
|
|
+bool QCPAxisRect::removeAxis(QCPAxis *axis)
|
|
|
+{
|
|
|
+ // don't access axis->axisType() to provide safety when axis is an invalid pointer, rather go through all axis containers:
|
|
|
+ QHashIterator<QCPAxis::AxisType, QList<QCPAxis*> > it(mAxes);
|
|
|
+ while (it.hasNext())
|
|
|
+ {
|
|
|
+ it.next();
|
|
|
+ if (it.value().contains(axis))
|
|
|
+ {
|
|
|
+ if (it.value().first() == axis && it.value().size() > 1) // if removing first axis, transfer axis offset to the new first axis (which at this point is the second axis, if it exists)
|
|
|
+ it.value()[1]->setOffset(axis->offset());
|
|
|
+ mAxes[it.key()].removeOne(axis);
|
|
|
+ if (qobject_cast<QCustomPlot*>(parentPlot())) // make sure this isn't called from QObject dtor when QCustomPlot is already destructed (happens when the axis rect is not in any layout and thus QObject-child of QCustomPlot)
|
|
|
+ parentPlot()->axisRemoved(axis);
|
|
|
+ delete axis;
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ qDebug() << Q_FUNC_INFO << "Axis isn't in axis rect:" << reinterpret_cast<quintptr>(axis);
|
|
|
+ return false;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Zooms in (or out) to the passed rectangular region \a pixelRect, given in pixel coordinates.
|
|
|
+
|
|
|
+ All axes of this axis rect will have their range zoomed accordingly. If you only wish to zoom
|
|
|
+ specific axes, use the overloaded version of this method.
|
|
|
+
|
|
|
+ \see QCustomPlot::setSelectionRectMode
|
|
|
+*/
|
|
|
+void QCPAxisRect::zoom(const QRectF &pixelRect)
|
|
|
+{
|
|
|
+ zoom(pixelRect, axes());
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Zooms in (or out) to the passed rectangular region \a pixelRect, given in pixel coordinates.
|
|
|
+
|
|
|
+ Only the axes passed in \a affectedAxes will have their ranges zoomed accordingly.
|
|
|
+
|
|
|
+ \see QCustomPlot::setSelectionRectMode
|
|
|
+*/
|
|
|
+void QCPAxisRect::zoom(const QRectF &pixelRect, const QList<QCPAxis*> &affectedAxes)
|
|
|
+{
|
|
|
+ foreach (QCPAxis *axis, affectedAxes)
|
|
|
+ {
|
|
|
+ if (!axis)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "a passed axis was zero";
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ QCPRange pixelRange;
|
|
|
+ if (axis->orientation() == Qt::Horizontal)
|
|
|
+ pixelRange = QCPRange(pixelRect.left(), pixelRect.right());
|
|
|
+ else
|
|
|
+ pixelRange = QCPRange(pixelRect.top(), pixelRect.bottom());
|
|
|
+ axis->setRange(axis->pixelToCoord(pixelRange.lower), axis->pixelToCoord(pixelRange.upper));
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Convenience function to create an axis on each side that doesn't have any axes yet and set their
|
|
|
+ visibility to true. Further, the top/right axes are assigned the following properties of the
|
|
|
+ bottom/left axes:
|
|
|
+
|
|
|
+ \li range (\ref QCPAxis::setRange)
|
|
|
+ \li range reversed (\ref QCPAxis::setRangeReversed)
|
|
|
+ \li scale type (\ref QCPAxis::setScaleType)
|
|
|
+ \li tick visibility (\ref QCPAxis::setTicks)
|
|
|
+ \li number format (\ref QCPAxis::setNumberFormat)
|
|
|
+ \li number precision (\ref QCPAxis::setNumberPrecision)
|
|
|
+ \li tick count of ticker (\ref QCPAxisTicker::setTickCount)
|
|
|
+ \li tick origin of ticker (\ref QCPAxisTicker::setTickOrigin)
|
|
|
+
|
|
|
+ Tick label visibility (\ref QCPAxis::setTickLabels) of the right and top axes are set to false.
|
|
|
+
|
|
|
+ If \a connectRanges is true, the \ref QCPAxis::rangeChanged "rangeChanged" signals of the bottom
|
|
|
+ and left axes are connected to the \ref QCPAxis::setRange slots of the top and right axes.
|
|
|
+*/
|
|
|
+void QCPAxisRect::setupFullAxesBox(bool connectRanges)
|
|
|
+{
|
|
|
+ QCPAxis *xAxis, *yAxis, *xAxis2, *yAxis2;
|
|
|
+ if (axisCount(QCPAxis::atBottom) == 0)
|
|
|
+ xAxis = addAxis(QCPAxis::atBottom);
|
|
|
+ else
|
|
|
+ xAxis = axis(QCPAxis::atBottom);
|
|
|
+
|
|
|
+ if (axisCount(QCPAxis::atLeft) == 0)
|
|
|
+ yAxis = addAxis(QCPAxis::atLeft);
|
|
|
+ else
|
|
|
+ yAxis = axis(QCPAxis::atLeft);
|
|
|
+
|
|
|
+ if (axisCount(QCPAxis::atTop) == 0)
|
|
|
+ xAxis2 = addAxis(QCPAxis::atTop);
|
|
|
+ else
|
|
|
+ xAxis2 = axis(QCPAxis::atTop);
|
|
|
+
|
|
|
+ if (axisCount(QCPAxis::atRight) == 0)
|
|
|
+ yAxis2 = addAxis(QCPAxis::atRight);
|
|
|
+ else
|
|
|
+ yAxis2 = axis(QCPAxis::atRight);
|
|
|
+
|
|
|
+ xAxis->setVisible(true);
|
|
|
+ yAxis->setVisible(true);
|
|
|
+ xAxis2->setVisible(true);
|
|
|
+ yAxis2->setVisible(true);
|
|
|
+ xAxis2->setTickLabels(false);
|
|
|
+ yAxis2->setTickLabels(false);
|
|
|
+
|
|
|
+ xAxis2->setRange(xAxis->range());
|
|
|
+ xAxis2->setRangeReversed(xAxis->rangeReversed());
|
|
|
+ xAxis2->setScaleType(xAxis->scaleType());
|
|
|
+ xAxis2->setTicks(xAxis->ticks());
|
|
|
+ xAxis2->setNumberFormat(xAxis->numberFormat());
|
|
|
+ xAxis2->setNumberPrecision(xAxis->numberPrecision());
|
|
|
+ xAxis2->ticker()->setTickCount(xAxis->ticker()->tickCount());
|
|
|
+ xAxis2->ticker()->setTickOrigin(xAxis->ticker()->tickOrigin());
|
|
|
+
|
|
|
+ yAxis2->setRange(yAxis->range());
|
|
|
+ yAxis2->setRangeReversed(yAxis->rangeReversed());
|
|
|
+ yAxis2->setScaleType(yAxis->scaleType());
|
|
|
+ yAxis2->setTicks(yAxis->ticks());
|
|
|
+ yAxis2->setNumberFormat(yAxis->numberFormat());
|
|
|
+ yAxis2->setNumberPrecision(yAxis->numberPrecision());
|
|
|
+ yAxis2->ticker()->setTickCount(yAxis->ticker()->tickCount());
|
|
|
+ yAxis2->ticker()->setTickOrigin(yAxis->ticker()->tickOrigin());
|
|
|
+
|
|
|
+ if (connectRanges)
|
|
|
+ {
|
|
|
+ connect(xAxis, SIGNAL(rangeChanged(QCPRange)), xAxis2, SLOT(setRange(QCPRange)));
|
|
|
+ connect(yAxis, SIGNAL(rangeChanged(QCPRange)), yAxis2, SLOT(setRange(QCPRange)));
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns a list of all the plottables that are associated with this axis rect.
|
|
|
+
|
|
|
+ A plottable is considered associated with an axis rect if its key or value axis (or both) is in
|
|
|
+ this axis rect.
|
|
|
+
|
|
|
+ \see graphs, items
|
|
|
+*/
|
|
|
+QList<QCPAbstractPlottable*> QCPAxisRect::plottables() const
|
|
|
+{
|
|
|
+ // Note: don't append all QCPAxis::plottables() into a list, because we might get duplicate entries
|
|
|
+ QList<QCPAbstractPlottable*> result;
|
|
|
+ for (int i=0; i<mParentPlot->mPlottables.size(); ++i)
|
|
|
+ {
|
|
|
+ if (mParentPlot->mPlottables.at(i)->keyAxis()->axisRect() == this || mParentPlot->mPlottables.at(i)->valueAxis()->axisRect() == this)
|
|
|
+ result.append(mParentPlot->mPlottables.at(i));
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns a list of all the graphs that are associated with this axis rect.
|
|
|
+
|
|
|
+ A graph is considered associated with an axis rect if its key or value axis (or both) is in
|
|
|
+ this axis rect.
|
|
|
+
|
|
|
+ \see plottables, items
|
|
|
+*/
|
|
|
+QList<QCPGraph*> QCPAxisRect::graphs() const
|
|
|
+{
|
|
|
+ // Note: don't append all QCPAxis::graphs() into a list, because we might get duplicate entries
|
|
|
+ QList<QCPGraph*> result;
|
|
|
+ for (int i=0; i<mParentPlot->mGraphs.size(); ++i)
|
|
|
+ {
|
|
|
+ if (mParentPlot->mGraphs.at(i)->keyAxis()->axisRect() == this || mParentPlot->mGraphs.at(i)->valueAxis()->axisRect() == this)
|
|
|
+ result.append(mParentPlot->mGraphs.at(i));
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns a list of all the items that are associated with this axis rect.
|
|
|
+
|
|
|
+ An item is considered associated with an axis rect if any of its positions has key or value axis
|
|
|
+ set to an axis that is in this axis rect, or if any of its positions has \ref
|
|
|
+ QCPItemPosition::setAxisRect set to the axis rect, or if the clip axis rect (\ref
|
|
|
+ QCPAbstractItem::setClipAxisRect) is set to this axis rect.
|
|
|
+
|
|
|
+ \see plottables, graphs
|
|
|
+*/
|
|
|
+QList<QCPAbstractItem *> QCPAxisRect::items() const
|
|
|
+{
|
|
|
+ // Note: don't just append all QCPAxis::items() into a list, because we might get duplicate entries
|
|
|
+ // and miss those items that have this axis rect as clipAxisRect.
|
|
|
+ QList<QCPAbstractItem*> result;
|
|
|
+ for (int itemId=0; itemId<mParentPlot->mItems.size(); ++itemId)
|
|
|
+ {
|
|
|
+ if (mParentPlot->mItems.at(itemId)->clipAxisRect() == this)
|
|
|
+ {
|
|
|
+ result.append(mParentPlot->mItems.at(itemId));
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ QList<QCPItemPosition*> positions = mParentPlot->mItems.at(itemId)->positions();
|
|
|
+ for (int posId=0; posId<positions.size(); ++posId)
|
|
|
+ {
|
|
|
+ if (positions.at(posId)->axisRect() == this ||
|
|
|
+ positions.at(posId)->keyAxis()->axisRect() == this ||
|
|
|
+ positions.at(posId)->valueAxis()->axisRect() == this)
|
|
|
+ {
|
|
|
+ result.append(mParentPlot->mItems.at(itemId));
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ This method is called automatically upon replot and doesn't need to be called by users of
|
|
|
+ QCPAxisRect.
|
|
|
+
|
|
|
+ Calls the base class implementation to update the margins (see \ref QCPLayoutElement::update),
|
|
|
+ and finally passes the \ref rect to the inset layout (\ref insetLayout) and calls its
|
|
|
+ QCPInsetLayout::update function.
|
|
|
+
|
|
|
+ \seebaseclassmethod
|
|
|
+*/
|
|
|
+void QCPAxisRect::update(UpdatePhase phase)
|
|
|
+{
|
|
|
+ QCPLayoutElement::update(phase);
|
|
|
+
|
|
|
+ switch (phase)
|
|
|
+ {
|
|
|
+ case upPreparation:
|
|
|
+ {
|
|
|
+ QList<QCPAxis*> allAxes = axes();
|
|
|
+ for (int i=0; i<allAxes.size(); ++i)
|
|
|
+ allAxes.at(i)->setupTickVectors();
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case upLayout:
|
|
|
+ {
|
|
|
+ mInsetLayout->setOuterRect(rect());
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ default: break;
|
|
|
+ }
|
|
|
+
|
|
|
+ // pass update call on to inset layout (doesn't happen automatically, because QCPAxisRect doesn't derive from QCPLayout):
|
|
|
+ mInsetLayout->update(phase);
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+QList<QCPLayoutElement*> QCPAxisRect::elements(bool recursive) const
|
|
|
+{
|
|
|
+ QList<QCPLayoutElement*> result;
|
|
|
+ if (mInsetLayout)
|
|
|
+ {
|
|
|
+ result << mInsetLayout;
|
|
|
+ if (recursive)
|
|
|
+ result << mInsetLayout->elements(recursive);
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPAxisRect::applyDefaultAntialiasingHint(QCPPainter *painter) const
|
|
|
+{
|
|
|
+ painter->setAntialiasing(false);
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPAxisRect::draw(QCPPainter *painter)
|
|
|
+{
|
|
|
+ drawBackground(painter);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets \a pm as the axis background pixmap. The axis background pixmap will be drawn inside the
|
|
|
+ axis rect. Since axis rects place themselves on the "background" layer by default, the axis rect
|
|
|
+ backgrounds are usually drawn below everything else.
|
|
|
+
|
|
|
+ For cases where the provided pixmap doesn't have the same size as the axis rect, scaling can be
|
|
|
+ enabled with \ref setBackgroundScaled and the scaling mode (i.e. whether and how the aspect ratio
|
|
|
+ is preserved) can be set with \ref setBackgroundScaledMode. To set all these options in one call,
|
|
|
+ consider using the overloaded version of this function.
|
|
|
+
|
|
|
+ Below the pixmap, the axis rect may be optionally filled with a brush, if specified with \ref
|
|
|
+ setBackground(const QBrush &brush).
|
|
|
+
|
|
|
+ \see setBackgroundScaled, setBackgroundScaledMode, setBackground(const QBrush &brush)
|
|
|
+*/
|
|
|
+void QCPAxisRect::setBackground(const QPixmap &pm)
|
|
|
+{
|
|
|
+ mBackgroundPixmap = pm;
|
|
|
+ mScaledBackgroundPixmap = QPixmap();
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Sets \a brush as the background brush. The axis rect background will be filled with this brush.
|
|
|
+ Since axis rects place themselves on the "background" layer by default, the axis rect backgrounds
|
|
|
+ are usually drawn below everything else.
|
|
|
+
|
|
|
+ The brush will be drawn before (under) any background pixmap, which may be specified with \ref
|
|
|
+ setBackground(const QPixmap &pm).
|
|
|
+
|
|
|
+ To disable drawing of a background brush, set \a brush to Qt::NoBrush.
|
|
|
+
|
|
|
+ \see setBackground(const QPixmap &pm)
|
|
|
+*/
|
|
|
+void QCPAxisRect::setBackground(const QBrush &brush)
|
|
|
+{
|
|
|
+ mBackgroundBrush = brush;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Allows setting the background pixmap of the axis rect, whether it shall be scaled and how it
|
|
|
+ shall be scaled in one call.
|
|
|
+
|
|
|
+ \see setBackground(const QPixmap &pm), setBackgroundScaled, setBackgroundScaledMode
|
|
|
+*/
|
|
|
+void QCPAxisRect::setBackground(const QPixmap &pm, bool scaled, Qt::AspectRatioMode mode)
|
|
|
+{
|
|
|
+ mBackgroundPixmap = pm;
|
|
|
+ mScaledBackgroundPixmap = QPixmap();
|
|
|
+ mBackgroundScaled = scaled;
|
|
|
+ mBackgroundScaledMode = mode;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets whether the axis background pixmap shall be scaled to fit the axis rect or not. If \a scaled
|
|
|
+ is set to true, you may control whether and how the aspect ratio of the original pixmap is
|
|
|
+ preserved with \ref setBackgroundScaledMode.
|
|
|
+
|
|
|
+ Note that the scaled version of the original pixmap is buffered, so there is no performance
|
|
|
+ penalty on replots. (Except when the axis rect dimensions are changed continuously.)
|
|
|
+
|
|
|
+ \see setBackground, setBackgroundScaledMode
|
|
|
+*/
|
|
|
+void QCPAxisRect::setBackgroundScaled(bool scaled)
|
|
|
+{
|
|
|
+ mBackgroundScaled = scaled;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ If scaling of the axis background pixmap is enabled (\ref setBackgroundScaled), use this function to
|
|
|
+ define whether and how the aspect ratio of the original pixmap passed to \ref setBackground is preserved.
|
|
|
+ \see setBackground, setBackgroundScaled
|
|
|
+*/
|
|
|
+void QCPAxisRect::setBackgroundScaledMode(Qt::AspectRatioMode mode)
|
|
|
+{
|
|
|
+ mBackgroundScaledMode = mode;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns the range drag axis of the \a orientation provided. If multiple axes were set, returns
|
|
|
+ the first one (use \ref rangeDragAxes to retrieve a list with all set axes).
|
|
|
+
|
|
|
+ \see setRangeDragAxes
|
|
|
+*/
|
|
|
+QCPAxis *QCPAxisRect::rangeDragAxis(Qt::Orientation orientation)
|
|
|
+{
|
|
|
+ if (orientation == Qt::Horizontal)
|
|
|
+ return mRangeDragHorzAxis.isEmpty() ? 0 : mRangeDragHorzAxis.first().data();
|
|
|
+ else
|
|
|
+ return mRangeDragVertAxis.isEmpty() ? 0 : mRangeDragVertAxis.first().data();
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns the range zoom axis of the \a orientation provided. If multiple axes were set, returns
|
|
|
+ the first one (use \ref rangeZoomAxes to retrieve a list with all set axes).
|
|
|
+
|
|
|
+ \see setRangeZoomAxes
|
|
|
+*/
|
|
|
+QCPAxis *QCPAxisRect::rangeZoomAxis(Qt::Orientation orientation)
|
|
|
+{
|
|
|
+ if (orientation == Qt::Horizontal)
|
|
|
+ return mRangeZoomHorzAxis.isEmpty() ? 0 : mRangeZoomHorzAxis.first().data();
|
|
|
+ else
|
|
|
+ return mRangeZoomVertAxis.isEmpty() ? 0 : mRangeZoomVertAxis.first().data();
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns all range drag axes of the \a orientation provided.
|
|
|
+
|
|
|
+ \see rangeZoomAxis, setRangeZoomAxes
|
|
|
+*/
|
|
|
+QList<QCPAxis*> QCPAxisRect::rangeDragAxes(Qt::Orientation orientation)
|
|
|
+{
|
|
|
+ QList<QCPAxis*> result;
|
|
|
+ if (orientation == Qt::Horizontal)
|
|
|
+ {
|
|
|
+ for (int i=0; i<mRangeDragHorzAxis.size(); ++i)
|
|
|
+ {
|
|
|
+ if (!mRangeDragHorzAxis.at(i).isNull())
|
|
|
+ result.append(mRangeDragHorzAxis.at(i).data());
|
|
|
+ }
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ for (int i=0; i<mRangeDragVertAxis.size(); ++i)
|
|
|
+ {
|
|
|
+ if (!mRangeDragVertAxis.at(i).isNull())
|
|
|
+ result.append(mRangeDragVertAxis.at(i).data());
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns all range zoom axes of the \a orientation provided.
|
|
|
+
|
|
|
+ \see rangeDragAxis, setRangeDragAxes
|
|
|
+*/
|
|
|
+QList<QCPAxis*> QCPAxisRect::rangeZoomAxes(Qt::Orientation orientation)
|
|
|
+{
|
|
|
+ QList<QCPAxis*> result;
|
|
|
+ if (orientation == Qt::Horizontal)
|
|
|
+ {
|
|
|
+ for (int i=0; i<mRangeZoomHorzAxis.size(); ++i)
|
|
|
+ {
|
|
|
+ if (!mRangeZoomHorzAxis.at(i).isNull())
|
|
|
+ result.append(mRangeZoomHorzAxis.at(i).data());
|
|
|
+ }
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ for (int i=0; i<mRangeZoomVertAxis.size(); ++i)
|
|
|
+ {
|
|
|
+ if (!mRangeZoomVertAxis.at(i).isNull())
|
|
|
+ result.append(mRangeZoomVertAxis.at(i).data());
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns the range zoom factor of the \a orientation provided.
|
|
|
+
|
|
|
+ \see setRangeZoomFactor
|
|
|
+*/
|
|
|
+double QCPAxisRect::rangeZoomFactor(Qt::Orientation orientation)
|
|
|
+{
|
|
|
+ return (orientation == Qt::Horizontal ? mRangeZoomFactorHorz : mRangeZoomFactorVert);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets which axis orientation may be range dragged by the user with mouse interaction.
|
|
|
+ What orientation corresponds to which specific axis can be set with
|
|
|
+ \ref setRangeDragAxes(QCPAxis *horizontal, QCPAxis *vertical). By
|
|
|
+ default, the horizontal axis is the bottom axis (xAxis) and the vertical axis
|
|
|
+ is the left axis (yAxis).
|
|
|
+
|
|
|
+ To disable range dragging entirely, pass 0 as \a orientations or remove \ref QCP::iRangeDrag from \ref
|
|
|
+ QCustomPlot::setInteractions. To enable range dragging for both directions, pass <tt>Qt::Horizontal |
|
|
|
+ Qt::Vertical</tt> as \a orientations.
|
|
|
+
|
|
|
+ In addition to setting \a orientations to a non-zero value, make sure \ref QCustomPlot::setInteractions
|
|
|
+ contains \ref QCP::iRangeDrag to enable the range dragging interaction.
|
|
|
+
|
|
|
+ \see setRangeZoom, setRangeDragAxes, QCustomPlot::setNoAntialiasingOnDrag
|
|
|
+*/
|
|
|
+void QCPAxisRect::setRangeDrag(Qt::Orientations orientations)
|
|
|
+{
|
|
|
+ mRangeDrag = orientations;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets which axis orientation may be zoomed by the user with the mouse wheel. What orientation
|
|
|
+ corresponds to which specific axis can be set with \ref setRangeZoomAxes(QCPAxis *horizontal,
|
|
|
+ QCPAxis *vertical). By default, the horizontal axis is the bottom axis (xAxis) and the vertical
|
|
|
+ axis is the left axis (yAxis).
|
|
|
+
|
|
|
+ To disable range zooming entirely, pass 0 as \a orientations or remove \ref QCP::iRangeZoom from \ref
|
|
|
+ QCustomPlot::setInteractions. To enable range zooming for both directions, pass <tt>Qt::Horizontal |
|
|
|
+ Qt::Vertical</tt> as \a orientations.
|
|
|
+
|
|
|
+ In addition to setting \a orientations to a non-zero value, make sure \ref QCustomPlot::setInteractions
|
|
|
+ contains \ref QCP::iRangeZoom to enable the range zooming interaction.
|
|
|
+
|
|
|
+ \see setRangeZoomFactor, setRangeZoomAxes, setRangeDrag
|
|
|
+*/
|
|
|
+void QCPAxisRect::setRangeZoom(Qt::Orientations orientations)
|
|
|
+{
|
|
|
+ mRangeZoom = orientations;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Sets the axes whose range will be dragged when \ref setRangeDrag enables mouse range dragging on
|
|
|
+ the QCustomPlot widget. Pass 0 if no axis shall be dragged in the respective orientation.
|
|
|
+
|
|
|
+ Use the overload taking a list of axes, if multiple axes (more than one per orientation) shall
|
|
|
+ react to dragging interactions.
|
|
|
+
|
|
|
+ \see setRangeZoomAxes
|
|
|
+*/
|
|
|
+void QCPAxisRect::setRangeDragAxes(QCPAxis *horizontal, QCPAxis *vertical)
|
|
|
+{
|
|
|
+ QList<QCPAxis*> horz, vert;
|
|
|
+ if (horizontal)
|
|
|
+ horz.append(horizontal);
|
|
|
+ if (vertical)
|
|
|
+ vert.append(vertical);
|
|
|
+ setRangeDragAxes(horz, vert);
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ This method allows to set up multiple axes to react to horizontal and vertical dragging. The drag
|
|
|
+ orientation that the respective axis will react to is deduced from its orientation (\ref
|
|
|
+ QCPAxis::orientation).
|
|
|
+
|
|
|
+ In the unusual case that you wish to e.g. drag a vertically oriented axis with a horizontal drag
|
|
|
+ motion, use the overload taking two separate lists for horizontal and vertical dragging.
|
|
|
+*/
|
|
|
+void QCPAxisRect::setRangeDragAxes(QList<QCPAxis*> axes)
|
|
|
+{
|
|
|
+ QList<QCPAxis*> horz, vert;
|
|
|
+ foreach (QCPAxis *ax, axes)
|
|
|
+ {
|
|
|
+ if (ax->orientation() == Qt::Horizontal)
|
|
|
+ horz.append(ax);
|
|
|
+ else
|
|
|
+ vert.append(ax);
|
|
|
+ }
|
|
|
+ setRangeDragAxes(horz, vert);
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ This method allows to set multiple axes up to react to horizontal and vertical dragging, and
|
|
|
+ define specifically which axis reacts to which drag orientation (irrespective of the axis
|
|
|
+ orientation).
|
|
|
+*/
|
|
|
+void QCPAxisRect::setRangeDragAxes(QList<QCPAxis*> horizontal, QList<QCPAxis*> vertical)
|
|
|
+{
|
|
|
+ mRangeDragHorzAxis.clear();
|
|
|
+ foreach (QCPAxis *ax, horizontal)
|
|
|
+ {
|
|
|
+ QPointer<QCPAxis> axPointer(ax);
|
|
|
+ if (!axPointer.isNull())
|
|
|
+ mRangeDragHorzAxis.append(axPointer);
|
|
|
+ else
|
|
|
+ qDebug() << Q_FUNC_INFO << "invalid axis passed in horizontal list:" << reinterpret_cast<quintptr>(ax);
|
|
|
+ }
|
|
|
+ mRangeDragVertAxis.clear();
|
|
|
+ foreach (QCPAxis *ax, vertical)
|
|
|
+ {
|
|
|
+ QPointer<QCPAxis> axPointer(ax);
|
|
|
+ if (!axPointer.isNull())
|
|
|
+ mRangeDragVertAxis.append(axPointer);
|
|
|
+ else
|
|
|
+ qDebug() << Q_FUNC_INFO << "invalid axis passed in vertical list:" << reinterpret_cast<quintptr>(ax);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the axes whose range will be zoomed when \ref setRangeZoom enables mouse wheel zooming on
|
|
|
+ the QCustomPlot widget. Pass 0 if no axis shall be zoomed in the respective orientation.
|
|
|
+
|
|
|
+ The two axes can be zoomed with different strengths, when different factors are passed to \ref
|
|
|
+ setRangeZoomFactor(double horizontalFactor, double verticalFactor).
|
|
|
+
|
|
|
+ Use the overload taking a list of axes, if multiple axes (more than one per orientation) shall
|
|
|
+ react to zooming interactions.
|
|
|
+
|
|
|
+ \see setRangeDragAxes
|
|
|
+*/
|
|
|
+void QCPAxisRect::setRangeZoomAxes(QCPAxis *horizontal, QCPAxis *vertical)
|
|
|
+{
|
|
|
+ QList<QCPAxis*> horz, vert;
|
|
|
+ if (horizontal)
|
|
|
+ horz.append(horizontal);
|
|
|
+ if (vertical)
|
|
|
+ vert.append(vertical);
|
|
|
+ setRangeZoomAxes(horz, vert);
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ This method allows to set up multiple axes to react to horizontal and vertical range zooming. The
|
|
|
+ zoom orientation that the respective axis will react to is deduced from its orientation (\ref
|
|
|
+ QCPAxis::orientation).
|
|
|
+
|
|
|
+ In the unusual case that you wish to e.g. zoom a vertically oriented axis with a horizontal zoom
|
|
|
+ interaction, use the overload taking two separate lists for horizontal and vertical zooming.
|
|
|
+*/
|
|
|
+void QCPAxisRect::setRangeZoomAxes(QList<QCPAxis*> axes)
|
|
|
+{
|
|
|
+ QList<QCPAxis*> horz, vert;
|
|
|
+ foreach (QCPAxis *ax, axes)
|
|
|
+ {
|
|
|
+ if (ax->orientation() == Qt::Horizontal)
|
|
|
+ horz.append(ax);
|
|
|
+ else
|
|
|
+ vert.append(ax);
|
|
|
+ }
|
|
|
+ setRangeZoomAxes(horz, vert);
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ This method allows to set multiple axes up to react to horizontal and vertical zooming, and
|
|
|
+ define specifically which axis reacts to which zoom orientation (irrespective of the axis
|
|
|
+ orientation).
|
|
|
+*/
|
|
|
+void QCPAxisRect::setRangeZoomAxes(QList<QCPAxis*> horizontal, QList<QCPAxis*> vertical)
|
|
|
+{
|
|
|
+ mRangeZoomHorzAxis.clear();
|
|
|
+ foreach (QCPAxis *ax, horizontal)
|
|
|
+ {
|
|
|
+ QPointer<QCPAxis> axPointer(ax);
|
|
|
+ if (!axPointer.isNull())
|
|
|
+ mRangeZoomHorzAxis.append(axPointer);
|
|
|
+ else
|
|
|
+ qDebug() << Q_FUNC_INFO << "invalid axis passed in horizontal list:" << reinterpret_cast<quintptr>(ax);
|
|
|
+ }
|
|
|
+ mRangeZoomVertAxis.clear();
|
|
|
+ foreach (QCPAxis *ax, vertical)
|
|
|
+ {
|
|
|
+ QPointer<QCPAxis> axPointer(ax);
|
|
|
+ if (!axPointer.isNull())
|
|
|
+ mRangeZoomVertAxis.append(axPointer);
|
|
|
+ else
|
|
|
+ qDebug() << Q_FUNC_INFO << "invalid axis passed in vertical list:" << reinterpret_cast<quintptr>(ax);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets how strong one rotation step of the mouse wheel zooms, when range zoom was activated with
|
|
|
+ \ref setRangeZoom. The two parameters \a horizontalFactor and \a verticalFactor provide a way to
|
|
|
+ let the horizontal axis zoom at different rates than the vertical axis. Which axis is horizontal
|
|
|
+ and which is vertical, can be set with \ref setRangeZoomAxes.
|
|
|
+
|
|
|
+ When the zoom factor is greater than one, scrolling the mouse wheel backwards (towards the user)
|
|
|
+ will zoom in (make the currently visible range smaller). For zoom factors smaller than one, the
|
|
|
+ same scrolling direction will zoom out.
|
|
|
+*/
|
|
|
+void QCPAxisRect::setRangeZoomFactor(double horizontalFactor, double verticalFactor)
|
|
|
+{
|
|
|
+ mRangeZoomFactorHorz = horizontalFactor;
|
|
|
+ mRangeZoomFactorVert = verticalFactor;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Sets both the horizontal and vertical zoom \a factor.
|
|
|
+*/
|
|
|
+void QCPAxisRect::setRangeZoomFactor(double factor)
|
|
|
+{
|
|
|
+ mRangeZoomFactorHorz = factor;
|
|
|
+ mRangeZoomFactorVert = factor;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Draws the background of this axis rect. It may consist of a background fill (a QBrush) and a
|
|
|
+ pixmap.
|
|
|
+
|
|
|
+ If a brush was given via \ref setBackground(const QBrush &brush), this function first draws an
|
|
|
+ according filling inside the axis rect with the provided \a painter.
|
|
|
+
|
|
|
+ Then, if a pixmap was provided via \ref setBackground, this function buffers the scaled version
|
|
|
+ depending on \ref setBackgroundScaled and \ref setBackgroundScaledMode and then draws it inside
|
|
|
+ the axis rect with the provided \a painter. The scaled version is buffered in
|
|
|
+ mScaledBackgroundPixmap to prevent expensive rescaling at every redraw. It is only updated, when
|
|
|
+ the axis rect has changed in a way that requires a rescale of the background pixmap (this is
|
|
|
+ dependent on the \ref setBackgroundScaledMode), or when a differend axis background pixmap was
|
|
|
+ set.
|
|
|
+
|
|
|
+ \see setBackground, setBackgroundScaled, setBackgroundScaledMode
|
|
|
+*/
|
|
|
+void QCPAxisRect::drawBackground(QCPPainter *painter)
|
|
|
+{
|
|
|
+ // draw background fill:
|
|
|
+ if (mBackgroundBrush != Qt::NoBrush)
|
|
|
+ painter->fillRect(mRect, mBackgroundBrush);
|
|
|
+
|
|
|
+ // draw background pixmap (on top of fill, if brush specified):
|
|
|
+ if (!mBackgroundPixmap.isNull())
|
|
|
+ {
|
|
|
+ if (mBackgroundScaled)
|
|
|
+ {
|
|
|
+ // check whether mScaledBackground needs to be updated:
|
|
|
+ QSize scaledSize(mBackgroundPixmap.size());
|
|
|
+ scaledSize.scale(mRect.size(), mBackgroundScaledMode);
|
|
|
+ if (mScaledBackgroundPixmap.size() != scaledSize)
|
|
|
+ mScaledBackgroundPixmap = mBackgroundPixmap.scaled(mRect.size(), mBackgroundScaledMode, Qt::SmoothTransformation);
|
|
|
+ painter->drawPixmap(mRect.topLeft()+QPoint(0, -1), mScaledBackgroundPixmap, QRect(0, 0, mRect.width(), mRect.height()) & mScaledBackgroundPixmap.rect());
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ painter->drawPixmap(mRect.topLeft()+QPoint(0, -1), mBackgroundPixmap, QRect(0, 0, mRect.width(), mRect.height()));
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ This function makes sure multiple axes on the side specified with \a type don't collide, but are
|
|
|
+ distributed according to their respective space requirement (QCPAxis::calculateMargin).
|
|
|
+
|
|
|
+ It does this by setting an appropriate offset (\ref QCPAxis::setOffset) on all axes except the
|
|
|
+ one with index zero.
|
|
|
+
|
|
|
+ This function is called by \ref calculateAutoMargin.
|
|
|
+*/
|
|
|
+void QCPAxisRect::updateAxesOffset(QCPAxis::AxisType type)
|
|
|
+{
|
|
|
+ const QList<QCPAxis*> axesList = mAxes.value(type);
|
|
|
+ if (axesList.isEmpty())
|
|
|
+ return;
|
|
|
+
|
|
|
+ bool isFirstVisible = !axesList.first()->visible(); // if the first axis is visible, the second axis (which is where the loop starts) isn't the first visible axis, so initialize with false
|
|
|
+ for (int i=1; i<axesList.size(); ++i)
|
|
|
+ {
|
|
|
+ int offset = axesList.at(i-1)->offset() + axesList.at(i-1)->calculateMargin();
|
|
|
+ if (axesList.at(i)->visible()) // only add inner tick length to offset if this axis is visible and it's not the first visible one (might happen if true first axis is invisible)
|
|
|
+ {
|
|
|
+ if (!isFirstVisible)
|
|
|
+ offset += axesList.at(i)->tickLengthIn();
|
|
|
+ isFirstVisible = false;
|
|
|
+ }
|
|
|
+ axesList.at(i)->setOffset(offset);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+int QCPAxisRect::calculateAutoMargin(QCP::MarginSide side)
|
|
|
+{
|
|
|
+ if (!mAutoMargins.testFlag(side))
|
|
|
+ qDebug() << Q_FUNC_INFO << "Called with side that isn't specified as auto margin";
|
|
|
+
|
|
|
+ updateAxesOffset(QCPAxis::marginSideToAxisType(side));
|
|
|
+
|
|
|
+ // note: only need to look at the last (outer most) axis to determine the total margin, due to updateAxisOffset call
|
|
|
+ const QList<QCPAxis*> axesList = mAxes.value(QCPAxis::marginSideToAxisType(side));
|
|
|
+ if (axesList.size() > 0)
|
|
|
+ return axesList.last()->offset() + axesList.last()->calculateMargin();
|
|
|
+ else
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Reacts to a change in layout to potentially set the convenience axis pointers \ref
|
|
|
+ QCustomPlot::xAxis, \ref QCustomPlot::yAxis, etc. of the parent QCustomPlot to the respective
|
|
|
+ axes of this axis rect. This is only done if the respective convenience pointer is currently zero
|
|
|
+ and if there is no QCPAxisRect at position (0, 0) of the plot layout.
|
|
|
+
|
|
|
+ This automation makes it simpler to replace the main axis rect with a newly created one, without
|
|
|
+ the need to manually reset the convenience pointers.
|
|
|
+*/
|
|
|
+void QCPAxisRect::layoutChanged()
|
|
|
+{
|
|
|
+ if (mParentPlot && mParentPlot->axisRectCount() > 0 && mParentPlot->axisRect(0) == this)
|
|
|
+ {
|
|
|
+ if (axisCount(QCPAxis::atBottom) > 0 && !mParentPlot->xAxis)
|
|
|
+ mParentPlot->xAxis = axis(QCPAxis::atBottom);
|
|
|
+ if (axisCount(QCPAxis::atLeft) > 0 && !mParentPlot->yAxis)
|
|
|
+ mParentPlot->yAxis = axis(QCPAxis::atLeft);
|
|
|
+ if (axisCount(QCPAxis::atTop) > 0 && !mParentPlot->xAxis2)
|
|
|
+ mParentPlot->xAxis2 = axis(QCPAxis::atTop);
|
|
|
+ if (axisCount(QCPAxis::atRight) > 0 && !mParentPlot->yAxis2)
|
|
|
+ mParentPlot->yAxis2 = axis(QCPAxis::atRight);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Event handler for when a mouse button is pressed on the axis rect. If the left mouse button is
|
|
|
+ pressed, the range dragging interaction is initialized (the actual range manipulation happens in
|
|
|
+ the \ref mouseMoveEvent).
|
|
|
+
|
|
|
+ The mDragging flag is set to true and some anchor points are set that are needed to determine the
|
|
|
+ distance the mouse was dragged in the mouse move/release events later.
|
|
|
+
|
|
|
+ \see mouseMoveEvent, mouseReleaseEvent
|
|
|
+*/
|
|
|
+void QCPAxisRect::mousePressEvent(QMouseEvent *event, const QVariant &details)
|
|
|
+{
|
|
|
+ Q_UNUSED(details)
|
|
|
+ if (event->buttons() & Qt::LeftButton)
|
|
|
+ {
|
|
|
+ mDragging = true;
|
|
|
+ // initialize antialiasing backup in case we start dragging:
|
|
|
+ if (mParentPlot->noAntialiasingOnDrag())
|
|
|
+ {
|
|
|
+ mAADragBackup = mParentPlot->antialiasedElements();
|
|
|
+ mNotAADragBackup = mParentPlot->notAntialiasedElements();
|
|
|
+ }
|
|
|
+ // Mouse range dragging interaction:
|
|
|
+ if (mParentPlot->interactions().testFlag(QCP::iRangeDrag))
|
|
|
+ {
|
|
|
+ mDragStartHorzRange.clear();
|
|
|
+ for (int i=0; i<mRangeDragHorzAxis.size(); ++i)
|
|
|
+ mDragStartHorzRange.append(mRangeDragHorzAxis.at(i).isNull() ? QCPRange() : mRangeDragHorzAxis.at(i)->range());
|
|
|
+ mDragStartVertRange.clear();
|
|
|
+ for (int i=0; i<mRangeDragVertAxis.size(); ++i)
|
|
|
+ mDragStartVertRange.append(mRangeDragVertAxis.at(i).isNull() ? QCPRange() : mRangeDragVertAxis.at(i)->range());
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Event handler for when the mouse is moved on the axis rect. If range dragging was activated in a
|
|
|
+ preceding \ref mousePressEvent, the range is moved accordingly.
|
|
|
+
|
|
|
+ \see mousePressEvent, mouseReleaseEvent
|
|
|
+*/
|
|
|
+void QCPAxisRect::mouseMoveEvent(QMouseEvent *event, const QPointF &startPos)
|
|
|
+{
|
|
|
+ Q_UNUSED(startPos)
|
|
|
+ // Mouse range dragging interaction:
|
|
|
+ if (mDragging && mParentPlot->interactions().testFlag(QCP::iRangeDrag))
|
|
|
+ {
|
|
|
+
|
|
|
+ if (mRangeDrag.testFlag(Qt::Horizontal))
|
|
|
+ {
|
|
|
+ for (int i=0; i<mRangeDragHorzAxis.size(); ++i)
|
|
|
+ {
|
|
|
+ QCPAxis *ax = mRangeDragHorzAxis.at(i).data();
|
|
|
+ if (!ax)
|
|
|
+ continue;
|
|
|
+ if (i >= mDragStartHorzRange.size())
|
|
|
+ break;
|
|
|
+ if (ax->mScaleType == QCPAxis::stLinear)
|
|
|
+ {
|
|
|
+ double diff = ax->pixelToCoord(startPos.x()) - ax->pixelToCoord(event->pos().x());
|
|
|
+ ax->setRange(mDragStartHorzRange.at(i).lower+diff, mDragStartHorzRange.at(i).upper+diff);
|
|
|
+ } else if (ax->mScaleType == QCPAxis::stLogarithmic)
|
|
|
+ {
|
|
|
+ double diff = ax->pixelToCoord(startPos.x()) / ax->pixelToCoord(event->pos().x());
|
|
|
+ ax->setRange(mDragStartHorzRange.at(i).lower*diff, mDragStartHorzRange.at(i).upper*diff);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (mRangeDrag.testFlag(Qt::Vertical))
|
|
|
+ {
|
|
|
+ for (int i=0; i<mRangeDragVertAxis.size(); ++i)
|
|
|
+ {
|
|
|
+ QCPAxis *ax = mRangeDragVertAxis.at(i).data();
|
|
|
+ if (!ax)
|
|
|
+ continue;
|
|
|
+ if (i >= mDragStartVertRange.size())
|
|
|
+ break;
|
|
|
+ if (ax->mScaleType == QCPAxis::stLinear)
|
|
|
+ {
|
|
|
+ double diff = ax->pixelToCoord(startPos.y()) - ax->pixelToCoord(event->pos().y());
|
|
|
+ ax->setRange(mDragStartVertRange.at(i).lower+diff, mDragStartVertRange.at(i).upper+diff);
|
|
|
+ } else if (ax->mScaleType == QCPAxis::stLogarithmic)
|
|
|
+ {
|
|
|
+ double diff = ax->pixelToCoord(startPos.y()) / ax->pixelToCoord(event->pos().y());
|
|
|
+ ax->setRange(mDragStartVertRange.at(i).lower*diff, mDragStartVertRange.at(i).upper*diff);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (mRangeDrag != 0) // if either vertical or horizontal drag was enabled, do a replot
|
|
|
+ {
|
|
|
+ if (mParentPlot->noAntialiasingOnDrag())
|
|
|
+ mParentPlot->setNotAntialiasedElements(QCP::aeAll);
|
|
|
+ mParentPlot->replot(QCustomPlot::rpQueuedReplot);
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPAxisRect::mouseReleaseEvent(QMouseEvent *event, const QPointF &startPos)
|
|
|
+{
|
|
|
+ Q_UNUSED(event)
|
|
|
+ Q_UNUSED(startPos)
|
|
|
+ mDragging = false;
|
|
|
+ if (mParentPlot->noAntialiasingOnDrag())
|
|
|
+ {
|
|
|
+ mParentPlot->setAntialiasedElements(mAADragBackup);
|
|
|
+ mParentPlot->setNotAntialiasedElements(mNotAADragBackup);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Event handler for mouse wheel events. If rangeZoom is Qt::Horizontal, Qt::Vertical or both, the
|
|
|
+ ranges of the axes defined as rangeZoomHorzAxis and rangeZoomVertAxis are scaled. The center of
|
|
|
+ the scaling operation is the current cursor position inside the axis rect. The scaling factor is
|
|
|
+ dependent on the mouse wheel delta (which direction the wheel was rotated) to provide a natural
|
|
|
+ zooming feel. The Strength of the zoom can be controlled via \ref setRangeZoomFactor.
|
|
|
+
|
|
|
+ Note, that event->delta() is usually +/-120 for single rotation steps. However, if the mouse
|
|
|
+ wheel is turned rapidly, many steps may bunch up to one event, so the event->delta() may then be
|
|
|
+ multiples of 120. This is taken into account here, by calculating \a wheelSteps and using it as
|
|
|
+ exponent of the range zoom factor. This takes care of the wheel direction automatically, by
|
|
|
+ inverting the factor, when the wheel step is negative (f^-1 = 1/f).
|
|
|
+*/
|
|
|
+void QCPAxisRect::wheelEvent(QWheelEvent *event)
|
|
|
+{
|
|
|
+ // Mouse range zooming interaction:
|
|
|
+ if (mParentPlot->interactions().testFlag(QCP::iRangeZoom))
|
|
|
+ {
|
|
|
+ if (mRangeZoom != 0)
|
|
|
+ {
|
|
|
+ double factor;
|
|
|
+ double wheelSteps = event->delta()/120.0; // a single step delta is +/-120 usually
|
|
|
+ if (mRangeZoom.testFlag(Qt::Horizontal))
|
|
|
+ {
|
|
|
+ factor = qPow(mRangeZoomFactorHorz, wheelSteps);
|
|
|
+ for (int i=0; i<mRangeZoomHorzAxis.size(); ++i)
|
|
|
+ {
|
|
|
+ if (!mRangeZoomHorzAxis.at(i).isNull())
|
|
|
+ mRangeZoomHorzAxis.at(i)->scaleRange(factor, mRangeZoomHorzAxis.at(i)->pixelToCoord(event->pos().x()));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (mRangeZoom.testFlag(Qt::Vertical))
|
|
|
+ {
|
|
|
+ factor = qPow(mRangeZoomFactorVert, wheelSteps);
|
|
|
+ for (int i=0; i<mRangeZoomVertAxis.size(); ++i)
|
|
|
+ {
|
|
|
+ if (!mRangeZoomVertAxis.at(i).isNull())
|
|
|
+ mRangeZoomVertAxis.at(i)->scaleRange(factor, mRangeZoomVertAxis.at(i)->pixelToCoord(event->pos().y()));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ mParentPlot->replot();
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+/* end of 'src/layoutelements/layoutelement-axisrect.cpp' */
|
|
|
+
|
|
|
+
|
|
|
+/* including file 'src/layoutelements/layoutelement-legend.cpp', size 31097 */
|
|
|
+/* commit 9868e55d3b412f2f89766bb482fcf299e93a0988 2017-09-04 01:56:22 +0200 */
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPAbstractLegendItem
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+/*! \class QCPAbstractLegendItem
|
|
|
+ \brief The abstract base class for all entries in a QCPLegend.
|
|
|
+
|
|
|
+ It defines a very basic interface for entries in a QCPLegend. For representing plottables in the
|
|
|
+ legend, the subclass \ref QCPPlottableLegendItem is more suitable.
|
|
|
+
|
|
|
+ Only derive directly from this class when you need absolute freedom (e.g. a custom legend entry
|
|
|
+ that's not even associated with a plottable).
|
|
|
+
|
|
|
+ You must implement the following pure virtual functions:
|
|
|
+ \li \ref draw (from QCPLayerable)
|
|
|
+
|
|
|
+ You inherit the following members you may use:
|
|
|
+ <table>
|
|
|
+ <tr>
|
|
|
+ <td>QCPLegend *\b mParentLegend</td>
|
|
|
+ <td>A pointer to the parent QCPLegend.</td>
|
|
|
+ </tr><tr>
|
|
|
+ <td>QFont \b mFont</td>
|
|
|
+ <td>The generic font of the item. You should use this font for all or at least the most prominent text of the item.</td>
|
|
|
+ </tr>
|
|
|
+ </table>
|
|
|
+*/
|
|
|
+
|
|
|
+/* start of documentation of signals */
|
|
|
+
|
|
|
+/*! \fn void QCPAbstractLegendItem::selectionChanged(bool selected)
|
|
|
+
|
|
|
+ This signal is emitted when the selection state of this legend item has changed, either by user
|
|
|
+ interaction or by a direct call to \ref setSelected.
|
|
|
+*/
|
|
|
+
|
|
|
+/* end of documentation of signals */
|
|
|
+
|
|
|
+/*!
|
|
|
+ Constructs a QCPAbstractLegendItem and associates it with the QCPLegend \a parent. This does not
|
|
|
+ cause the item to be added to \a parent, so \ref QCPLegend::addItem must be called separately.
|
|
|
+*/
|
|
|
+QCPAbstractLegendItem::QCPAbstractLegendItem(QCPLegend *parent) :
|
|
|
+ QCPLayoutElement(parent->parentPlot()),
|
|
|
+ mParentLegend(parent),
|
|
|
+ mFont(parent->font()),
|
|
|
+ mTextColor(parent->textColor()),
|
|
|
+ mSelectedFont(parent->selectedFont()),
|
|
|
+ mSelectedTextColor(parent->selectedTextColor()),
|
|
|
+ mSelectable(true),
|
|
|
+ mSelected(false)
|
|
|
+{
|
|
|
+ setLayer(QLatin1String("legend"));
|
|
|
+ setMargins(QMargins(0, 0, 0, 0));
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the default font of this specific legend item to \a font.
|
|
|
+
|
|
|
+ \see setTextColor, QCPLegend::setFont
|
|
|
+*/
|
|
|
+void QCPAbstractLegendItem::setFont(const QFont &font)
|
|
|
+{
|
|
|
+ mFont = font;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the default text color of this specific legend item to \a color.
|
|
|
+
|
|
|
+ \see setFont, QCPLegend::setTextColor
|
|
|
+*/
|
|
|
+void QCPAbstractLegendItem::setTextColor(const QColor &color)
|
|
|
+{
|
|
|
+ mTextColor = color;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ When this legend item is selected, \a font is used to draw generic text, instead of the normal
|
|
|
+ font set with \ref setFont.
|
|
|
+
|
|
|
+ \see setFont, QCPLegend::setSelectedFont
|
|
|
+*/
|
|
|
+void QCPAbstractLegendItem::setSelectedFont(const QFont &font)
|
|
|
+{
|
|
|
+ mSelectedFont = font;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ When this legend item is selected, \a color is used to draw generic text, instead of the normal
|
|
|
+ color set with \ref setTextColor.
|
|
|
+
|
|
|
+ \see setTextColor, QCPLegend::setSelectedTextColor
|
|
|
+*/
|
|
|
+void QCPAbstractLegendItem::setSelectedTextColor(const QColor &color)
|
|
|
+{
|
|
|
+ mSelectedTextColor = color;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets whether this specific legend item is selectable.
|
|
|
+
|
|
|
+ \see setSelectedParts, QCustomPlot::setInteractions
|
|
|
+*/
|
|
|
+void QCPAbstractLegendItem::setSelectable(bool selectable)
|
|
|
+{
|
|
|
+ if (mSelectable != selectable)
|
|
|
+ {
|
|
|
+ mSelectable = selectable;
|
|
|
+ emit selectableChanged(mSelectable);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets whether this specific legend item is selected.
|
|
|
+
|
|
|
+ It is possible to set the selection state of this item by calling this function directly, even if
|
|
|
+ setSelectable is set to false.
|
|
|
+
|
|
|
+ \see setSelectableParts, QCustomPlot::setInteractions
|
|
|
+*/
|
|
|
+void QCPAbstractLegendItem::setSelected(bool selected)
|
|
|
+{
|
|
|
+ if (mSelected != selected)
|
|
|
+ {
|
|
|
+ mSelected = selected;
|
|
|
+ emit selectionChanged(mSelected);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+double QCPAbstractLegendItem::selectTest(const QPointF &pos, bool onlySelectable, QVariant *details) const
|
|
|
+{
|
|
|
+ Q_UNUSED(details)
|
|
|
+ if (!mParentPlot) return -1;
|
|
|
+ if (onlySelectable && (!mSelectable || !mParentLegend->selectableParts().testFlag(QCPLegend::spItems)))
|
|
|
+ return -1;
|
|
|
+
|
|
|
+ if (mRect.contains(pos.toPoint()))
|
|
|
+ return mParentPlot->selectionTolerance()*0.99;
|
|
|
+ else
|
|
|
+ return -1;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPAbstractLegendItem::applyDefaultAntialiasingHint(QCPPainter *painter) const
|
|
|
+{
|
|
|
+ applyAntialiasingHint(painter, mAntialiased, QCP::aeLegendItems);
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+QRect QCPAbstractLegendItem::clipRect() const
|
|
|
+{
|
|
|
+ return mOuterRect;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPAbstractLegendItem::selectEvent(QMouseEvent *event, bool additive, const QVariant &details, bool *selectionStateChanged)
|
|
|
+{
|
|
|
+ Q_UNUSED(event)
|
|
|
+ Q_UNUSED(details)
|
|
|
+ if (mSelectable && mParentLegend->selectableParts().testFlag(QCPLegend::spItems))
|
|
|
+ {
|
|
|
+ bool selBefore = mSelected;
|
|
|
+ setSelected(additive ? !mSelected : true);
|
|
|
+ if (selectionStateChanged)
|
|
|
+ *selectionStateChanged = mSelected != selBefore;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPAbstractLegendItem::deselectEvent(bool *selectionStateChanged)
|
|
|
+{
|
|
|
+ if (mSelectable && mParentLegend->selectableParts().testFlag(QCPLegend::spItems))
|
|
|
+ {
|
|
|
+ bool selBefore = mSelected;
|
|
|
+ setSelected(false);
|
|
|
+ if (selectionStateChanged)
|
|
|
+ *selectionStateChanged = mSelected != selBefore;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPPlottableLegendItem
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+/*! \class QCPPlottableLegendItem
|
|
|
+ \brief A legend item representing a plottable with an icon and the plottable name.
|
|
|
+
|
|
|
+ This is the standard legend item for plottables. It displays an icon of the plottable next to the
|
|
|
+ plottable name. The icon is drawn by the respective plottable itself (\ref
|
|
|
+ QCPAbstractPlottable::drawLegendIcon), and tries to give an intuitive symbol for the plottable.
|
|
|
+ For example, the QCPGraph draws a centered horizontal line and/or a single scatter point in the
|
|
|
+ middle.
|
|
|
+
|
|
|
+ Legend items of this type are always associated with one plottable (retrievable via the
|
|
|
+ plottable() function and settable with the constructor). You may change the font of the plottable
|
|
|
+ name with \ref setFont. Icon padding and border pen is taken from the parent QCPLegend, see \ref
|
|
|
+ QCPLegend::setIconBorderPen and \ref QCPLegend::setIconTextPadding.
|
|
|
+
|
|
|
+ The function \ref QCPAbstractPlottable::addToLegend/\ref QCPAbstractPlottable::removeFromLegend
|
|
|
+ creates/removes legend items of this type.
|
|
|
+
|
|
|
+ Since QCPLegend is based on QCPLayoutGrid, a legend item itself is just a subclass of
|
|
|
+ QCPLayoutElement. While it could be added to a legend (or any other layout) via the normal layout
|
|
|
+ interface, QCPLegend has specialized functions for handling legend items conveniently, see the
|
|
|
+ documentation of \ref QCPLegend.
|
|
|
+*/
|
|
|
+
|
|
|
+/*!
|
|
|
+ Creates a new legend item associated with \a plottable.
|
|
|
+
|
|
|
+ Once it's created, it can be added to the legend via \ref QCPLegend::addItem.
|
|
|
+
|
|
|
+ A more convenient way of adding/removing a plottable to/from the legend is via the functions \ref
|
|
|
+ QCPAbstractPlottable::addToLegend and \ref QCPAbstractPlottable::removeFromLegend.
|
|
|
+*/
|
|
|
+QCPPlottableLegendItem::QCPPlottableLegendItem(QCPLegend *parent, QCPAbstractPlottable *plottable) :
|
|
|
+ QCPAbstractLegendItem(parent),
|
|
|
+ mPlottable(plottable)
|
|
|
+{
|
|
|
+ setAntialiased(false);
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the pen that shall be used to draw the icon border, taking into account the selection
|
|
|
+ state of this item.
|
|
|
+*/
|
|
|
+QPen QCPPlottableLegendItem::getIconBorderPen() const
|
|
|
+{
|
|
|
+ return mSelected ? mParentLegend->selectedIconBorderPen() : mParentLegend->iconBorderPen();
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the text color that shall be used to draw text, taking into account the selection state
|
|
|
+ of this item.
|
|
|
+*/
|
|
|
+QColor QCPPlottableLegendItem::getTextColor() const
|
|
|
+{
|
|
|
+ return mSelected ? mSelectedTextColor : mTextColor;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the font that shall be used to draw text, taking into account the selection state of this
|
|
|
+ item.
|
|
|
+*/
|
|
|
+QFont QCPPlottableLegendItem::getFont() const
|
|
|
+{
|
|
|
+ return mSelected ? mSelectedFont : mFont;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Draws the item with \a painter. The size and position of the drawn legend item is defined by the
|
|
|
+ parent layout (typically a \ref QCPLegend) and the \ref minimumOuterSizeHint and \ref
|
|
|
+ maximumOuterSizeHint of this legend item.
|
|
|
+*/
|
|
|
+void QCPPlottableLegendItem::draw(QCPPainter *painter)
|
|
|
+{
|
|
|
+ if (!mPlottable) return;
|
|
|
+ painter->setFont(getFont());
|
|
|
+ painter->setPen(QPen(getTextColor()));
|
|
|
+ QSizeF iconSize = mParentLegend->iconSize();
|
|
|
+ QRectF textRect = painter->fontMetrics().boundingRect(0, 0, 0, iconSize.height(), Qt::TextDontClip, mPlottable->name());
|
|
|
+ QRectF iconRect(mRect.topLeft(), iconSize);
|
|
|
+ int textHeight = qMax(textRect.height(), iconSize.height()); // if text has smaller height than icon, center text vertically in icon height, else align tops
|
|
|
+ painter->drawText(mRect.x()+iconSize.width()+mParentLegend->iconTextPadding(), mRect.y(), textRect.width(), textHeight, Qt::TextDontClip, mPlottable->name());
|
|
|
+ // draw icon:
|
|
|
+ painter->save();
|
|
|
+ painter->setClipRect(iconRect, Qt::IntersectClip);
|
|
|
+ mPlottable->drawLegendIcon(painter, iconRect);
|
|
|
+ painter->restore();
|
|
|
+ // draw icon border:
|
|
|
+ if (getIconBorderPen().style() != Qt::NoPen)
|
|
|
+ {
|
|
|
+ painter->setPen(getIconBorderPen());
|
|
|
+ painter->setBrush(Qt::NoBrush);
|
|
|
+ int halfPen = qCeil(painter->pen().widthF()*0.5)+1;
|
|
|
+ painter->setClipRect(mOuterRect.adjusted(-halfPen, -halfPen, halfPen, halfPen)); // extend default clip rect so thicker pens (especially during selection) are not clipped
|
|
|
+ painter->drawRect(iconRect);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Calculates and returns the size of this item. This includes the icon, the text and the padding in
|
|
|
+ between.
|
|
|
+
|
|
|
+ \seebaseclassmethod
|
|
|
+*/
|
|
|
+QSize QCPPlottableLegendItem::minimumOuterSizeHint() const
|
|
|
+{
|
|
|
+ if (!mPlottable) return QSize();
|
|
|
+ QSize result(0, 0);
|
|
|
+ QRect textRect;
|
|
|
+ QFontMetrics fontMetrics(getFont());
|
|
|
+ QSize iconSize = mParentLegend->iconSize();
|
|
|
+ textRect = fontMetrics.boundingRect(0, 0, 0, iconSize.height(), Qt::TextDontClip, mPlottable->name());
|
|
|
+ result.setWidth(iconSize.width() + mParentLegend->iconTextPadding() + textRect.width());
|
|
|
+ result.setHeight(qMax(textRect.height(), iconSize.height()));
|
|
|
+ result.rwidth() += mMargins.left()+mMargins.right();
|
|
|
+ result.rheight() += mMargins.top()+mMargins.bottom();
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPLegend
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+/*! \class QCPLegend
|
|
|
+ \brief Manages a legend inside a QCustomPlot.
|
|
|
+
|
|
|
+ A legend is a small box somewhere in the plot which lists plottables with their name and icon.
|
|
|
+
|
|
|
+ A legend is populated with legend items by calling \ref QCPAbstractPlottable::addToLegend on the
|
|
|
+ plottable, for which a legend item shall be created. In the case of the main legend (\ref
|
|
|
+ QCustomPlot::legend), simply adding plottables to the plot while \ref
|
|
|
+ QCustomPlot::setAutoAddPlottableToLegend is set to true (the default) creates corresponding
|
|
|
+ legend items. The legend item associated with a certain plottable can be removed with \ref
|
|
|
+ QCPAbstractPlottable::removeFromLegend. However, QCPLegend also offers an interface to add and
|
|
|
+ manipulate legend items directly: \ref item, \ref itemWithPlottable, \ref itemCount, \ref
|
|
|
+ addItem, \ref removeItem, etc.
|
|
|
+
|
|
|
+ Since \ref QCPLegend derives from \ref QCPLayoutGrid, it can be placed in any position a \ref
|
|
|
+ QCPLayoutElement may be positioned. The legend items are themselves \ref QCPLayoutElement
|
|
|
+ "QCPLayoutElements" which are placed in the grid layout of the legend. \ref QCPLegend only adds
|
|
|
+ an interface specialized for handling child elements of type \ref QCPAbstractLegendItem, as
|
|
|
+ mentioned above. In principle, any other layout elements may also be added to a legend via the
|
|
|
+ normal \ref QCPLayoutGrid interface. See the special page about \link thelayoutsystem The Layout
|
|
|
+ System\endlink for examples on how to add other elements to the legend and move it outside the axis
|
|
|
+ rect.
|
|
|
+
|
|
|
+ Use the methods \ref setFillOrder and \ref setWrap inherited from \ref QCPLayoutGrid to control
|
|
|
+ in which order (column first or row first) the legend is filled up when calling \ref addItem, and
|
|
|
+ at which column or row wrapping occurs.
|
|
|
+
|
|
|
+ By default, every QCustomPlot has one legend (\ref QCustomPlot::legend) which is placed in the
|
|
|
+ inset layout of the main axis rect (\ref QCPAxisRect::insetLayout). To move the legend to another
|
|
|
+ position inside the axis rect, use the methods of the \ref QCPLayoutInset. To move the legend
|
|
|
+ outside of the axis rect, place it anywhere else with the \ref QCPLayout/\ref QCPLayoutElement
|
|
|
+ interface.
|
|
|
+*/
|
|
|
+
|
|
|
+/* start of documentation of signals */
|
|
|
+
|
|
|
+/*! \fn void QCPLegend::selectionChanged(QCPLegend::SelectableParts selection);
|
|
|
+
|
|
|
+ This signal is emitted when the selection state of this legend has changed.
|
|
|
+
|
|
|
+ \see setSelectedParts, setSelectableParts
|
|
|
+*/
|
|
|
+
|
|
|
+/* end of documentation of signals */
|
|
|
+
|
|
|
+/*!
|
|
|
+ Constructs a new QCPLegend instance with default values.
|
|
|
+
|
|
|
+ Note that by default, QCustomPlot already contains a legend ready to be used as \ref
|
|
|
+ QCustomPlot::legend
|
|
|
+*/
|
|
|
+QCPLegend::QCPLegend()
|
|
|
+{
|
|
|
+ setFillOrder(QCPLayoutGrid::foRowsFirst);
|
|
|
+ setWrap(0);
|
|
|
+
|
|
|
+ setRowSpacing(3);
|
|
|
+ setColumnSpacing(8);
|
|
|
+ setMargins(QMargins(7, 5, 7, 4));
|
|
|
+ setAntialiased(false);
|
|
|
+ setIconSize(32, 18);
|
|
|
+
|
|
|
+ setIconTextPadding(7);
|
|
|
+
|
|
|
+ setSelectableParts(spLegendBox | spItems);
|
|
|
+ setSelectedParts(spNone);
|
|
|
+
|
|
|
+ setBorderPen(QPen(Qt::black, 0));
|
|
|
+ setSelectedBorderPen(QPen(Qt::blue, 2));
|
|
|
+ setIconBorderPen(Qt::NoPen);
|
|
|
+ setSelectedIconBorderPen(QPen(Qt::blue, 2));
|
|
|
+ setBrush(Qt::white);
|
|
|
+ setSelectedBrush(Qt::white);
|
|
|
+ setTextColor(Qt::black);
|
|
|
+ setSelectedTextColor(Qt::blue);
|
|
|
+}
|
|
|
+
|
|
|
+QCPLegend::~QCPLegend()
|
|
|
+{
|
|
|
+ clearItems();
|
|
|
+ if (qobject_cast<QCustomPlot*>(mParentPlot)) // make sure this isn't called from QObject dtor when QCustomPlot is already destructed (happens when the legend is not in any layout and thus QObject-child of QCustomPlot)
|
|
|
+ mParentPlot->legendRemoved(this);
|
|
|
+}
|
|
|
+
|
|
|
+/* no doc for getter, see setSelectedParts */
|
|
|
+QCPLegend::SelectableParts QCPLegend::selectedParts() const
|
|
|
+{
|
|
|
+ // check whether any legend elements selected, if yes, add spItems to return value
|
|
|
+ bool hasSelectedItems = false;
|
|
|
+ for (int i=0; i<itemCount(); ++i)
|
|
|
+ {
|
|
|
+ if (item(i) && item(i)->selected())
|
|
|
+ {
|
|
|
+ hasSelectedItems = true;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (hasSelectedItems)
|
|
|
+ return mSelectedParts | spItems;
|
|
|
+ else
|
|
|
+ return mSelectedParts & ~spItems;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the pen, the border of the entire legend is drawn with.
|
|
|
+*/
|
|
|
+void QCPLegend::setBorderPen(const QPen &pen)
|
|
|
+{
|
|
|
+ mBorderPen = pen;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the brush of the legend background.
|
|
|
+*/
|
|
|
+void QCPLegend::setBrush(const QBrush &brush)
|
|
|
+{
|
|
|
+ mBrush = brush;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the default font of legend text. Legend items that draw text (e.g. the name of a graph) will
|
|
|
+ use this font by default. However, a different font can be specified on a per-item-basis by
|
|
|
+ accessing the specific legend item.
|
|
|
+
|
|
|
+ This function will also set \a font on all already existing legend items.
|
|
|
+
|
|
|
+ \see QCPAbstractLegendItem::setFont
|
|
|
+*/
|
|
|
+void QCPLegend::setFont(const QFont &font)
|
|
|
+{
|
|
|
+ mFont = font;
|
|
|
+ for (int i=0; i<itemCount(); ++i)
|
|
|
+ {
|
|
|
+ if (item(i))
|
|
|
+ item(i)->setFont(mFont);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the default color of legend text. Legend items that draw text (e.g. the name of a graph)
|
|
|
+ will use this color by default. However, a different colors can be specified on a per-item-basis
|
|
|
+ by accessing the specific legend item.
|
|
|
+
|
|
|
+ This function will also set \a color on all already existing legend items.
|
|
|
+
|
|
|
+ \see QCPAbstractLegendItem::setTextColor
|
|
|
+*/
|
|
|
+void QCPLegend::setTextColor(const QColor &color)
|
|
|
+{
|
|
|
+ mTextColor = color;
|
|
|
+ for (int i=0; i<itemCount(); ++i)
|
|
|
+ {
|
|
|
+ if (item(i))
|
|
|
+ item(i)->setTextColor(color);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the size of legend icons. Legend items that draw an icon (e.g. a visual
|
|
|
+ representation of the graph) will use this size by default.
|
|
|
+*/
|
|
|
+void QCPLegend::setIconSize(const QSize &size)
|
|
|
+{
|
|
|
+ mIconSize = size;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+*/
|
|
|
+void QCPLegend::setIconSize(int width, int height)
|
|
|
+{
|
|
|
+ mIconSize.setWidth(width);
|
|
|
+ mIconSize.setHeight(height);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the horizontal space in pixels between the legend icon and the text next to it.
|
|
|
+ Legend items that draw an icon (e.g. a visual representation of the graph) and text (e.g. the
|
|
|
+ name of the graph) will use this space by default.
|
|
|
+*/
|
|
|
+void QCPLegend::setIconTextPadding(int padding)
|
|
|
+{
|
|
|
+ mIconTextPadding = padding;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the pen used to draw a border around each legend icon. Legend items that draw an
|
|
|
+ icon (e.g. a visual representation of the graph) will use this pen by default.
|
|
|
+
|
|
|
+ If no border is wanted, set this to \a Qt::NoPen.
|
|
|
+*/
|
|
|
+void QCPLegend::setIconBorderPen(const QPen &pen)
|
|
|
+{
|
|
|
+ mIconBorderPen = pen;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets whether the user can (de-)select the parts in \a selectable by clicking on the QCustomPlot surface.
|
|
|
+ (When \ref QCustomPlot::setInteractions contains \ref QCP::iSelectLegend.)
|
|
|
+
|
|
|
+ However, even when \a selectable is set to a value not allowing the selection of a specific part,
|
|
|
+ it is still possible to set the selection of this part manually, by calling \ref setSelectedParts
|
|
|
+ directly.
|
|
|
+
|
|
|
+ \see SelectablePart, setSelectedParts
|
|
|
+*/
|
|
|
+void QCPLegend::setSelectableParts(const SelectableParts &selectable)
|
|
|
+{
|
|
|
+ if (mSelectableParts != selectable)
|
|
|
+ {
|
|
|
+ mSelectableParts = selectable;
|
|
|
+ emit selectableChanged(mSelectableParts);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the selected state of the respective legend parts described by \ref SelectablePart. When a part
|
|
|
+ is selected, it uses a different pen/font and brush. If some legend items are selected and \a selected
|
|
|
+ doesn't contain \ref spItems, those items become deselected.
|
|
|
+
|
|
|
+ The entire selection mechanism is handled automatically when \ref QCustomPlot::setInteractions
|
|
|
+ contains iSelectLegend. You only need to call this function when you wish to change the selection
|
|
|
+ state manually.
|
|
|
+
|
|
|
+ This function can change the selection state of a part even when \ref setSelectableParts was set to a
|
|
|
+ value that actually excludes the part.
|
|
|
+
|
|
|
+ emits the \ref selectionChanged signal when \a selected is different from the previous selection state.
|
|
|
+
|
|
|
+ Note that it doesn't make sense to set the selected state \ref spItems here when it wasn't set
|
|
|
+ before, because there's no way to specify which exact items to newly select. Do this by calling
|
|
|
+ \ref QCPAbstractLegendItem::setSelected directly on the legend item you wish to select.
|
|
|
+
|
|
|
+ \see SelectablePart, setSelectableParts, selectTest, setSelectedBorderPen, setSelectedIconBorderPen, setSelectedBrush,
|
|
|
+ setSelectedFont
|
|
|
+*/
|
|
|
+void QCPLegend::setSelectedParts(const SelectableParts &selected)
|
|
|
+{
|
|
|
+ SelectableParts newSelected = selected;
|
|
|
+ mSelectedParts = this->selectedParts(); // update mSelectedParts in case item selection changed
|
|
|
+
|
|
|
+ if (mSelectedParts != newSelected)
|
|
|
+ {
|
|
|
+ if (!mSelectedParts.testFlag(spItems) && newSelected.testFlag(spItems)) // attempt to set spItems flag (can't do that)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "spItems flag can not be set, it can only be unset with this function";
|
|
|
+ newSelected &= ~spItems;
|
|
|
+ }
|
|
|
+ if (mSelectedParts.testFlag(spItems) && !newSelected.testFlag(spItems)) // spItems flag was unset, so clear item selection
|
|
|
+ {
|
|
|
+ for (int i=0; i<itemCount(); ++i)
|
|
|
+ {
|
|
|
+ if (item(i))
|
|
|
+ item(i)->setSelected(false);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ mSelectedParts = newSelected;
|
|
|
+ emit selectionChanged(mSelectedParts);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ When the legend box is selected, this pen is used to draw the border instead of the normal pen
|
|
|
+ set via \ref setBorderPen.
|
|
|
+
|
|
|
+ \see setSelectedParts, setSelectableParts, setSelectedBrush
|
|
|
+*/
|
|
|
+void QCPLegend::setSelectedBorderPen(const QPen &pen)
|
|
|
+{
|
|
|
+ mSelectedBorderPen = pen;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the pen legend items will use to draw their icon borders, when they are selected.
|
|
|
+
|
|
|
+ \see setSelectedParts, setSelectableParts, setSelectedFont
|
|
|
+*/
|
|
|
+void QCPLegend::setSelectedIconBorderPen(const QPen &pen)
|
|
|
+{
|
|
|
+ mSelectedIconBorderPen = pen;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ When the legend box is selected, this brush is used to draw the legend background instead of the normal brush
|
|
|
+ set via \ref setBrush.
|
|
|
+
|
|
|
+ \see setSelectedParts, setSelectableParts, setSelectedBorderPen
|
|
|
+*/
|
|
|
+void QCPLegend::setSelectedBrush(const QBrush &brush)
|
|
|
+{
|
|
|
+ mSelectedBrush = brush;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the default font that is used by legend items when they are selected.
|
|
|
+
|
|
|
+ This function will also set \a font on all already existing legend items.
|
|
|
+
|
|
|
+ \see setFont, QCPAbstractLegendItem::setSelectedFont
|
|
|
+*/
|
|
|
+void QCPLegend::setSelectedFont(const QFont &font)
|
|
|
+{
|
|
|
+ mSelectedFont = font;
|
|
|
+ for (int i=0; i<itemCount(); ++i)
|
|
|
+ {
|
|
|
+ if (item(i))
|
|
|
+ item(i)->setSelectedFont(font);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the default text color that is used by legend items when they are selected.
|
|
|
+
|
|
|
+ This function will also set \a color on all already existing legend items.
|
|
|
+
|
|
|
+ \see setTextColor, QCPAbstractLegendItem::setSelectedTextColor
|
|
|
+*/
|
|
|
+void QCPLegend::setSelectedTextColor(const QColor &color)
|
|
|
+{
|
|
|
+ mSelectedTextColor = color;
|
|
|
+ for (int i=0; i<itemCount(); ++i)
|
|
|
+ {
|
|
|
+ if (item(i))
|
|
|
+ item(i)->setSelectedTextColor(color);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns the item with index \a i.
|
|
|
+
|
|
|
+ Note that the linear index depends on the current fill order (\ref setFillOrder).
|
|
|
+
|
|
|
+ \see itemCount, addItem, itemWithPlottable
|
|
|
+*/
|
|
|
+QCPAbstractLegendItem *QCPLegend::item(int index) const
|
|
|
+{
|
|
|
+ return qobject_cast<QCPAbstractLegendItem*>(elementAt(index));
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns the QCPPlottableLegendItem which is associated with \a plottable (e.g. a \ref QCPGraph*).
|
|
|
+ If such an item isn't in the legend, returns 0.
|
|
|
+
|
|
|
+ \see hasItemWithPlottable
|
|
|
+*/
|
|
|
+QCPPlottableLegendItem *QCPLegend::itemWithPlottable(const QCPAbstractPlottable *plottable) const
|
|
|
+{
|
|
|
+ for (int i=0; i<itemCount(); ++i)
|
|
|
+ {
|
|
|
+ if (QCPPlottableLegendItem *pli = qobject_cast<QCPPlottableLegendItem*>(item(i)))
|
|
|
+ {
|
|
|
+ if (pli->plottable() == plottable)
|
|
|
+ return pli;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns the number of items currently in the legend.
|
|
|
+
|
|
|
+ Note that if empty cells are in the legend (e.g. by calling methods of the \ref QCPLayoutGrid
|
|
|
+ base class which allows creating empty cells), they are included in the returned count.
|
|
|
+
|
|
|
+ \see item
|
|
|
+*/
|
|
|
+int QCPLegend::itemCount() const
|
|
|
+{
|
|
|
+ return elementCount();
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns whether the legend contains \a item.
|
|
|
+
|
|
|
+ \see hasItemWithPlottable
|
|
|
+*/
|
|
|
+bool QCPLegend::hasItem(QCPAbstractLegendItem *item) const
|
|
|
+{
|
|
|
+ for (int i=0; i<itemCount(); ++i)
|
|
|
+ {
|
|
|
+ if (item == this->item(i))
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ return false;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns whether the legend contains a QCPPlottableLegendItem which is associated with \a plottable (e.g. a \ref QCPGraph*).
|
|
|
+ If such an item isn't in the legend, returns false.
|
|
|
+
|
|
|
+ \see itemWithPlottable
|
|
|
+*/
|
|
|
+bool QCPLegend::hasItemWithPlottable(const QCPAbstractPlottable *plottable) const
|
|
|
+{
|
|
|
+ return itemWithPlottable(plottable);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Adds \a item to the legend, if it's not present already. The element is arranged according to the
|
|
|
+ current fill order (\ref setFillOrder) and wrapping (\ref setWrap).
|
|
|
+
|
|
|
+ Returns true on sucess, i.e. if the item wasn't in the list already and has been successfuly added.
|
|
|
+
|
|
|
+ The legend takes ownership of the item.
|
|
|
+
|
|
|
+ \see removeItem, item, hasItem
|
|
|
+*/
|
|
|
+bool QCPLegend::addItem(QCPAbstractLegendItem *item)
|
|
|
+{
|
|
|
+ return addElement(item);
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Removes the item with the specified \a index from the legend and deletes it.
|
|
|
+
|
|
|
+ After successful removal, the legend is reordered according to the current fill order (\ref
|
|
|
+ setFillOrder) and wrapping (\ref setWrap), so no empty cell remains where the removed \a item
|
|
|
+ was. If you don't want this, rather use the raw element interface of \ref QCPLayoutGrid.
|
|
|
+
|
|
|
+ Returns true, if successful. Unlike \ref QCPLayoutGrid::removeAt, this method only removes
|
|
|
+ elements derived from \ref QCPAbstractLegendItem.
|
|
|
+
|
|
|
+ \see itemCount, clearItems
|
|
|
+*/
|
|
|
+bool QCPLegend::removeItem(int index)
|
|
|
+{
|
|
|
+ if (QCPAbstractLegendItem *ali = item(index))
|
|
|
+ {
|
|
|
+ bool success = remove(ali);
|
|
|
+ if (success)
|
|
|
+ setFillOrder(fillOrder(), true); // gets rid of empty cell by reordering
|
|
|
+ return success;
|
|
|
+ } else
|
|
|
+ return false;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Removes \a item from the legend and deletes it.
|
|
|
+
|
|
|
+ After successful removal, the legend is reordered according to the current fill order (\ref
|
|
|
+ setFillOrder) and wrapping (\ref setWrap), so no empty cell remains where the removed \a item
|
|
|
+ was. If you don't want this, rather use the raw element interface of \ref QCPLayoutGrid.
|
|
|
+
|
|
|
+ Returns true, if successful.
|
|
|
+
|
|
|
+ \see clearItems
|
|
|
+*/
|
|
|
+bool QCPLegend::removeItem(QCPAbstractLegendItem *item)
|
|
|
+{
|
|
|
+ bool success = remove(item);
|
|
|
+ if (success)
|
|
|
+ setFillOrder(fillOrder(), true); // gets rid of empty cell by reordering
|
|
|
+ return success;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Removes all items from the legend.
|
|
|
+*/
|
|
|
+void QCPLegend::clearItems()
|
|
|
+{
|
|
|
+ for (int i=itemCount()-1; i>=0; --i)
|
|
|
+ removeItem(i);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns the legend items that are currently selected. If no items are selected,
|
|
|
+ the list is empty.
|
|
|
+
|
|
|
+ \see QCPAbstractLegendItem::setSelected, setSelectable
|
|
|
+*/
|
|
|
+QList<QCPAbstractLegendItem *> QCPLegend::selectedItems() const
|
|
|
+{
|
|
|
+ QList<QCPAbstractLegendItem*> result;
|
|
|
+ for (int i=0; i<itemCount(); ++i)
|
|
|
+ {
|
|
|
+ if (QCPAbstractLegendItem *ali = item(i))
|
|
|
+ {
|
|
|
+ if (ali->selected())
|
|
|
+ result.append(ali);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ A convenience function to easily set the QPainter::Antialiased hint on the provided \a painter
|
|
|
+ before drawing main legend elements.
|
|
|
+
|
|
|
+ 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.
|
|
|
+
|
|
|
+ \seebaseclassmethod
|
|
|
+
|
|
|
+ \see setAntialiased
|
|
|
+*/
|
|
|
+void QCPLegend::applyDefaultAntialiasingHint(QCPPainter *painter) const
|
|
|
+{
|
|
|
+ applyAntialiasingHint(painter, mAntialiased, QCP::aeLegend);
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the pen used to paint the border of the legend, taking into account the selection state
|
|
|
+ of the legend box.
|
|
|
+*/
|
|
|
+QPen QCPLegend::getBorderPen() const
|
|
|
+{
|
|
|
+ return mSelectedParts.testFlag(spLegendBox) ? mSelectedBorderPen : mBorderPen;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the brush used to paint the background of the legend, taking into account the selection
|
|
|
+ state of the legend box.
|
|
|
+*/
|
|
|
+QBrush QCPLegend::getBrush() const
|
|
|
+{
|
|
|
+ return mSelectedParts.testFlag(spLegendBox) ? mSelectedBrush : mBrush;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Draws the legend box with the provided \a painter. The individual legend items are layerables
|
|
|
+ themselves, thus are drawn independently.
|
|
|
+*/
|
|
|
+void QCPLegend::draw(QCPPainter *painter)
|
|
|
+{
|
|
|
+ // draw background rect:
|
|
|
+ painter->setBrush(getBrush());
|
|
|
+ painter->setPen(getBorderPen());
|
|
|
+ painter->drawRect(mOuterRect);
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+double QCPLegend::selectTest(const QPointF &pos, bool onlySelectable, QVariant *details) const
|
|
|
+{
|
|
|
+ if (!mParentPlot) return -1;
|
|
|
+ if (onlySelectable && !mSelectableParts.testFlag(spLegendBox))
|
|
|
+ return -1;
|
|
|
+
|
|
|
+ if (mOuterRect.contains(pos.toPoint()))
|
|
|
+ {
|
|
|
+ if (details) details->setValue(spLegendBox);
|
|
|
+ return mParentPlot->selectionTolerance()*0.99;
|
|
|
+ }
|
|
|
+ return -1;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPLegend::selectEvent(QMouseEvent *event, bool additive, const QVariant &details, bool *selectionStateChanged)
|
|
|
+{
|
|
|
+ Q_UNUSED(event)
|
|
|
+ mSelectedParts = selectedParts(); // in case item selection has changed
|
|
|
+ if (details.value<SelectablePart>() == spLegendBox && mSelectableParts.testFlag(spLegendBox))
|
|
|
+ {
|
|
|
+ SelectableParts selBefore = mSelectedParts;
|
|
|
+ setSelectedParts(additive ? mSelectedParts^spLegendBox : mSelectedParts|spLegendBox); // no need to unset spItems in !additive case, because they will be deselected by QCustomPlot (they're normal QCPLayerables with own deselectEvent)
|
|
|
+ if (selectionStateChanged)
|
|
|
+ *selectionStateChanged = mSelectedParts != selBefore;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPLegend::deselectEvent(bool *selectionStateChanged)
|
|
|
+{
|
|
|
+ mSelectedParts = selectedParts(); // in case item selection has changed
|
|
|
+ if (mSelectableParts.testFlag(spLegendBox))
|
|
|
+ {
|
|
|
+ SelectableParts selBefore = mSelectedParts;
|
|
|
+ setSelectedParts(selectedParts() & ~spLegendBox);
|
|
|
+ if (selectionStateChanged)
|
|
|
+ *selectionStateChanged = mSelectedParts != selBefore;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+QCP::Interaction QCPLegend::selectionCategory() const
|
|
|
+{
|
|
|
+ return QCP::iSelectLegend;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+QCP::Interaction QCPAbstractLegendItem::selectionCategory() const
|
|
|
+{
|
|
|
+ return QCP::iSelectLegend;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPLegend::parentPlotInitialized(QCustomPlot *parentPlot)
|
|
|
+{
|
|
|
+ if (parentPlot && !parentPlot->legend)
|
|
|
+ parentPlot->legend = this;
|
|
|
+}
|
|
|
+/* end of 'src/layoutelements/layoutelement-legend.cpp' */
|
|
|
+
|
|
|
+
|
|
|
+/* including file 'src/layoutelements/layoutelement-textelement.cpp', size 12761 */
|
|
|
+/* commit 9868e55d3b412f2f89766bb482fcf299e93a0988 2017-09-04 01:56:22 +0200 */
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPTextElement
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+/*! \class QCPTextElement
|
|
|
+ \brief A layout element displaying a text
|
|
|
+
|
|
|
+ The text may be specified with \ref setText, the formatting can be controlled with \ref setFont,
|
|
|
+ \ref setTextColor, and \ref setTextFlags.
|
|
|
+
|
|
|
+ A text element can be added as follows:
|
|
|
+ \snippet documentation/doc-code-snippets/mainwindow.cpp qcptextelement-creation
|
|
|
+*/
|
|
|
+
|
|
|
+/* start documentation of signals */
|
|
|
+
|
|
|
+/*! \fn void QCPTextElement::selectionChanged(bool selected)
|
|
|
+
|
|
|
+ This signal is emitted when the selection state has changed to \a selected, either by user
|
|
|
+ interaction or by a direct call to \ref setSelected.
|
|
|
+
|
|
|
+ \see setSelected, setSelectable
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn void QCPTextElement::clicked(QMouseEvent *event)
|
|
|
+
|
|
|
+ This signal is emitted when the text element is clicked.
|
|
|
+
|
|
|
+ \see doubleClicked, selectTest
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn void QCPTextElement::doubleClicked(QMouseEvent *event)
|
|
|
+
|
|
|
+ This signal is emitted when the text element is double clicked.
|
|
|
+
|
|
|
+ \see clicked, selectTest
|
|
|
+*/
|
|
|
+
|
|
|
+/* end documentation of signals */
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Creates a new QCPTextElement instance and sets default values. The initial text is empty (\ref
|
|
|
+ setText).
|
|
|
+*/
|
|
|
+QCPTextElement::QCPTextElement(QCustomPlot *parentPlot) :
|
|
|
+ QCPLayoutElement(parentPlot),
|
|
|
+ mText(),
|
|
|
+ mTextFlags(Qt::AlignCenter|Qt::TextWordWrap),
|
|
|
+ mFont(QFont(QLatin1String("sans serif"), 12)), // will be taken from parentPlot if available, see below
|
|
|
+ mTextColor(Qt::black),
|
|
|
+ mSelectedFont(QFont(QLatin1String("sans serif"), 12)), // will be taken from parentPlot if available, see below
|
|
|
+ mSelectedTextColor(Qt::blue),
|
|
|
+ mSelectable(false),
|
|
|
+ mSelected(false)
|
|
|
+{
|
|
|
+ if (parentPlot)
|
|
|
+ {
|
|
|
+ mFont = parentPlot->font();
|
|
|
+ mSelectedFont = parentPlot->font();
|
|
|
+ }
|
|
|
+ setMargins(QMargins(2, 2, 2, 2));
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Creates a new QCPTextElement instance and sets default values.
|
|
|
+
|
|
|
+ The initial text is set to \a text.
|
|
|
+*/
|
|
|
+QCPTextElement::QCPTextElement(QCustomPlot *parentPlot, const QString &text) :
|
|
|
+ QCPLayoutElement(parentPlot),
|
|
|
+ mText(text),
|
|
|
+ mTextFlags(Qt::AlignCenter|Qt::TextWordWrap),
|
|
|
+ mFont(QFont(QLatin1String("sans serif"), 12)), // will be taken from parentPlot if available, see below
|
|
|
+ mTextColor(Qt::black),
|
|
|
+ mSelectedFont(QFont(QLatin1String("sans serif"), 12)), // will be taken from parentPlot if available, see below
|
|
|
+ mSelectedTextColor(Qt::blue),
|
|
|
+ mSelectable(false),
|
|
|
+ mSelected(false)
|
|
|
+{
|
|
|
+ if (parentPlot)
|
|
|
+ {
|
|
|
+ mFont = parentPlot->font();
|
|
|
+ mSelectedFont = parentPlot->font();
|
|
|
+ }
|
|
|
+ setMargins(QMargins(2, 2, 2, 2));
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Creates a new QCPTextElement instance and sets default values.
|
|
|
+
|
|
|
+ The initial text is set to \a text with \a pointSize.
|
|
|
+*/
|
|
|
+QCPTextElement::QCPTextElement(QCustomPlot *parentPlot, const QString &text, double pointSize) :
|
|
|
+ QCPLayoutElement(parentPlot),
|
|
|
+ mText(text),
|
|
|
+ mTextFlags(Qt::AlignCenter|Qt::TextWordWrap),
|
|
|
+ mFont(QFont(QLatin1String("sans serif"), pointSize)), // will be taken from parentPlot if available, see below
|
|
|
+ mTextColor(Qt::black),
|
|
|
+ mSelectedFont(QFont(QLatin1String("sans serif"), pointSize)), // will be taken from parentPlot if available, see below
|
|
|
+ mSelectedTextColor(Qt::blue),
|
|
|
+ mSelectable(false),
|
|
|
+ mSelected(false)
|
|
|
+{
|
|
|
+ if (parentPlot)
|
|
|
+ {
|
|
|
+ mFont = parentPlot->font();
|
|
|
+ mFont.setPointSizeF(pointSize);
|
|
|
+ mSelectedFont = parentPlot->font();
|
|
|
+ mSelectedFont.setPointSizeF(pointSize);
|
|
|
+ }
|
|
|
+ setMargins(QMargins(2, 2, 2, 2));
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Creates a new QCPTextElement instance and sets default values.
|
|
|
+
|
|
|
+ The initial text is set to \a text with \a pointSize and the specified \a fontFamily.
|
|
|
+*/
|
|
|
+QCPTextElement::QCPTextElement(QCustomPlot *parentPlot, const QString &text, const QString &fontFamily, double pointSize) :
|
|
|
+ QCPLayoutElement(parentPlot),
|
|
|
+ mText(text),
|
|
|
+ mTextFlags(Qt::AlignCenter|Qt::TextWordWrap),
|
|
|
+ mFont(QFont(fontFamily, pointSize)),
|
|
|
+ mTextColor(Qt::black),
|
|
|
+ mSelectedFont(QFont(fontFamily, pointSize)),
|
|
|
+ mSelectedTextColor(Qt::blue),
|
|
|
+ mSelectable(false),
|
|
|
+ mSelected(false)
|
|
|
+{
|
|
|
+ setMargins(QMargins(2, 2, 2, 2));
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Creates a new QCPTextElement instance and sets default values.
|
|
|
+
|
|
|
+ The initial text is set to \a text with the specified \a font.
|
|
|
+*/
|
|
|
+QCPTextElement::QCPTextElement(QCustomPlot *parentPlot, const QString &text, const QFont &font) :
|
|
|
+ QCPLayoutElement(parentPlot),
|
|
|
+ mText(text),
|
|
|
+ mTextFlags(Qt::AlignCenter|Qt::TextWordWrap),
|
|
|
+ mFont(font),
|
|
|
+ mTextColor(Qt::black),
|
|
|
+ mSelectedFont(font),
|
|
|
+ mSelectedTextColor(Qt::blue),
|
|
|
+ mSelectable(false),
|
|
|
+ mSelected(false)
|
|
|
+{
|
|
|
+ setMargins(QMargins(2, 2, 2, 2));
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the text that will be displayed to \a text. Multiple lines can be created by insertion of "\n".
|
|
|
+
|
|
|
+ \see setFont, setTextColor, setTextFlags
|
|
|
+*/
|
|
|
+void QCPTextElement::setText(const QString &text)
|
|
|
+{
|
|
|
+ mText = text;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets options for text alignment and wrapping behaviour. \a flags is a bitwise OR-combination of
|
|
|
+ \c Qt::AlignmentFlag and \c Qt::TextFlag enums.
|
|
|
+
|
|
|
+ Possible enums are:
|
|
|
+ - Qt::AlignLeft
|
|
|
+ - Qt::AlignRight
|
|
|
+ - Qt::AlignHCenter
|
|
|
+ - Qt::AlignJustify
|
|
|
+ - Qt::AlignTop
|
|
|
+ - Qt::AlignBottom
|
|
|
+ - Qt::AlignVCenter
|
|
|
+ - Qt::AlignCenter
|
|
|
+ - Qt::TextDontClip
|
|
|
+ - Qt::TextSingleLine
|
|
|
+ - Qt::TextExpandTabs
|
|
|
+ - Qt::TextShowMnemonic
|
|
|
+ - Qt::TextWordWrap
|
|
|
+ - Qt::TextIncludeTrailingSpaces
|
|
|
+*/
|
|
|
+void QCPTextElement::setTextFlags(int flags)
|
|
|
+{
|
|
|
+ mTextFlags = flags;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the \a font of the text.
|
|
|
+
|
|
|
+ \see setTextColor, setSelectedFont
|
|
|
+*/
|
|
|
+void QCPTextElement::setFont(const QFont &font)
|
|
|
+{
|
|
|
+ mFont = font;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the \a color of the text.
|
|
|
+
|
|
|
+ \see setFont, setSelectedTextColor
|
|
|
+*/
|
|
|
+void QCPTextElement::setTextColor(const QColor &color)
|
|
|
+{
|
|
|
+ mTextColor = color;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the \a font of the text that will be used if the text element is selected (\ref setSelected).
|
|
|
+
|
|
|
+ \see setFont
|
|
|
+*/
|
|
|
+void QCPTextElement::setSelectedFont(const QFont &font)
|
|
|
+{
|
|
|
+ mSelectedFont = font;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the \a color of the text that will be used if the text element is selected (\ref setSelected).
|
|
|
+
|
|
|
+ \see setTextColor
|
|
|
+*/
|
|
|
+void QCPTextElement::setSelectedTextColor(const QColor &color)
|
|
|
+{
|
|
|
+ mSelectedTextColor = color;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets whether the user may select this text element.
|
|
|
+
|
|
|
+ Note that even when \a selectable is set to <tt>false</tt>, the selection state may be changed
|
|
|
+ programmatically via \ref setSelected.
|
|
|
+*/
|
|
|
+void QCPTextElement::setSelectable(bool selectable)
|
|
|
+{
|
|
|
+ if (mSelectable != selectable)
|
|
|
+ {
|
|
|
+ mSelectable = selectable;
|
|
|
+ emit selectableChanged(mSelectable);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the selection state of this text element to \a selected. If the selection has changed, \ref
|
|
|
+ selectionChanged is emitted.
|
|
|
+
|
|
|
+ Note that this function can change the selection state independently of the current \ref
|
|
|
+ setSelectable state.
|
|
|
+*/
|
|
|
+void QCPTextElement::setSelected(bool selected)
|
|
|
+{
|
|
|
+ if (mSelected != selected)
|
|
|
+ {
|
|
|
+ mSelected = selected;
|
|
|
+ emit selectionChanged(mSelected);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPTextElement::applyDefaultAntialiasingHint(QCPPainter *painter) const
|
|
|
+{
|
|
|
+ applyAntialiasingHint(painter, mAntialiased, QCP::aeOther);
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPTextElement::draw(QCPPainter *painter)
|
|
|
+{
|
|
|
+ painter->setFont(mainFont());
|
|
|
+ painter->setPen(QPen(mainTextColor()));
|
|
|
+ painter->drawText(mRect, Qt::AlignCenter, mText, &mTextBoundingRect);
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+QSize QCPTextElement::minimumOuterSizeHint() const
|
|
|
+{
|
|
|
+ QFontMetrics metrics(mFont);
|
|
|
+ QSize result(metrics.boundingRect(0, 0, 0, 0, Qt::AlignCenter, mText).size());
|
|
|
+ result.rwidth() += mMargins.left()+mMargins.right();
|
|
|
+ result.rheight() += mMargins.top()+mMargins.bottom();
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+QSize QCPTextElement::maximumOuterSizeHint() const
|
|
|
+{
|
|
|
+ QFontMetrics metrics(mFont);
|
|
|
+ QSize result(metrics.boundingRect(0, 0, 0, 0, Qt::AlignCenter, mText).size());
|
|
|
+ result.setWidth(QWIDGETSIZE_MAX);
|
|
|
+ result.rheight() += mMargins.top()+mMargins.bottom();
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPTextElement::selectEvent(QMouseEvent *event, bool additive, const QVariant &details, bool *selectionStateChanged)
|
|
|
+{
|
|
|
+ Q_UNUSED(event)
|
|
|
+ Q_UNUSED(details)
|
|
|
+ if (mSelectable)
|
|
|
+ {
|
|
|
+ bool selBefore = mSelected;
|
|
|
+ setSelected(additive ? !mSelected : true);
|
|
|
+ if (selectionStateChanged)
|
|
|
+ *selectionStateChanged = mSelected != selBefore;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPTextElement::deselectEvent(bool *selectionStateChanged)
|
|
|
+{
|
|
|
+ if (mSelectable)
|
|
|
+ {
|
|
|
+ bool selBefore = mSelected;
|
|
|
+ setSelected(false);
|
|
|
+ if (selectionStateChanged)
|
|
|
+ *selectionStateChanged = mSelected != selBefore;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns 0.99*selectionTolerance (see \ref QCustomPlot::setSelectionTolerance) when \a pos is
|
|
|
+ within the bounding box of the text element's text. Note that this bounding box is updated in the
|
|
|
+ draw call.
|
|
|
+
|
|
|
+ If \a pos is outside the text's bounding box or if \a onlySelectable is true and this text
|
|
|
+ element is not selectable (\ref setSelectable), returns -1.
|
|
|
+
|
|
|
+ \seebaseclassmethod
|
|
|
+*/
|
|
|
+double QCPTextElement::selectTest(const QPointF &pos, bool onlySelectable, QVariant *details) const
|
|
|
+{
|
|
|
+ Q_UNUSED(details)
|
|
|
+ if (onlySelectable && !mSelectable)
|
|
|
+ return -1;
|
|
|
+
|
|
|
+ if (mTextBoundingRect.contains(pos.toPoint()))
|
|
|
+ return mParentPlot->selectionTolerance()*0.99;
|
|
|
+ else
|
|
|
+ return -1;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Accepts the mouse event in order to emit the according click signal in the \ref
|
|
|
+ mouseReleaseEvent.
|
|
|
+
|
|
|
+ \seebaseclassmethod
|
|
|
+*/
|
|
|
+void QCPTextElement::mousePressEvent(QMouseEvent *event, const QVariant &details)
|
|
|
+{
|
|
|
+ Q_UNUSED(details)
|
|
|
+ event->accept();
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Emits the \ref clicked signal if the cursor hasn't moved by more than a few pixels since the \ref
|
|
|
+ mousePressEvent.
|
|
|
+
|
|
|
+ \seebaseclassmethod
|
|
|
+*/
|
|
|
+void QCPTextElement::mouseReleaseEvent(QMouseEvent *event, const QPointF &startPos)
|
|
|
+{
|
|
|
+ if ((QPointF(event->pos())-startPos).manhattanLength() <= 3)
|
|
|
+ emit clicked(event);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Emits the \ref doubleClicked signal.
|
|
|
+
|
|
|
+ \seebaseclassmethod
|
|
|
+*/
|
|
|
+void QCPTextElement::mouseDoubleClickEvent(QMouseEvent *event, const QVariant &details)
|
|
|
+{
|
|
|
+ Q_UNUSED(details)
|
|
|
+ emit doubleClicked(event);
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the main font to be used. This is mSelectedFont if \ref setSelected is set to
|
|
|
+ <tt>true</tt>, else mFont is returned.
|
|
|
+*/
|
|
|
+QFont QCPTextElement::mainFont() const
|
|
|
+{
|
|
|
+ return mSelected ? mSelectedFont : mFont;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the main color to be used. This is mSelectedTextColor if \ref setSelected is set to
|
|
|
+ <tt>true</tt>, else mTextColor is returned.
|
|
|
+*/
|
|
|
+QColor QCPTextElement::mainTextColor() const
|
|
|
+{
|
|
|
+ return mSelected ? mSelectedTextColor : mTextColor;
|
|
|
+}
|
|
|
+/* end of 'src/layoutelements/layoutelement-textelement.cpp' */
|
|
|
+
|
|
|
+
|
|
|
+/* including file 'src/layoutelements/layoutelement-colorscale.cpp', size 25770 */
|
|
|
+/* commit 9868e55d3b412f2f89766bb482fcf299e93a0988 2017-09-04 01:56:22 +0200 */
|
|
|
+
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPColorScale
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+/*! \class QCPColorScale
|
|
|
+ \brief A color scale for use with color coding data such as QCPColorMap
|
|
|
+
|
|
|
+ This layout element can be placed on the plot to correlate a color gradient with data values. It
|
|
|
+ is usually used in combination with one or multiple \ref QCPColorMap "QCPColorMaps".
|
|
|
+
|
|
|
+ \image html QCPColorScale.png
|
|
|
+
|
|
|
+ The color scale can be either horizontal or vertical, as shown in the image above. The
|
|
|
+ orientation and the side where the numbers appear is controlled with \ref setType.
|
|
|
+
|
|
|
+ Use \ref QCPColorMap::setColorScale to connect a color map with a color scale. Once they are
|
|
|
+ connected, they share their gradient, data range and data scale type (\ref setGradient, \ref
|
|
|
+ setDataRange, \ref setDataScaleType). Multiple color maps may be associated with a single color
|
|
|
+ scale, to make them all synchronize these properties.
|
|
|
+
|
|
|
+ To have finer control over the number display and axis behaviour, you can directly access the
|
|
|
+ \ref axis. See the documentation of QCPAxis for details about configuring axes. For example, if
|
|
|
+ you want to change the number of automatically generated ticks, call
|
|
|
+ \snippet documentation/doc-code-snippets/mainwindow.cpp qcpcolorscale-tickcount
|
|
|
+
|
|
|
+ Placing a color scale next to the main axis rect works like with any other layout element:
|
|
|
+ \snippet documentation/doc-code-snippets/mainwindow.cpp qcpcolorscale-creation
|
|
|
+ In this case we have placed it to the right of the default axis rect, so it wasn't necessary to
|
|
|
+ call \ref setType, since \ref QCPAxis::atRight is already the default. The text next to the color
|
|
|
+ scale can be set with \ref setLabel.
|
|
|
+
|
|
|
+ For optimum appearance (like in the image above), it may be desirable to line up the axis rect and
|
|
|
+ the borders of the color scale. Use a \ref QCPMarginGroup to achieve this:
|
|
|
+ \snippet documentation/doc-code-snippets/mainwindow.cpp qcpcolorscale-margingroup
|
|
|
+
|
|
|
+ Color scales are initialized with a non-zero minimum top and bottom margin (\ref
|
|
|
+ setMinimumMargins), because vertical color scales are most common and the minimum top/bottom
|
|
|
+ margin makes sure it keeps some distance to the top/bottom widget border. So if you change to a
|
|
|
+ horizontal color scale by setting \ref setType to \ref QCPAxis::atBottom or \ref QCPAxis::atTop, you
|
|
|
+ might want to also change the minimum margins accordingly, e.g. <tt>setMinimumMargins(QMargins(6, 0, 6, 0))</tt>.
|
|
|
+*/
|
|
|
+
|
|
|
+/* start documentation of inline functions */
|
|
|
+
|
|
|
+/*! \fn QCPAxis *QCPColorScale::axis() const
|
|
|
+
|
|
|
+ Returns the internal \ref QCPAxis instance of this color scale. You can access it to alter the
|
|
|
+ appearance and behaviour of the axis. \ref QCPColorScale duplicates some properties in its
|
|
|
+ interface for convenience. Those are \ref setDataRange (\ref QCPAxis::setRange), \ref
|
|
|
+ setDataScaleType (\ref QCPAxis::setScaleType), and the method \ref setLabel (\ref
|
|
|
+ QCPAxis::setLabel). As they each are connected, it does not matter whether you use the method on
|
|
|
+ the QCPColorScale or on its QCPAxis.
|
|
|
+
|
|
|
+ If the type of the color scale is changed with \ref setType, the axis returned by this method
|
|
|
+ will change, too, to either the left, right, bottom or top axis, depending on which type was set.
|
|
|
+*/
|
|
|
+
|
|
|
+/* end documentation of signals */
|
|
|
+/* start documentation of signals */
|
|
|
+
|
|
|
+/*! \fn void QCPColorScale::dataRangeChanged(const QCPRange &newRange);
|
|
|
+
|
|
|
+ This signal is emitted when the data range changes.
|
|
|
+
|
|
|
+ \see setDataRange
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn void QCPColorScale::dataScaleTypeChanged(QCPAxis::ScaleType scaleType);
|
|
|
+
|
|
|
+ This signal is emitted when the data scale type changes.
|
|
|
+
|
|
|
+ \see setDataScaleType
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn void QCPColorScale::gradientChanged(const QCPColorGradient &newGradient);
|
|
|
+
|
|
|
+ This signal is emitted when the gradient changes.
|
|
|
+
|
|
|
+ \see setGradient
|
|
|
+*/
|
|
|
+
|
|
|
+/* end documentation of signals */
|
|
|
+
|
|
|
+/*!
|
|
|
+ Constructs a new QCPColorScale.
|
|
|
+*/
|
|
|
+QCPColorScale::QCPColorScale(QCustomPlot *parentPlot) :
|
|
|
+ QCPLayoutElement(parentPlot),
|
|
|
+ mType(QCPAxis::atTop), // set to atTop such that setType(QCPAxis::atRight) below doesn't skip work because it thinks it's already atRight
|
|
|
+ mDataScaleType(QCPAxis::stLinear),
|
|
|
+ mBarWidth(20),
|
|
|
+ mAxisRect(new QCPColorScaleAxisRectPrivate(this))
|
|
|
+{
|
|
|
+ setMinimumMargins(QMargins(0, 6, 0, 6)); // for default right color scale types, keep some room at bottom and top (important if no margin group is used)
|
|
|
+ setType(QCPAxis::atRight);
|
|
|
+ setDataRange(QCPRange(0, 6));
|
|
|
+}
|
|
|
+
|
|
|
+QCPColorScale::~QCPColorScale()
|
|
|
+{
|
|
|
+ delete mAxisRect;
|
|
|
+}
|
|
|
+
|
|
|
+/* undocumented getter */
|
|
|
+QString QCPColorScale::label() const
|
|
|
+{
|
|
|
+ if (!mColorAxis)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "internal color axis undefined";
|
|
|
+ return QString();
|
|
|
+ }
|
|
|
+
|
|
|
+ return mColorAxis.data()->label();
|
|
|
+}
|
|
|
+
|
|
|
+/* undocumented getter */
|
|
|
+bool QCPColorScale::rangeDrag() const
|
|
|
+{
|
|
|
+ if (!mAxisRect)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "internal axis rect was deleted";
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ return mAxisRect.data()->rangeDrag().testFlag(QCPAxis::orientation(mType)) &&
|
|
|
+ mAxisRect.data()->rangeDragAxis(QCPAxis::orientation(mType)) &&
|
|
|
+ mAxisRect.data()->rangeDragAxis(QCPAxis::orientation(mType))->orientation() == QCPAxis::orientation(mType);
|
|
|
+}
|
|
|
+
|
|
|
+/* undocumented getter */
|
|
|
+bool QCPColorScale::rangeZoom() const
|
|
|
+{
|
|
|
+ if (!mAxisRect)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "internal axis rect was deleted";
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ return mAxisRect.data()->rangeZoom().testFlag(QCPAxis::orientation(mType)) &&
|
|
|
+ mAxisRect.data()->rangeZoomAxis(QCPAxis::orientation(mType)) &&
|
|
|
+ mAxisRect.data()->rangeZoomAxis(QCPAxis::orientation(mType))->orientation() == QCPAxis::orientation(mType);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets at which side of the color scale the axis is placed, and thus also its orientation.
|
|
|
+
|
|
|
+ Note that after setting \a type to a different value, the axis returned by \ref axis() will
|
|
|
+ be a different one. The new axis will adopt the following properties from the previous axis: The
|
|
|
+ range, scale type, label and ticker (the latter will be shared and not copied).
|
|
|
+*/
|
|
|
+void QCPColorScale::setType(QCPAxis::AxisType type)
|
|
|
+{
|
|
|
+ if (!mAxisRect)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "internal axis rect was deleted";
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ if (mType != type)
|
|
|
+ {
|
|
|
+ mType = type;
|
|
|
+ QCPRange rangeTransfer(0, 6);
|
|
|
+ QString labelTransfer;
|
|
|
+ QSharedPointer<QCPAxisTicker> tickerTransfer;
|
|
|
+ // transfer/revert some settings on old axis if it exists:
|
|
|
+ bool doTransfer = (bool)mColorAxis;
|
|
|
+ if (doTransfer)
|
|
|
+ {
|
|
|
+ rangeTransfer = mColorAxis.data()->range();
|
|
|
+ labelTransfer = mColorAxis.data()->label();
|
|
|
+ tickerTransfer = mColorAxis.data()->ticker();
|
|
|
+ mColorAxis.data()->setLabel(QString());
|
|
|
+ disconnect(mColorAxis.data(), SIGNAL(rangeChanged(QCPRange)), this, SLOT(setDataRange(QCPRange)));
|
|
|
+ disconnect(mColorAxis.data(), SIGNAL(scaleTypeChanged(QCPAxis::ScaleType)), this, SLOT(setDataScaleType(QCPAxis::ScaleType)));
|
|
|
+ }
|
|
|
+ QList<QCPAxis::AxisType> allAxisTypes = QList<QCPAxis::AxisType>() << QCPAxis::atLeft << QCPAxis::atRight << QCPAxis::atBottom << QCPAxis::atTop;
|
|
|
+ foreach (QCPAxis::AxisType atype, allAxisTypes)
|
|
|
+ {
|
|
|
+ mAxisRect.data()->axis(atype)->setTicks(atype == mType);
|
|
|
+ mAxisRect.data()->axis(atype)->setTickLabels(atype== mType);
|
|
|
+ }
|
|
|
+ // set new mColorAxis pointer:
|
|
|
+ mColorAxis = mAxisRect.data()->axis(mType);
|
|
|
+ // transfer settings to new axis:
|
|
|
+ if (doTransfer)
|
|
|
+ {
|
|
|
+ mColorAxis.data()->setRange(rangeTransfer); // range transfer necessary if axis changes from vertical to horizontal or vice versa (axes with same orientation are synchronized via signals)
|
|
|
+ mColorAxis.data()->setLabel(labelTransfer);
|
|
|
+ mColorAxis.data()->setTicker(tickerTransfer);
|
|
|
+ }
|
|
|
+ connect(mColorAxis.data(), SIGNAL(rangeChanged(QCPRange)), this, SLOT(setDataRange(QCPRange)));
|
|
|
+ connect(mColorAxis.data(), SIGNAL(scaleTypeChanged(QCPAxis::ScaleType)), this, SLOT(setDataScaleType(QCPAxis::ScaleType)));
|
|
|
+ mAxisRect.data()->setRangeDragAxes(QList<QCPAxis*>() << mColorAxis.data());
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the range spanned by the color gradient and that is shown by the axis in the color scale.
|
|
|
+
|
|
|
+ It is equivalent to calling QCPColorMap::setDataRange on any of the connected color maps. It is
|
|
|
+ also equivalent to directly accessing the \ref axis and setting its range with \ref
|
|
|
+ QCPAxis::setRange.
|
|
|
+
|
|
|
+ \see setDataScaleType, setGradient, rescaleDataRange
|
|
|
+*/
|
|
|
+void QCPColorScale::setDataRange(const QCPRange &dataRange)
|
|
|
+{
|
|
|
+ if (mDataRange.lower != dataRange.lower || mDataRange.upper != dataRange.upper)
|
|
|
+ {
|
|
|
+ mDataRange = dataRange;
|
|
|
+ if (mColorAxis)
|
|
|
+ mColorAxis.data()->setRange(mDataRange);
|
|
|
+ emit dataRangeChanged(mDataRange);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the scale type of the color scale, i.e. whether values are linearly associated with colors
|
|
|
+ or logarithmically.
|
|
|
+
|
|
|
+ It is equivalent to calling QCPColorMap::setDataScaleType on any of the connected color maps. It is
|
|
|
+ also equivalent to directly accessing the \ref axis and setting its scale type with \ref
|
|
|
+ QCPAxis::setScaleType.
|
|
|
+
|
|
|
+ \see setDataRange, setGradient
|
|
|
+*/
|
|
|
+void QCPColorScale::setDataScaleType(QCPAxis::ScaleType scaleType)
|
|
|
+{
|
|
|
+ if (mDataScaleType != scaleType)
|
|
|
+ {
|
|
|
+ mDataScaleType = scaleType;
|
|
|
+ if (mColorAxis)
|
|
|
+ mColorAxis.data()->setScaleType(mDataScaleType);
|
|
|
+ if (mDataScaleType == QCPAxis::stLogarithmic)
|
|
|
+ setDataRange(mDataRange.sanitizedForLogScale());
|
|
|
+ emit dataScaleTypeChanged(mDataScaleType);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the color gradient that will be used to represent data values.
|
|
|
+
|
|
|
+ It is equivalent to calling QCPColorMap::setGradient on any of the connected color maps.
|
|
|
+
|
|
|
+ \see setDataRange, setDataScaleType
|
|
|
+*/
|
|
|
+void QCPColorScale::setGradient(const QCPColorGradient &gradient)
|
|
|
+{
|
|
|
+ if (mGradient != gradient)
|
|
|
+ {
|
|
|
+ mGradient = gradient;
|
|
|
+ if (mAxisRect)
|
|
|
+ mAxisRect.data()->mGradientImageInvalidated = true;
|
|
|
+ emit gradientChanged(mGradient);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the axis label of the color scale. This is equivalent to calling \ref QCPAxis::setLabel on
|
|
|
+ the internal \ref axis.
|
|
|
+*/
|
|
|
+void QCPColorScale::setLabel(const QString &str)
|
|
|
+{
|
|
|
+ if (!mColorAxis)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "internal color axis undefined";
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ mColorAxis.data()->setLabel(str);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the width (or height, for horizontal color scales) the bar where the gradient is displayed
|
|
|
+ will have.
|
|
|
+*/
|
|
|
+void QCPColorScale::setBarWidth(int width)
|
|
|
+{
|
|
|
+ mBarWidth = width;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets whether the user can drag the data range (\ref setDataRange).
|
|
|
+
|
|
|
+ Note that \ref QCP::iRangeDrag must be in the QCustomPlot's interactions (\ref
|
|
|
+ QCustomPlot::setInteractions) to allow range dragging.
|
|
|
+*/
|
|
|
+void QCPColorScale::setRangeDrag(bool enabled)
|
|
|
+{
|
|
|
+ if (!mAxisRect)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "internal axis rect was deleted";
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (enabled)
|
|
|
+ mAxisRect.data()->setRangeDrag(QCPAxis::orientation(mType));
|
|
|
+ else
|
|
|
+ mAxisRect.data()->setRangeDrag(0);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets whether the user can zoom the data range (\ref setDataRange) by scrolling the mouse wheel.
|
|
|
+
|
|
|
+ Note that \ref QCP::iRangeZoom must be in the QCustomPlot's interactions (\ref
|
|
|
+ QCustomPlot::setInteractions) to allow range dragging.
|
|
|
+*/
|
|
|
+void QCPColorScale::setRangeZoom(bool enabled)
|
|
|
+{
|
|
|
+ if (!mAxisRect)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "internal axis rect was deleted";
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (enabled)
|
|
|
+ mAxisRect.data()->setRangeZoom(QCPAxis::orientation(mType));
|
|
|
+ else
|
|
|
+ mAxisRect.data()->setRangeZoom(0);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns a list of all the color maps associated with this color scale.
|
|
|
+*/
|
|
|
+QList<QCPColorMap*> QCPColorScale::colorMaps() const
|
|
|
+{
|
|
|
+ QList<QCPColorMap*> result;
|
|
|
+ for (int i=0; i<mParentPlot->plottableCount(); ++i)
|
|
|
+ {
|
|
|
+ if (QCPColorMap *cm = qobject_cast<QCPColorMap*>(mParentPlot->plottable(i)))
|
|
|
+ if (cm->colorScale() == this)
|
|
|
+ result.append(cm);
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Changes the data range such that all color maps associated with this color scale are fully mapped
|
|
|
+ to the gradient in the data dimension.
|
|
|
+
|
|
|
+ \see setDataRange
|
|
|
+*/
|
|
|
+void QCPColorScale::rescaleDataRange(bool onlyVisibleMaps)
|
|
|
+{
|
|
|
+ QList<QCPColorMap*> maps = colorMaps();
|
|
|
+ QCPRange newRange;
|
|
|
+ bool haveRange = false;
|
|
|
+ QCP::SignDomain sign = QCP::sdBoth;
|
|
|
+ if (mDataScaleType == QCPAxis::stLogarithmic)
|
|
|
+ sign = (mDataRange.upper < 0 ? QCP::sdNegative : QCP::sdPositive);
|
|
|
+ for (int i=0; i<maps.size(); ++i)
|
|
|
+ {
|
|
|
+ if (!maps.at(i)->realVisibility() && onlyVisibleMaps)
|
|
|
+ continue;
|
|
|
+ QCPRange mapRange;
|
|
|
+ if (maps.at(i)->colorScale() == this)
|
|
|
+ {
|
|
|
+ bool currentFoundRange = true;
|
|
|
+ mapRange = maps.at(i)->data()->dataBounds();
|
|
|
+ if (sign == QCP::sdPositive)
|
|
|
+ {
|
|
|
+ if (mapRange.lower <= 0 && mapRange.upper > 0)
|
|
|
+ mapRange.lower = mapRange.upper*1e-3;
|
|
|
+ else if (mapRange.lower <= 0 && mapRange.upper <= 0)
|
|
|
+ currentFoundRange = false;
|
|
|
+ } else if (sign == QCP::sdNegative)
|
|
|
+ {
|
|
|
+ if (mapRange.upper >= 0 && mapRange.lower < 0)
|
|
|
+ mapRange.upper = mapRange.lower*1e-3;
|
|
|
+ else if (mapRange.upper >= 0 && mapRange.lower >= 0)
|
|
|
+ currentFoundRange = false;
|
|
|
+ }
|
|
|
+ if (currentFoundRange)
|
|
|
+ {
|
|
|
+ if (!haveRange)
|
|
|
+ newRange = mapRange;
|
|
|
+ else
|
|
|
+ newRange.expand(mapRange);
|
|
|
+ haveRange = true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (haveRange)
|
|
|
+ {
|
|
|
+ if (!QCPRange::validRange(newRange)) // likely due to range being zero (plottable has only constant data in this dimension), shift current range to at least center the data
|
|
|
+ {
|
|
|
+ double center = (newRange.lower+newRange.upper)*0.5; // upper and lower should be equal anyway, but just to make sure, incase validRange returned false for other reason
|
|
|
+ if (mDataScaleType == QCPAxis::stLinear)
|
|
|
+ {
|
|
|
+ newRange.lower = center-mDataRange.size()/2.0;
|
|
|
+ newRange.upper = center+mDataRange.size()/2.0;
|
|
|
+ } else // mScaleType == stLogarithmic
|
|
|
+ {
|
|
|
+ newRange.lower = center/qSqrt(mDataRange.upper/mDataRange.lower);
|
|
|
+ newRange.upper = center*qSqrt(mDataRange.upper/mDataRange.lower);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ setDataRange(newRange);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPColorScale::update(UpdatePhase phase)
|
|
|
+{
|
|
|
+ QCPLayoutElement::update(phase);
|
|
|
+ if (!mAxisRect)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "internal axis rect was deleted";
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ mAxisRect.data()->update(phase);
|
|
|
+
|
|
|
+ switch (phase)
|
|
|
+ {
|
|
|
+ case upMargins:
|
|
|
+ {
|
|
|
+ if (mType == QCPAxis::atBottom || mType == QCPAxis::atTop)
|
|
|
+ {
|
|
|
+ setMaximumSize(QWIDGETSIZE_MAX, mBarWidth+mAxisRect.data()->margins().top()+mAxisRect.data()->margins().bottom());
|
|
|
+ setMinimumSize(0, mBarWidth+mAxisRect.data()->margins().top()+mAxisRect.data()->margins().bottom());
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ setMaximumSize(mBarWidth+mAxisRect.data()->margins().left()+mAxisRect.data()->margins().right(), QWIDGETSIZE_MAX);
|
|
|
+ setMinimumSize(mBarWidth+mAxisRect.data()->margins().left()+mAxisRect.data()->margins().right(), 0);
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case upLayout:
|
|
|
+ {
|
|
|
+ mAxisRect.data()->setOuterRect(rect());
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ default: break;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPColorScale::applyDefaultAntialiasingHint(QCPPainter *painter) const
|
|
|
+{
|
|
|
+ painter->setAntialiasing(false);
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPColorScale::mousePressEvent(QMouseEvent *event, const QVariant &details)
|
|
|
+{
|
|
|
+ if (!mAxisRect)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "internal axis rect was deleted";
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ mAxisRect.data()->mousePressEvent(event, details);
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPColorScale::mouseMoveEvent(QMouseEvent *event, const QPointF &startPos)
|
|
|
+{
|
|
|
+ if (!mAxisRect)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "internal axis rect was deleted";
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ mAxisRect.data()->mouseMoveEvent(event, startPos);
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPColorScale::mouseReleaseEvent(QMouseEvent *event, const QPointF &startPos)
|
|
|
+{
|
|
|
+ if (!mAxisRect)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "internal axis rect was deleted";
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ mAxisRect.data()->mouseReleaseEvent(event, startPos);
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPColorScale::wheelEvent(QWheelEvent *event)
|
|
|
+{
|
|
|
+ if (!mAxisRect)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "internal axis rect was deleted";
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ mAxisRect.data()->wheelEvent(event);
|
|
|
+}
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPColorScaleAxisRectPrivate
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+/*! \class QCPColorScaleAxisRectPrivate
|
|
|
+
|
|
|
+ \internal
|
|
|
+ \brief An axis rect subclass for use in a QCPColorScale
|
|
|
+
|
|
|
+ This is a private class and not part of the public QCustomPlot interface.
|
|
|
+
|
|
|
+ It provides the axis rect functionality for the QCPColorScale class.
|
|
|
+*/
|
|
|
+
|
|
|
+
|
|
|
+/*!
|
|
|
+ Creates a new instance, as a child of \a parentColorScale.
|
|
|
+*/
|
|
|
+QCPColorScaleAxisRectPrivate::QCPColorScaleAxisRectPrivate(QCPColorScale *parentColorScale) :
|
|
|
+ QCPAxisRect(parentColorScale->parentPlot(), true),
|
|
|
+ mParentColorScale(parentColorScale),
|
|
|
+ mGradientImageInvalidated(true)
|
|
|
+{
|
|
|
+ setParentLayerable(parentColorScale);
|
|
|
+ setMinimumMargins(QMargins(0, 0, 0, 0));
|
|
|
+ QList<QCPAxis::AxisType> allAxisTypes = QList<QCPAxis::AxisType>() << QCPAxis::atBottom << QCPAxis::atTop << QCPAxis::atLeft << QCPAxis::atRight;
|
|
|
+ foreach (QCPAxis::AxisType type, allAxisTypes)
|
|
|
+ {
|
|
|
+ axis(type)->setVisible(true);
|
|
|
+ axis(type)->grid()->setVisible(false);
|
|
|
+ axis(type)->setPadding(0);
|
|
|
+ connect(axis(type), SIGNAL(selectionChanged(QCPAxis::SelectableParts)), this, SLOT(axisSelectionChanged(QCPAxis::SelectableParts)));
|
|
|
+ connect(axis(type), SIGNAL(selectableChanged(QCPAxis::SelectableParts)), this, SLOT(axisSelectableChanged(QCPAxis::SelectableParts)));
|
|
|
+ }
|
|
|
+
|
|
|
+ connect(axis(QCPAxis::atLeft), SIGNAL(rangeChanged(QCPRange)), axis(QCPAxis::atRight), SLOT(setRange(QCPRange)));
|
|
|
+ connect(axis(QCPAxis::atRight), SIGNAL(rangeChanged(QCPRange)), axis(QCPAxis::atLeft), SLOT(setRange(QCPRange)));
|
|
|
+ connect(axis(QCPAxis::atBottom), SIGNAL(rangeChanged(QCPRange)), axis(QCPAxis::atTop), SLOT(setRange(QCPRange)));
|
|
|
+ connect(axis(QCPAxis::atTop), SIGNAL(rangeChanged(QCPRange)), axis(QCPAxis::atBottom), SLOT(setRange(QCPRange)));
|
|
|
+ connect(axis(QCPAxis::atLeft), SIGNAL(scaleTypeChanged(QCPAxis::ScaleType)), axis(QCPAxis::atRight), SLOT(setScaleType(QCPAxis::ScaleType)));
|
|
|
+ connect(axis(QCPAxis::atRight), SIGNAL(scaleTypeChanged(QCPAxis::ScaleType)), axis(QCPAxis::atLeft), SLOT(setScaleType(QCPAxis::ScaleType)));
|
|
|
+ connect(axis(QCPAxis::atBottom), SIGNAL(scaleTypeChanged(QCPAxis::ScaleType)), axis(QCPAxis::atTop), SLOT(setScaleType(QCPAxis::ScaleType)));
|
|
|
+ connect(axis(QCPAxis::atTop), SIGNAL(scaleTypeChanged(QCPAxis::ScaleType)), axis(QCPAxis::atBottom), SLOT(setScaleType(QCPAxis::ScaleType)));
|
|
|
+
|
|
|
+ // make layer transfers of color scale transfer to axis rect and axes
|
|
|
+ // the axes must be set after axis rect, such that they appear above color gradient drawn by axis rect:
|
|
|
+ connect(parentColorScale, SIGNAL(layerChanged(QCPLayer*)), this, SLOT(setLayer(QCPLayer*)));
|
|
|
+ foreach (QCPAxis::AxisType type, allAxisTypes)
|
|
|
+ connect(parentColorScale, SIGNAL(layerChanged(QCPLayer*)), axis(type), SLOT(setLayer(QCPLayer*)));
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Updates the color gradient image if necessary, by calling \ref updateGradientImage, then draws
|
|
|
+ it. Then the axes are drawn by calling the \ref QCPAxisRect::draw base class implementation.
|
|
|
+
|
|
|
+ \seebaseclassmethod
|
|
|
+*/
|
|
|
+void QCPColorScaleAxisRectPrivate::draw(QCPPainter *painter)
|
|
|
+{
|
|
|
+ if (mGradientImageInvalidated)
|
|
|
+ updateGradientImage();
|
|
|
+
|
|
|
+ bool mirrorHorz = false;
|
|
|
+ bool mirrorVert = false;
|
|
|
+ if (mParentColorScale->mColorAxis)
|
|
|
+ {
|
|
|
+ mirrorHorz = mParentColorScale->mColorAxis.data()->rangeReversed() && (mParentColorScale->type() == QCPAxis::atBottom || mParentColorScale->type() == QCPAxis::atTop);
|
|
|
+ mirrorVert = mParentColorScale->mColorAxis.data()->rangeReversed() && (mParentColorScale->type() == QCPAxis::atLeft || mParentColorScale->type() == QCPAxis::atRight);
|
|
|
+ }
|
|
|
+
|
|
|
+ painter->drawImage(rect().adjusted(0, -1, 0, -1), mGradientImage.mirrored(mirrorHorz, mirrorVert));
|
|
|
+ QCPAxisRect::draw(painter);
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Uses the current gradient of the parent \ref QCPColorScale (specified in the constructor) to
|
|
|
+ generate a gradient image. This gradient image will be used in the \ref draw method.
|
|
|
+*/
|
|
|
+void QCPColorScaleAxisRectPrivate::updateGradientImage()
|
|
|
+{
|
|
|
+ if (rect().isEmpty())
|
|
|
+ return;
|
|
|
+
|
|
|
+ const QImage::Format format = QImage::Format_ARGB32_Premultiplied;
|
|
|
+ int n = mParentColorScale->mGradient.levelCount();
|
|
|
+ int w, h;
|
|
|
+ QVector<double> data(n);
|
|
|
+ for (int i=0; i<n; ++i)
|
|
|
+ data[i] = i;
|
|
|
+ if (mParentColorScale->mType == QCPAxis::atBottom || mParentColorScale->mType == QCPAxis::atTop)
|
|
|
+ {
|
|
|
+ w = n;
|
|
|
+ h = rect().height();
|
|
|
+ mGradientImage = QImage(w, h, format);
|
|
|
+ QVector<QRgb*> pixels;
|
|
|
+ for (int y=0; y<h; ++y)
|
|
|
+ pixels.append(reinterpret_cast<QRgb*>(mGradientImage.scanLine(y)));
|
|
|
+ mParentColorScale->mGradient.colorize(data.constData(), QCPRange(0, n-1), pixels.first(), n);
|
|
|
+ for (int y=1; y<h; ++y)
|
|
|
+ memcpy(pixels.at(y), pixels.first(), n*sizeof(QRgb));
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ w = rect().width();
|
|
|
+ h = n;
|
|
|
+ mGradientImage = QImage(w, h, format);
|
|
|
+ for (int y=0; y<h; ++y)
|
|
|
+ {
|
|
|
+ QRgb *pixels = reinterpret_cast<QRgb*>(mGradientImage.scanLine(y));
|
|
|
+ const QRgb lineColor = mParentColorScale->mGradient.color(data[h-1-y], QCPRange(0, n-1));
|
|
|
+ for (int x=0; x<w; ++x)
|
|
|
+ pixels[x] = lineColor;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ mGradientImageInvalidated = false;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ This slot is connected to the selectionChanged signals of the four axes in the constructor. It
|
|
|
+ synchronizes the selection state of the axes.
|
|
|
+*/
|
|
|
+void QCPColorScaleAxisRectPrivate::axisSelectionChanged(QCPAxis::SelectableParts selectedParts)
|
|
|
+{
|
|
|
+ // axis bases of four axes shall always (de-)selected synchronously:
|
|
|
+ QList<QCPAxis::AxisType> allAxisTypes = QList<QCPAxis::AxisType>() << QCPAxis::atBottom << QCPAxis::atTop << QCPAxis::atLeft << QCPAxis::atRight;
|
|
|
+ foreach (QCPAxis::AxisType type, allAxisTypes)
|
|
|
+ {
|
|
|
+ if (QCPAxis *senderAxis = qobject_cast<QCPAxis*>(sender()))
|
|
|
+ if (senderAxis->axisType() == type)
|
|
|
+ continue;
|
|
|
+
|
|
|
+ if (axis(type)->selectableParts().testFlag(QCPAxis::spAxis))
|
|
|
+ {
|
|
|
+ if (selectedParts.testFlag(QCPAxis::spAxis))
|
|
|
+ axis(type)->setSelectedParts(axis(type)->selectedParts() | QCPAxis::spAxis);
|
|
|
+ else
|
|
|
+ axis(type)->setSelectedParts(axis(type)->selectedParts() & ~QCPAxis::spAxis);
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ This slot is connected to the selectableChanged signals of the four axes in the constructor. It
|
|
|
+ synchronizes the selectability of the axes.
|
|
|
+*/
|
|
|
+void QCPColorScaleAxisRectPrivate::axisSelectableChanged(QCPAxis::SelectableParts selectableParts)
|
|
|
+{
|
|
|
+ // synchronize axis base selectability:
|
|
|
+ QList<QCPAxis::AxisType> allAxisTypes = QList<QCPAxis::AxisType>() << QCPAxis::atBottom << QCPAxis::atTop << QCPAxis::atLeft << QCPAxis::atRight;
|
|
|
+ foreach (QCPAxis::AxisType type, allAxisTypes)
|
|
|
+ {
|
|
|
+ if (QCPAxis *senderAxis = qobject_cast<QCPAxis*>(sender()))
|
|
|
+ if (senderAxis->axisType() == type)
|
|
|
+ continue;
|
|
|
+
|
|
|
+ if (axis(type)->selectableParts().testFlag(QCPAxis::spAxis))
|
|
|
+ {
|
|
|
+ if (selectableParts.testFlag(QCPAxis::spAxis))
|
|
|
+ axis(type)->setSelectableParts(axis(type)->selectableParts() | QCPAxis::spAxis);
|
|
|
+ else
|
|
|
+ axis(type)->setSelectableParts(axis(type)->selectableParts() & ~QCPAxis::spAxis);
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+/* end of 'src/layoutelements/layoutelement-colorscale.cpp' */
|
|
|
+
|
|
|
+
|
|
|
+/* including file 'src/plottables/plottable-graph.cpp', size 73960 */
|
|
|
+/* commit 9868e55d3b412f2f89766bb482fcf299e93a0988 2017-09-04 01:56:22 +0200 */
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPGraphData
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+/*! \class QCPGraphData
|
|
|
+ \brief Holds the data of one single data point for QCPGraph.
|
|
|
+
|
|
|
+ The stored data is:
|
|
|
+ \li \a key: coordinate on the key axis of this data point (this is the \a mainKey and the \a sortKey)
|
|
|
+ \li \a value: coordinate on the value axis of this data point (this is the \a mainValue)
|
|
|
+
|
|
|
+ The container for storing multiple data points is \ref QCPGraphDataContainer. It is a typedef for
|
|
|
+ \ref QCPDataContainer with \ref QCPGraphData as the DataType template parameter. See the
|
|
|
+ documentation there for an explanation regarding the data type's generic methods.
|
|
|
+
|
|
|
+ \see QCPGraphDataContainer
|
|
|
+*/
|
|
|
+
|
|
|
+/* start documentation of inline functions */
|
|
|
+
|
|
|
+/*! \fn double QCPGraphData::sortKey() const
|
|
|
+
|
|
|
+ Returns the \a key member of this data point.
|
|
|
+
|
|
|
+ For a general explanation of what this method is good for in the context of the data container,
|
|
|
+ see the documentation of \ref QCPDataContainer.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn static QCPGraphData QCPGraphData::fromSortKey(double sortKey)
|
|
|
+
|
|
|
+ Returns a data point with the specified \a sortKey. All other members are set to zero.
|
|
|
+
|
|
|
+ For a general explanation of what this method is good for in the context of the data container,
|
|
|
+ see the documentation of \ref QCPDataContainer.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn static static bool QCPGraphData::sortKeyIsMainKey()
|
|
|
+
|
|
|
+ Since the member \a key is both the data point key coordinate and the data ordering parameter,
|
|
|
+ this method returns true.
|
|
|
+
|
|
|
+ For a general explanation of what this method is good for in the context of the data container,
|
|
|
+ see the documentation of \ref QCPDataContainer.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn double QCPGraphData::mainKey() const
|
|
|
+
|
|
|
+ Returns the \a key member of this data point.
|
|
|
+
|
|
|
+ For a general explanation of what this method is good for in the context of the data container,
|
|
|
+ see the documentation of \ref QCPDataContainer.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn double QCPGraphData::mainValue() const
|
|
|
+
|
|
|
+ Returns the \a value member of this data point.
|
|
|
+
|
|
|
+ For a general explanation of what this method is good for in the context of the data container,
|
|
|
+ see the documentation of \ref QCPDataContainer.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn QCPRange QCPGraphData::valueRange() const
|
|
|
+
|
|
|
+ Returns a QCPRange with both lower and upper boundary set to \a value of this data point.
|
|
|
+
|
|
|
+ For a general explanation of what this method is good for in the context of the data container,
|
|
|
+ see the documentation of \ref QCPDataContainer.
|
|
|
+*/
|
|
|
+
|
|
|
+/* end documentation of inline functions */
|
|
|
+
|
|
|
+/*!
|
|
|
+ Constructs a data point with key and value set to zero.
|
|
|
+*/
|
|
|
+QCPGraphData::QCPGraphData() :
|
|
|
+ key(0),
|
|
|
+ value(0)
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Constructs a data point with the specified \a key and \a value.
|
|
|
+*/
|
|
|
+QCPGraphData::QCPGraphData(double key, double value) :
|
|
|
+ key(key),
|
|
|
+ value(value)
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPGraph
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+/*! \class QCPGraph
|
|
|
+ \brief A plottable representing a graph in a plot.
|
|
|
+
|
|
|
+ \image html QCPGraph.png
|
|
|
+
|
|
|
+ Usually you create new graphs by calling QCustomPlot::addGraph. The resulting instance can be
|
|
|
+ accessed via QCustomPlot::graph.
|
|
|
+
|
|
|
+ To plot data, assign it with the \ref setData or \ref addData functions. Alternatively, you can
|
|
|
+ also access and modify the data via the \ref data method, which returns a pointer to the internal
|
|
|
+ \ref QCPGraphDataContainer.
|
|
|
+
|
|
|
+ Graphs are used to display single-valued data. Single-valued means that there should only be one
|
|
|
+ data point per unique key coordinate. In other words, the graph can't have \a loops. If you do
|
|
|
+ want to plot non-single-valued curves, rather use the QCPCurve plottable.
|
|
|
+
|
|
|
+ Gaps in the graph line can be created by adding data points with NaN as value
|
|
|
+ (<tt>qQNaN()</tt> or <tt>std::numeric_limits<double>::quiet_NaN()</tt>) in between the two data points that shall be
|
|
|
+ separated.
|
|
|
+
|
|
|
+ \section qcpgraph-appearance Changing the appearance
|
|
|
+
|
|
|
+ The appearance of the graph is mainly determined by the line style, scatter style, brush and pen
|
|
|
+ of the graph (\ref setLineStyle, \ref setScatterStyle, \ref setBrush, \ref setPen).
|
|
|
+
|
|
|
+ \subsection filling Filling under or between graphs
|
|
|
+
|
|
|
+ QCPGraph knows two types of fills: Normal graph fills towards the zero-value-line parallel to
|
|
|
+ the key axis of the graph, and fills between two graphs, called channel fills. To enable a fill,
|
|
|
+ just set a brush with \ref setBrush which is neither Qt::NoBrush nor fully transparent.
|
|
|
+
|
|
|
+ By default, a normal fill towards the zero-value-line will be drawn. To set up a channel fill
|
|
|
+ between this graph and another one, call \ref setChannelFillGraph with the other graph as
|
|
|
+ parameter.
|
|
|
+
|
|
|
+ \see QCustomPlot::addGraph, QCustomPlot::graph
|
|
|
+*/
|
|
|
+
|
|
|
+/* start of documentation of inline functions */
|
|
|
+
|
|
|
+/*! \fn QSharedPointer<QCPGraphDataContainer> QCPGraph::data() const
|
|
|
+
|
|
|
+ Returns a shared pointer to the internal data storage of type \ref QCPGraphDataContainer. You may
|
|
|
+ use it to directly manipulate the data, which may be more convenient and faster than using the
|
|
|
+ regular \ref setData or \ref addData methods.
|
|
|
+*/
|
|
|
+
|
|
|
+/* end of documentation of inline functions */
|
|
|
+
|
|
|
+/*!
|
|
|
+ Constructs a graph which uses \a keyAxis as its key axis ("x") and \a valueAxis as its value
|
|
|
+ axis ("y"). \a keyAxis and \a valueAxis must reside in the same QCustomPlot instance and not have
|
|
|
+ the same orientation. If either of these restrictions is violated, a corresponding message is
|
|
|
+ printed to the debug output (qDebug), the construction is not aborted, though.
|
|
|
+
|
|
|
+ The created QCPGraph is automatically registered with the QCustomPlot instance inferred from \a
|
|
|
+ keyAxis. This QCustomPlot instance takes ownership of the QCPGraph, so do not delete it manually
|
|
|
+ but use QCustomPlot::removePlottable() instead.
|
|
|
+
|
|
|
+ To directly create a graph inside a plot, you can also use the simpler QCustomPlot::addGraph function.
|
|
|
+*/
|
|
|
+QCPGraph::QCPGraph(QCPAxis *keyAxis, QCPAxis *valueAxis) :
|
|
|
+ QCPAbstractPlottable1D<QCPGraphData>(keyAxis, valueAxis)
|
|
|
+{
|
|
|
+ // special handling for QCPGraphs to maintain the simple graph interface:
|
|
|
+ mParentPlot->registerGraph(this);
|
|
|
+
|
|
|
+ setPen(QPen(Qt::blue, 0));
|
|
|
+ setBrush(Qt::NoBrush);
|
|
|
+
|
|
|
+ setLineStyle(lsLine);
|
|
|
+ setScatterSkip(0);
|
|
|
+ setChannelFillGraph(0);
|
|
|
+ setAdaptiveSampling(true);
|
|
|
+}
|
|
|
+
|
|
|
+QCPGraph::~QCPGraph()
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Replaces the current data container with the provided \a data container.
|
|
|
+
|
|
|
+ Since a QSharedPointer is used, multiple QCPGraphs may share the same data container safely.
|
|
|
+ Modifying the data in the container will then affect all graphs that share the container. Sharing
|
|
|
+ can be achieved by simply exchanging the data containers wrapped in shared pointers:
|
|
|
+ \snippet documentation/doc-code-snippets/mainwindow.cpp qcpgraph-datasharing-1
|
|
|
+
|
|
|
+ If you do not wish to share containers, but create a copy from an existing container, rather use
|
|
|
+ the \ref QCPDataContainer<DataType>::set method on the graph's data container directly:
|
|
|
+ \snippet documentation/doc-code-snippets/mainwindow.cpp qcpgraph-datasharing-2
|
|
|
+
|
|
|
+ \see addData
|
|
|
+*/
|
|
|
+void QCPGraph::setData(QSharedPointer<QCPGraphDataContainer> data)
|
|
|
+{
|
|
|
+ mDataContainer = data;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Replaces the current data with the provided points in \a keys and \a values. The provided
|
|
|
+ vectors should have equal length. Else, the number of added points will be the size of the
|
|
|
+ smallest vector.
|
|
|
+
|
|
|
+ If you can guarantee that the passed data points are sorted by \a keys in ascending order, you
|
|
|
+ can set \a alreadySorted to true, to improve performance by saving a sorting run.
|
|
|
+
|
|
|
+ \see addData
|
|
|
+*/
|
|
|
+void QCPGraph::setData(const QVector<double> &keys, const QVector<double> &values, bool alreadySorted)
|
|
|
+{
|
|
|
+ mDataContainer->clear();
|
|
|
+ addData(keys, values, alreadySorted);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets how the single data points are connected in the plot. For scatter-only plots, set \a ls to
|
|
|
+ \ref lsNone and \ref setScatterStyle to the desired scatter style.
|
|
|
+
|
|
|
+ \see setScatterStyle
|
|
|
+*/
|
|
|
+void QCPGraph::setLineStyle(LineStyle ls)
|
|
|
+{
|
|
|
+ mLineStyle = ls;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the visual appearance of single data points in the plot. If set to \ref QCPScatterStyle::ssNone, no scatter points
|
|
|
+ are drawn (e.g. for line-only-plots with appropriate line style).
|
|
|
+
|
|
|
+ \see QCPScatterStyle, setLineStyle
|
|
|
+*/
|
|
|
+void QCPGraph::setScatterStyle(const QCPScatterStyle &style)
|
|
|
+{
|
|
|
+ mScatterStyle = style;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ If scatters are displayed (scatter style not \ref QCPScatterStyle::ssNone), \a skip number of
|
|
|
+ scatter points are skipped/not drawn after every drawn scatter point.
|
|
|
+
|
|
|
+ This can be used to make the data appear sparser while for example still having a smooth line,
|
|
|
+ and to improve performance for very high density plots.
|
|
|
+
|
|
|
+ If \a skip is set to 0 (default), all scatter points are drawn.
|
|
|
+
|
|
|
+ \see setScatterStyle
|
|
|
+*/
|
|
|
+void QCPGraph::setScatterSkip(int skip)
|
|
|
+{
|
|
|
+ mScatterSkip = qMax(0, skip);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the target graph for filling the area between this graph and \a targetGraph with the current
|
|
|
+ brush (\ref setBrush).
|
|
|
+
|
|
|
+ When \a targetGraph is set to 0, a normal graph fill to the zero-value-line will be shown. To
|
|
|
+ disable any filling, set the brush to Qt::NoBrush.
|
|
|
+
|
|
|
+ \see setBrush
|
|
|
+*/
|
|
|
+void QCPGraph::setChannelFillGraph(QCPGraph *targetGraph)
|
|
|
+{
|
|
|
+ // prevent setting channel target to this graph itself:
|
|
|
+ if (targetGraph == this)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "targetGraph is this graph itself";
|
|
|
+ mChannelFillGraph = 0;
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ // prevent setting channel target to a graph not in the plot:
|
|
|
+ if (targetGraph && targetGraph->mParentPlot != mParentPlot)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "targetGraph not in same plot";
|
|
|
+ mChannelFillGraph = 0;
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ mChannelFillGraph = targetGraph;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets whether adaptive sampling shall be used when plotting this graph. QCustomPlot's adaptive
|
|
|
+ sampling technique can drastically improve the replot performance for graphs with a larger number
|
|
|
+ of points (e.g. above 10,000), without notably changing the appearance of the graph.
|
|
|
+
|
|
|
+ By default, adaptive sampling is enabled. Even if enabled, QCustomPlot decides whether adaptive
|
|
|
+ sampling shall actually be used on a per-graph basis. So leaving adaptive sampling enabled has no
|
|
|
+ disadvantage in almost all cases.
|
|
|
+
|
|
|
+ \image html adaptive-sampling-line.png "A line plot of 500,000 points without and with adaptive sampling"
|
|
|
+
|
|
|
+ As can be seen, line plots experience no visual degradation from adaptive sampling. Outliers are
|
|
|
+ reproduced reliably, as well as the overall shape of the data set. The replot time reduces
|
|
|
+ dramatically though. This allows QCustomPlot to display large amounts of data in realtime.
|
|
|
+
|
|
|
+ \image html adaptive-sampling-scatter.png "A scatter plot of 100,000 points without and with adaptive sampling"
|
|
|
+
|
|
|
+ Care must be taken when using high-density scatter plots in combination with adaptive sampling.
|
|
|
+ The adaptive sampling algorithm treats scatter plots more carefully than line plots which still
|
|
|
+ gives a significant reduction of replot times, but not quite as much as for line plots. This is
|
|
|
+ because scatter plots inherently need more data points to be preserved in order to still resemble
|
|
|
+ the original, non-adaptive-sampling plot. As shown above, the results still aren't quite
|
|
|
+ identical, as banding occurs for the outer data points. This is in fact intentional, such that
|
|
|
+ the boundaries of the data cloud stay visible to the viewer. How strong the banding appears,
|
|
|
+ depends on the point density, i.e. the number of points in the plot.
|
|
|
+
|
|
|
+ For some situations with scatter plots it might thus be desirable to manually turn adaptive
|
|
|
+ sampling off. For example, when saving the plot to disk. This can be achieved by setting \a
|
|
|
+ enabled to false before issuing a command like \ref QCustomPlot::savePng, and setting \a enabled
|
|
|
+ back to true afterwards.
|
|
|
+*/
|
|
|
+void QCPGraph::setAdaptiveSampling(bool enabled)
|
|
|
+{
|
|
|
+ mAdaptiveSampling = enabled;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Adds the provided points in \a keys and \a values to the current data. The provided vectors
|
|
|
+ should have equal length. Else, the number of added points will be the size of the smallest
|
|
|
+ vector.
|
|
|
+
|
|
|
+ If you can guarantee that the passed data points are sorted by \a keys in ascending order, you
|
|
|
+ can set \a alreadySorted to true, to improve performance by saving a sorting run.
|
|
|
+
|
|
|
+ Alternatively, you can also access and modify the data directly via the \ref data method, which
|
|
|
+ returns a pointer to the internal data container.
|
|
|
+*/
|
|
|
+void QCPGraph::addData(const QVector<double> &keys, const QVector<double> &values, bool alreadySorted)
|
|
|
+{
|
|
|
+ if (keys.size() != values.size())
|
|
|
+ qDebug() << Q_FUNC_INFO << "keys and values have different sizes:" << keys.size() << values.size();
|
|
|
+ const int n = qMin(keys.size(), values.size());
|
|
|
+ QVector<QCPGraphData> tempData(n);
|
|
|
+ QVector<QCPGraphData>::iterator it = tempData.begin();
|
|
|
+ const QVector<QCPGraphData>::iterator itEnd = tempData.end();
|
|
|
+ int i = 0;
|
|
|
+ while (it != itEnd)
|
|
|
+ {
|
|
|
+ it->key = keys[i];
|
|
|
+ it->value = values[i];
|
|
|
+ ++it;
|
|
|
+ ++i;
|
|
|
+ }
|
|
|
+ mDataContainer->add(tempData, alreadySorted); // don't modify tempData beyond this to prevent copy on write
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Adds the provided data point as \a key and \a value to the current data.
|
|
|
+
|
|
|
+ Alternatively, you can also access and modify the data directly via the \ref data method, which
|
|
|
+ returns a pointer to the internal data container.
|
|
|
+*/
|
|
|
+void QCPGraph::addData(double key, double value)
|
|
|
+{
|
|
|
+ mDataContainer->add(QCPGraphData(key, value));
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+double QCPGraph::selectTest(const QPointF &pos, bool onlySelectable, QVariant *details) const
|
|
|
+{
|
|
|
+ if ((onlySelectable && mSelectable == QCP::stNone) || mDataContainer->isEmpty())
|
|
|
+ return -1;
|
|
|
+ if (!mKeyAxis || !mValueAxis)
|
|
|
+ return -1;
|
|
|
+
|
|
|
+ if (mKeyAxis.data()->axisRect()->rect().contains(pos.toPoint()))
|
|
|
+ {
|
|
|
+ QCPGraphDataContainer::const_iterator closestDataPoint = mDataContainer->constEnd();
|
|
|
+ double result = pointDistance(pos, closestDataPoint);
|
|
|
+ if (details)
|
|
|
+ {
|
|
|
+ int pointIndex = closestDataPoint-mDataContainer->constBegin();
|
|
|
+ details->setValue(QCPDataSelection(QCPDataRange(pointIndex, pointIndex+1)));
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+ } else
|
|
|
+ return -1;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+QCPRange QCPGraph::getKeyRange(bool &foundRange, QCP::SignDomain inSignDomain) const
|
|
|
+{
|
|
|
+ return mDataContainer->keyRange(foundRange, inSignDomain);
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+QCPRange QCPGraph::getValueRange(bool &foundRange, QCP::SignDomain inSignDomain, const QCPRange &inKeyRange) const
|
|
|
+{
|
|
|
+ return mDataContainer->valueRange(foundRange, inSignDomain, inKeyRange);
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPGraph::draw(QCPPainter *painter)
|
|
|
+{
|
|
|
+ if (!mKeyAxis || !mValueAxis) { qDebug() << Q_FUNC_INFO << "invalid key or value axis"; return; }
|
|
|
+ if (mKeyAxis.data()->range().size() <= 0 || mDataContainer->isEmpty()) return;
|
|
|
+ if (mLineStyle == lsNone && mScatterStyle.isNone()) return;
|
|
|
+
|
|
|
+ QVector<QPointF> lines, scatters; // line and (if necessary) scatter pixel coordinates will be stored here while iterating over segments
|
|
|
+
|
|
|
+ // loop over and draw segments of unselected/selected data:
|
|
|
+ QList<QCPDataRange> selectedSegments, unselectedSegments, allSegments;
|
|
|
+ getDataSegments(selectedSegments, unselectedSegments);
|
|
|
+ allSegments << unselectedSegments << selectedSegments;
|
|
|
+ for (int i=0; i<allSegments.size(); ++i)
|
|
|
+ {
|
|
|
+ bool isSelectedSegment = i >= unselectedSegments.size();
|
|
|
+ // get line pixel points appropriate to line style:
|
|
|
+ QCPDataRange lineDataRange = isSelectedSegment ? allSegments.at(i) : allSegments.at(i).adjusted(-1, 1); // unselected segments extend lines to bordering selected data point (safe to exceed total data bounds in first/last segment, getLines takes care)
|
|
|
+ getLines(&lines, lineDataRange);
|
|
|
+
|
|
|
+ // check data validity if flag set:
|
|
|
+#ifdef QCUSTOMPLOT_CHECK_DATA
|
|
|
+ QCPGraphDataContainer::const_iterator it;
|
|
|
+ for (it = mDataContainer->constBegin(); it != mDataContainer->constEnd(); ++it)
|
|
|
+ {
|
|
|
+ if (QCP::isInvalidData(it->key, it->value))
|
|
|
+ qDebug() << Q_FUNC_INFO << "Data point at" << it->key << "invalid." << "Plottable name:" << name();
|
|
|
+ }
|
|
|
+#endif
|
|
|
+
|
|
|
+ // draw fill of graph:
|
|
|
+ if (isSelectedSegment && mSelectionDecorator)
|
|
|
+ mSelectionDecorator->applyBrush(painter);
|
|
|
+ else
|
|
|
+ painter->setBrush(mBrush);
|
|
|
+ painter->setPen(Qt::NoPen);
|
|
|
+ drawFill(painter, &lines);
|
|
|
+
|
|
|
+ // draw line:
|
|
|
+ if (mLineStyle != lsNone)
|
|
|
+ {
|
|
|
+ if (isSelectedSegment && mSelectionDecorator)
|
|
|
+ mSelectionDecorator->applyPen(painter);
|
|
|
+ else
|
|
|
+ painter->setPen(mPen);
|
|
|
+ painter->setBrush(Qt::NoBrush);
|
|
|
+ if (mLineStyle == lsImpulse)
|
|
|
+ drawImpulsePlot(painter, lines);
|
|
|
+ else
|
|
|
+ drawLinePlot(painter, lines); // also step plots can be drawn as a line plot
|
|
|
+ }
|
|
|
+
|
|
|
+ // draw scatters:
|
|
|
+ QCPScatterStyle finalScatterStyle = mScatterStyle;
|
|
|
+ if (isSelectedSegment && mSelectionDecorator)
|
|
|
+ finalScatterStyle = mSelectionDecorator->getFinalScatterStyle(mScatterStyle);
|
|
|
+ if (!finalScatterStyle.isNone())
|
|
|
+ {
|
|
|
+ getScatters(&scatters, allSegments.at(i));
|
|
|
+ drawScatterPlot(painter, scatters, finalScatterStyle);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // draw other selection decoration that isn't just line/scatter pens and brushes:
|
|
|
+ if (mSelectionDecorator)
|
|
|
+ mSelectionDecorator->drawDecoration(painter, selection());
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPGraph::drawLegendIcon(QCPPainter *painter, const QRectF &rect) const
|
|
|
+{
|
|
|
+ // draw fill:
|
|
|
+ if (mBrush.style() != Qt::NoBrush)
|
|
|
+ {
|
|
|
+ applyFillAntialiasingHint(painter);
|
|
|
+ painter->fillRect(QRectF(rect.left(), rect.top()+rect.height()/2.0, rect.width(), rect.height()/3.0), mBrush);
|
|
|
+ }
|
|
|
+ // draw line vertically centered:
|
|
|
+ if (mLineStyle != lsNone)
|
|
|
+ {
|
|
|
+ applyDefaultAntialiasingHint(painter);
|
|
|
+ painter->setPen(mPen);
|
|
|
+ painter->drawLine(QLineF(rect.left(), rect.top()+rect.height()/2.0, rect.right()+5, rect.top()+rect.height()/2.0)); // +5 on x2 else last segment is missing from dashed/dotted pens
|
|
|
+ }
|
|
|
+ // draw scatter symbol:
|
|
|
+ if (!mScatterStyle.isNone())
|
|
|
+ {
|
|
|
+ applyScattersAntialiasingHint(painter);
|
|
|
+ // scale scatter pixmap if it's too large to fit in legend icon rect:
|
|
|
+ if (mScatterStyle.shape() == QCPScatterStyle::ssPixmap && (mScatterStyle.pixmap().size().width() > rect.width() || mScatterStyle.pixmap().size().height() > rect.height()))
|
|
|
+ {
|
|
|
+ QCPScatterStyle scaledStyle(mScatterStyle);
|
|
|
+ scaledStyle.setPixmap(scaledStyle.pixmap().scaled(rect.size().toSize(), Qt::KeepAspectRatio, Qt::SmoothTransformation));
|
|
|
+ scaledStyle.applyTo(painter, mPen);
|
|
|
+ scaledStyle.drawShape(painter, QRectF(rect).center());
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ mScatterStyle.applyTo(painter, mPen);
|
|
|
+ mScatterStyle.drawShape(painter, QRectF(rect).center());
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ This method retrieves an optimized set of data points via \ref getOptimizedLineData, an branches
|
|
|
+ out to the line style specific functions such as \ref dataToLines, \ref dataToStepLeftLines, etc.
|
|
|
+ according to the line style of the graph.
|
|
|
+
|
|
|
+ \a lines will be filled with points in pixel coordinates, that can be drawn with the according
|
|
|
+ draw functions like \ref drawLinePlot and \ref drawImpulsePlot. The points returned in \a lines
|
|
|
+ aren't necessarily the original data points. For example, step line styles require additional
|
|
|
+ points to form the steps when drawn. If the line style of the graph is \ref lsNone, the \a
|
|
|
+ lines vector will be empty.
|
|
|
+
|
|
|
+ \a dataRange specifies the beginning and ending data indices that will be taken into account for
|
|
|
+ conversion. In this function, the specified range may exceed the total data bounds without harm:
|
|
|
+ a correspondingly trimmed data range will be used. This takes the burden off the user of this
|
|
|
+ function to check for valid indices in \a dataRange, e.g. when extending ranges coming from \ref
|
|
|
+ getDataSegments.
|
|
|
+
|
|
|
+ \see getScatters
|
|
|
+*/
|
|
|
+void QCPGraph::getLines(QVector<QPointF> *lines, const QCPDataRange &dataRange) const
|
|
|
+{
|
|
|
+ if (!lines) return;
|
|
|
+ QCPGraphDataContainer::const_iterator begin, end;
|
|
|
+ getVisibleDataBounds(begin, end, dataRange);
|
|
|
+ if (begin == end)
|
|
|
+ {
|
|
|
+ lines->clear();
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ QVector<QCPGraphData> lineData;
|
|
|
+ if (mLineStyle != lsNone)
|
|
|
+ getOptimizedLineData(&lineData, begin, end);
|
|
|
+
|
|
|
+ if (mKeyAxis->rangeReversed() != (mKeyAxis->orientation() == Qt::Vertical)) // make sure key pixels are sorted ascending in lineData (significantly simplifies following processing)
|
|
|
+ std::reverse(lineData.begin(), lineData.end());
|
|
|
+
|
|
|
+ switch (mLineStyle)
|
|
|
+ {
|
|
|
+ case lsNone: lines->clear(); break;
|
|
|
+ case lsLine: *lines = dataToLines(lineData); break;
|
|
|
+ case lsStepLeft: *lines = dataToStepLeftLines(lineData); break;
|
|
|
+ case lsStepRight: *lines = dataToStepRightLines(lineData); break;
|
|
|
+ case lsStepCenter: *lines = dataToStepCenterLines(lineData); break;
|
|
|
+ case lsImpulse: *lines = dataToImpulseLines(lineData); break;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ This method retrieves an optimized set of data points via \ref getOptimizedScatterData and then
|
|
|
+ converts them to pixel coordinates. The resulting points are returned in \a scatters, and can be
|
|
|
+ passed to \ref drawScatterPlot.
|
|
|
+
|
|
|
+ \a dataRange specifies the beginning and ending data indices that will be taken into account for
|
|
|
+ conversion. In this function, the specified range may exceed the total data bounds without harm:
|
|
|
+ a correspondingly trimmed data range will be used. This takes the burden off the user of this
|
|
|
+ function to check for valid indices in \a dataRange, e.g. when extending ranges coming from \ref
|
|
|
+ getDataSegments.
|
|
|
+*/
|
|
|
+void QCPGraph::getScatters(QVector<QPointF> *scatters, const QCPDataRange &dataRange) const
|
|
|
+{
|
|
|
+ if (!scatters) return;
|
|
|
+ QCPAxis *keyAxis = mKeyAxis.data();
|
|
|
+ QCPAxis *valueAxis = mValueAxis.data();
|
|
|
+ if (!keyAxis || !valueAxis) { qDebug() << Q_FUNC_INFO << "invalid key or value axis"; scatters->clear(); return; }
|
|
|
+
|
|
|
+ QCPGraphDataContainer::const_iterator begin, end;
|
|
|
+ getVisibleDataBounds(begin, end, dataRange);
|
|
|
+ if (begin == end)
|
|
|
+ {
|
|
|
+ scatters->clear();
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ QVector<QCPGraphData> data;
|
|
|
+ getOptimizedScatterData(&data, begin, end);
|
|
|
+
|
|
|
+ if (mKeyAxis->rangeReversed() != (mKeyAxis->orientation() == Qt::Vertical)) // make sure key pixels are sorted ascending in data (significantly simplifies following processing)
|
|
|
+ std::reverse(data.begin(), data.end());
|
|
|
+
|
|
|
+ scatters->resize(data.size());
|
|
|
+ if (keyAxis->orientation() == Qt::Vertical)
|
|
|
+ {
|
|
|
+ for (int i=0; i<data.size(); ++i)
|
|
|
+ {
|
|
|
+ if (!qIsNaN(data.at(i).value))
|
|
|
+ {
|
|
|
+ (*scatters)[i].setX(valueAxis->coordToPixel(data.at(i).value));
|
|
|
+ (*scatters)[i].setY(keyAxis->coordToPixel(data.at(i).key));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ for (int i=0; i<data.size(); ++i)
|
|
|
+ {
|
|
|
+ if (!qIsNaN(data.at(i).value))
|
|
|
+ {
|
|
|
+ (*scatters)[i].setX(keyAxis->coordToPixel(data.at(i).key));
|
|
|
+ (*scatters)[i].setY(valueAxis->coordToPixel(data.at(i).value));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Takes raw data points in plot coordinates as \a data, and returns a vector containing pixel
|
|
|
+ coordinate points which are suitable for drawing the line style \ref lsLine.
|
|
|
+
|
|
|
+ The source of \a data is usually \ref getOptimizedLineData, and this method is called in \a
|
|
|
+ getLines if the line style is set accordingly.
|
|
|
+
|
|
|
+ \see dataToStepLeftLines, dataToStepRightLines, dataToStepCenterLines, dataToImpulseLines, getLines, drawLinePlot
|
|
|
+*/
|
|
|
+QVector<QPointF> QCPGraph::dataToLines(const QVector<QCPGraphData> &data) const
|
|
|
+{
|
|
|
+ QVector<QPointF> result;
|
|
|
+ QCPAxis *keyAxis = mKeyAxis.data();
|
|
|
+ QCPAxis *valueAxis = mValueAxis.data();
|
|
|
+ if (!keyAxis || !valueAxis) { qDebug() << Q_FUNC_INFO << "invalid key or value axis"; return result; }
|
|
|
+
|
|
|
+ result.resize(data.size());
|
|
|
+
|
|
|
+ // transform data points to pixels:
|
|
|
+ if (keyAxis->orientation() == Qt::Vertical)
|
|
|
+ {
|
|
|
+ for (int i=0; i<data.size(); ++i)
|
|
|
+ {
|
|
|
+ result[i].setX(valueAxis->coordToPixel(data.at(i).value));
|
|
|
+ result[i].setY(keyAxis->coordToPixel(data.at(i).key));
|
|
|
+ }
|
|
|
+ } else // key axis is horizontal
|
|
|
+ {
|
|
|
+ for (int i=0; i<data.size(); ++i)
|
|
|
+ {
|
|
|
+ result[i].setX(keyAxis->coordToPixel(data.at(i).key));
|
|
|
+ result[i].setY(valueAxis->coordToPixel(data.at(i).value));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Takes raw data points in plot coordinates as \a data, and returns a vector containing pixel
|
|
|
+ coordinate points which are suitable for drawing the line style \ref lsStepLeft.
|
|
|
+
|
|
|
+ The source of \a data is usually \ref getOptimizedLineData, and this method is called in \a
|
|
|
+ getLines if the line style is set accordingly.
|
|
|
+
|
|
|
+ \see dataToLines, dataToStepRightLines, dataToStepCenterLines, dataToImpulseLines, getLines, drawLinePlot
|
|
|
+*/
|
|
|
+QVector<QPointF> QCPGraph::dataToStepLeftLines(const QVector<QCPGraphData> &data) const
|
|
|
+{
|
|
|
+ QVector<QPointF> result;
|
|
|
+ QCPAxis *keyAxis = mKeyAxis.data();
|
|
|
+ QCPAxis *valueAxis = mValueAxis.data();
|
|
|
+ if (!keyAxis || !valueAxis) { qDebug() << Q_FUNC_INFO << "invalid key or value axis"; return result; }
|
|
|
+
|
|
|
+ result.resize(data.size()*2);
|
|
|
+
|
|
|
+ // calculate steps from data and transform to pixel coordinates:
|
|
|
+ if (keyAxis->orientation() == Qt::Vertical)
|
|
|
+ {
|
|
|
+ double lastValue = valueAxis->coordToPixel(data.first().value);
|
|
|
+ for (int i=0; i<data.size(); ++i)
|
|
|
+ {
|
|
|
+ const double key = keyAxis->coordToPixel(data.at(i).key);
|
|
|
+ result[i*2+0].setX(lastValue);
|
|
|
+ result[i*2+0].setY(key);
|
|
|
+ lastValue = valueAxis->coordToPixel(data.at(i).value);
|
|
|
+ result[i*2+1].setX(lastValue);
|
|
|
+ result[i*2+1].setY(key);
|
|
|
+ }
|
|
|
+ } else // key axis is horizontal
|
|
|
+ {
|
|
|
+ double lastValue = valueAxis->coordToPixel(data.first().value);
|
|
|
+ for (int i=0; i<data.size(); ++i)
|
|
|
+ {
|
|
|
+ const double key = keyAxis->coordToPixel(data.at(i).key);
|
|
|
+ result[i*2+0].setX(key);
|
|
|
+ result[i*2+0].setY(lastValue);
|
|
|
+ lastValue = valueAxis->coordToPixel(data.at(i).value);
|
|
|
+ result[i*2+1].setX(key);
|
|
|
+ result[i*2+1].setY(lastValue);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Takes raw data points in plot coordinates as \a data, and returns a vector containing pixel
|
|
|
+ coordinate points which are suitable for drawing the line style \ref lsStepRight.
|
|
|
+
|
|
|
+ The source of \a data is usually \ref getOptimizedLineData, and this method is called in \a
|
|
|
+ getLines if the line style is set accordingly.
|
|
|
+
|
|
|
+ \see dataToLines, dataToStepLeftLines, dataToStepCenterLines, dataToImpulseLines, getLines, drawLinePlot
|
|
|
+*/
|
|
|
+QVector<QPointF> QCPGraph::dataToStepRightLines(const QVector<QCPGraphData> &data) const
|
|
|
+{
|
|
|
+ QVector<QPointF> result;
|
|
|
+ QCPAxis *keyAxis = mKeyAxis.data();
|
|
|
+ QCPAxis *valueAxis = mValueAxis.data();
|
|
|
+ if (!keyAxis || !valueAxis) { qDebug() << Q_FUNC_INFO << "invalid key or value axis"; return result; }
|
|
|
+
|
|
|
+ result.resize(data.size()*2);
|
|
|
+
|
|
|
+ // calculate steps from data and transform to pixel coordinates:
|
|
|
+ if (keyAxis->orientation() == Qt::Vertical)
|
|
|
+ {
|
|
|
+ double lastKey = keyAxis->coordToPixel(data.first().key);
|
|
|
+ for (int i=0; i<data.size(); ++i)
|
|
|
+ {
|
|
|
+ const double value = valueAxis->coordToPixel(data.at(i).value);
|
|
|
+ result[i*2+0].setX(value);
|
|
|
+ result[i*2+0].setY(lastKey);
|
|
|
+ lastKey = keyAxis->coordToPixel(data.at(i).key);
|
|
|
+ result[i*2+1].setX(value);
|
|
|
+ result[i*2+1].setY(lastKey);
|
|
|
+ }
|
|
|
+ } else // key axis is horizontal
|
|
|
+ {
|
|
|
+ double lastKey = keyAxis->coordToPixel(data.first().key);
|
|
|
+ for (int i=0; i<data.size(); ++i)
|
|
|
+ {
|
|
|
+ const double value = valueAxis->coordToPixel(data.at(i).value);
|
|
|
+ result[i*2+0].setX(lastKey);
|
|
|
+ result[i*2+0].setY(value);
|
|
|
+ lastKey = keyAxis->coordToPixel(data.at(i).key);
|
|
|
+ result[i*2+1].setX(lastKey);
|
|
|
+ result[i*2+1].setY(value);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Takes raw data points in plot coordinates as \a data, and returns a vector containing pixel
|
|
|
+ coordinate points which are suitable for drawing the line style \ref lsStepCenter.
|
|
|
+
|
|
|
+ The source of \a data is usually \ref getOptimizedLineData, and this method is called in \a
|
|
|
+ getLines if the line style is set accordingly.
|
|
|
+
|
|
|
+ \see dataToLines, dataToStepLeftLines, dataToStepRightLines, dataToImpulseLines, getLines, drawLinePlot
|
|
|
+*/
|
|
|
+QVector<QPointF> QCPGraph::dataToStepCenterLines(const QVector<QCPGraphData> &data) const
|
|
|
+{
|
|
|
+ QVector<QPointF> result;
|
|
|
+ QCPAxis *keyAxis = mKeyAxis.data();
|
|
|
+ QCPAxis *valueAxis = mValueAxis.data();
|
|
|
+ if (!keyAxis || !valueAxis) { qDebug() << Q_FUNC_INFO << "invalid key or value axis"; return result; }
|
|
|
+
|
|
|
+ result.resize(data.size()*2);
|
|
|
+
|
|
|
+ // calculate steps from data and transform to pixel coordinates:
|
|
|
+ if (keyAxis->orientation() == Qt::Vertical)
|
|
|
+ {
|
|
|
+ double lastKey = keyAxis->coordToPixel(data.first().key);
|
|
|
+ double lastValue = valueAxis->coordToPixel(data.first().value);
|
|
|
+ result[0].setX(lastValue);
|
|
|
+ result[0].setY(lastKey);
|
|
|
+ for (int i=1; i<data.size(); ++i)
|
|
|
+ {
|
|
|
+ const double key = (keyAxis->coordToPixel(data.at(i).key)+lastKey)*0.5;
|
|
|
+ result[i*2-1].setX(lastValue);
|
|
|
+ result[i*2-1].setY(key);
|
|
|
+ lastValue = valueAxis->coordToPixel(data.at(i).value);
|
|
|
+ lastKey = keyAxis->coordToPixel(data.at(i).key);
|
|
|
+ result[i*2+0].setX(lastValue);
|
|
|
+ result[i*2+0].setY(key);
|
|
|
+ }
|
|
|
+ result[data.size()*2-1].setX(lastValue);
|
|
|
+ result[data.size()*2-1].setY(lastKey);
|
|
|
+ } else // key axis is horizontal
|
|
|
+ {
|
|
|
+ double lastKey = keyAxis->coordToPixel(data.first().key);
|
|
|
+ double lastValue = valueAxis->coordToPixel(data.first().value);
|
|
|
+ result[0].setX(lastKey);
|
|
|
+ result[0].setY(lastValue);
|
|
|
+ for (int i=1; i<data.size(); ++i)
|
|
|
+ {
|
|
|
+ const double key = (keyAxis->coordToPixel(data.at(i).key)+lastKey)*0.5;
|
|
|
+ result[i*2-1].setX(key);
|
|
|
+ result[i*2-1].setY(lastValue);
|
|
|
+ lastValue = valueAxis->coordToPixel(data.at(i).value);
|
|
|
+ lastKey = keyAxis->coordToPixel(data.at(i).key);
|
|
|
+ result[i*2+0].setX(key);
|
|
|
+ result[i*2+0].setY(lastValue);
|
|
|
+ }
|
|
|
+ result[data.size()*2-1].setX(lastKey);
|
|
|
+ result[data.size()*2-1].setY(lastValue);
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Takes raw data points in plot coordinates as \a data, and returns a vector containing pixel
|
|
|
+ coordinate points which are suitable for drawing the line style \ref lsImpulse.
|
|
|
+
|
|
|
+ The source of \a data is usually \ref getOptimizedLineData, and this method is called in \a
|
|
|
+ getLines if the line style is set accordingly.
|
|
|
+
|
|
|
+ \see dataToLines, dataToStepLeftLines, dataToStepRightLines, dataToStepCenterLines, getLines, drawImpulsePlot
|
|
|
+*/
|
|
|
+QVector<QPointF> QCPGraph::dataToImpulseLines(const QVector<QCPGraphData> &data) const
|
|
|
+{
|
|
|
+ QVector<QPointF> result;
|
|
|
+ QCPAxis *keyAxis = mKeyAxis.data();
|
|
|
+ QCPAxis *valueAxis = mValueAxis.data();
|
|
|
+ if (!keyAxis || !valueAxis) { qDebug() << Q_FUNC_INFO << "invalid key or value axis"; return result; }
|
|
|
+
|
|
|
+ result.resize(data.size()*2);
|
|
|
+
|
|
|
+ // transform data points to pixels:
|
|
|
+ if (keyAxis->orientation() == Qt::Vertical)
|
|
|
+ {
|
|
|
+ for (int i=0; i<data.size(); ++i)
|
|
|
+ {
|
|
|
+ const double key = keyAxis->coordToPixel(data.at(i).key);
|
|
|
+ result[i*2+0].setX(valueAxis->coordToPixel(0));
|
|
|
+ result[i*2+0].setY(key);
|
|
|
+ result[i*2+1].setX(valueAxis->coordToPixel(data.at(i).value));
|
|
|
+ result[i*2+1].setY(key);
|
|
|
+ }
|
|
|
+ } else // key axis is horizontal
|
|
|
+ {
|
|
|
+ for (int i=0; i<data.size(); ++i)
|
|
|
+ {
|
|
|
+ const double key = keyAxis->coordToPixel(data.at(i).key);
|
|
|
+ result[i*2+0].setX(key);
|
|
|
+ result[i*2+0].setY(valueAxis->coordToPixel(0));
|
|
|
+ result[i*2+1].setX(key);
|
|
|
+ result[i*2+1].setY(valueAxis->coordToPixel(data.at(i).value));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Draws the fill of the graph using the specified \a painter, with the currently set brush.
|
|
|
+
|
|
|
+ Depending on whether a normal fill or a channel fill (\ref setChannelFillGraph) is needed, \ref
|
|
|
+ getFillPolygon or \ref getChannelFillPolygon are used to find the according fill polygons.
|
|
|
+
|
|
|
+ In order to handle NaN Data points correctly (the fill needs to be split into disjoint areas),
|
|
|
+ this method first determines a list of non-NaN segments with \ref getNonNanSegments, on which to
|
|
|
+ operate. In the channel fill case, \ref getOverlappingSegments is used to consolidate the non-NaN
|
|
|
+ segments of the two involved graphs, before passing the overlapping pairs to \ref
|
|
|
+ getChannelFillPolygon.
|
|
|
+
|
|
|
+ Pass the points of this graph's line as \a lines, in pixel coordinates.
|
|
|
+
|
|
|
+ \see drawLinePlot, drawImpulsePlot, drawScatterPlot
|
|
|
+*/
|
|
|
+void QCPGraph::drawFill(QCPPainter *painter, QVector<QPointF> *lines) const
|
|
|
+{
|
|
|
+ if (mLineStyle == lsImpulse) return; // fill doesn't make sense for impulse plot
|
|
|
+ if (painter->brush().style() == Qt::NoBrush || painter->brush().color().alpha() == 0) return;
|
|
|
+
|
|
|
+ applyFillAntialiasingHint(painter);
|
|
|
+ QVector<QCPDataRange> segments = getNonNanSegments(lines, keyAxis()->orientation());
|
|
|
+ if (!mChannelFillGraph)
|
|
|
+ {
|
|
|
+ // draw base fill under graph, fill goes all the way to the zero-value-line:
|
|
|
+ for (int i=0; i<segments.size(); ++i)
|
|
|
+ painter->drawPolygon(getFillPolygon(lines, segments.at(i)));
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ // draw fill between this graph and mChannelFillGraph:
|
|
|
+ QVector<QPointF> otherLines;
|
|
|
+ mChannelFillGraph->getLines(&otherLines, QCPDataRange(0, mChannelFillGraph->dataCount()));
|
|
|
+ if (!otherLines.isEmpty())
|
|
|
+ {
|
|
|
+ QVector<QCPDataRange> otherSegments = getNonNanSegments(&otherLines, mChannelFillGraph->keyAxis()->orientation());
|
|
|
+ QVector<QPair<QCPDataRange, QCPDataRange> > segmentPairs = getOverlappingSegments(segments, lines, otherSegments, &otherLines);
|
|
|
+ for (int i=0; i<segmentPairs.size(); ++i)
|
|
|
+ painter->drawPolygon(getChannelFillPolygon(lines, segmentPairs.at(i).first, &otherLines, segmentPairs.at(i).second));
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Draws scatter symbols at every point passed in \a scatters, given in pixel coordinates. The
|
|
|
+ scatters will be drawn with \a painter and have the appearance as specified in \a style.
|
|
|
+
|
|
|
+ \see drawLinePlot, drawImpulsePlot
|
|
|
+*/
|
|
|
+void QCPGraph::drawScatterPlot(QCPPainter *painter, const QVector<QPointF> &scatters, const QCPScatterStyle &style) const
|
|
|
+{
|
|
|
+ applyScattersAntialiasingHint(painter);
|
|
|
+ style.applyTo(painter, mPen);
|
|
|
+ for (int i=0; i<scatters.size(); ++i)
|
|
|
+ style.drawShape(painter, scatters.at(i).x(), scatters.at(i).y());
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Draws lines between the points in \a lines, given in pixel coordinates.
|
|
|
+
|
|
|
+ \see drawScatterPlot, drawImpulsePlot, QCPAbstractPlottable1D::drawPolyline
|
|
|
+*/
|
|
|
+void QCPGraph::drawLinePlot(QCPPainter *painter, const QVector<QPointF> &lines) const
|
|
|
+{
|
|
|
+ if (painter->pen().style() != Qt::NoPen && painter->pen().color().alpha() != 0)
|
|
|
+ {
|
|
|
+ applyDefaultAntialiasingHint(painter);
|
|
|
+ drawPolyline(painter, lines);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Draws impulses from the provided data, i.e. it connects all line pairs in \a lines, given in
|
|
|
+ pixel coordinates. The \a lines necessary for impulses are generated by \ref dataToImpulseLines
|
|
|
+ from the regular graph data points.
|
|
|
+
|
|
|
+ \see drawLinePlot, drawScatterPlot
|
|
|
+*/
|
|
|
+void QCPGraph::drawImpulsePlot(QCPPainter *painter, const QVector<QPointF> &lines) const
|
|
|
+{
|
|
|
+ if (painter->pen().style() != Qt::NoPen && painter->pen().color().alpha() != 0)
|
|
|
+ {
|
|
|
+ applyDefaultAntialiasingHint(painter);
|
|
|
+ QPen oldPen = painter->pen();
|
|
|
+ QPen newPen = painter->pen();
|
|
|
+ newPen.setCapStyle(Qt::FlatCap); // so impulse line doesn't reach beyond zero-line
|
|
|
+ painter->setPen(newPen);
|
|
|
+ painter->drawLines(lines);
|
|
|
+ painter->setPen(oldPen);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns via \a lineData the data points that need to be visualized for this graph when plotting
|
|
|
+ graph lines, taking into consideration the currently visible axis ranges and, if \ref
|
|
|
+ setAdaptiveSampling is enabled, local point densities. The considered data can be restricted
|
|
|
+ further by \a begin and \a end, e.g. to only plot a certain segment of the data (see \ref
|
|
|
+ getDataSegments).
|
|
|
+
|
|
|
+ This method is used by \ref getLines to retrieve the basic working set of data.
|
|
|
+
|
|
|
+ \see getOptimizedScatterData
|
|
|
+*/
|
|
|
+void QCPGraph::getOptimizedLineData(QVector<QCPGraphData> *lineData, const QCPGraphDataContainer::const_iterator &begin, const QCPGraphDataContainer::const_iterator &end) const
|
|
|
+{
|
|
|
+ if (!lineData) return;
|
|
|
+ QCPAxis *keyAxis = mKeyAxis.data();
|
|
|
+ QCPAxis *valueAxis = mValueAxis.data();
|
|
|
+ if (!keyAxis || !valueAxis) { qDebug() << Q_FUNC_INFO << "invalid key or value axis"; return; }
|
|
|
+ if (begin == end) return;
|
|
|
+
|
|
|
+ int dataCount = end-begin;
|
|
|
+ int maxCount = std::numeric_limits<int>::max();
|
|
|
+ if (mAdaptiveSampling)
|
|
|
+ {
|
|
|
+ double keyPixelSpan = qAbs(keyAxis->coordToPixel(begin->key)-keyAxis->coordToPixel((end-1)->key));
|
|
|
+ if (2*keyPixelSpan+2 < (double)std::numeric_limits<int>::max())
|
|
|
+ maxCount = 2*keyPixelSpan+2;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (mAdaptiveSampling && dataCount >= maxCount) // use adaptive sampling only if there are at least two points per pixel on average
|
|
|
+ {
|
|
|
+ QCPGraphDataContainer::const_iterator it = begin;
|
|
|
+ double minValue = it->value;
|
|
|
+ double maxValue = it->value;
|
|
|
+ QCPGraphDataContainer::const_iterator currentIntervalFirstPoint = it;
|
|
|
+ int reversedFactor = keyAxis->pixelOrientation(); // is used to calculate keyEpsilon pixel into the correct direction
|
|
|
+ int reversedRound = reversedFactor==-1 ? 1 : 0; // is used to switch between floor (normal) and ceil (reversed) rounding of currentIntervalStartKey
|
|
|
+ double currentIntervalStartKey = keyAxis->pixelToCoord((int)(keyAxis->coordToPixel(begin->key)+reversedRound));
|
|
|
+ double lastIntervalEndKey = currentIntervalStartKey;
|
|
|
+ double keyEpsilon = qAbs(currentIntervalStartKey-keyAxis->pixelToCoord(keyAxis->coordToPixel(currentIntervalStartKey)+1.0*reversedFactor)); // interval of one pixel on screen when mapped to plot key coordinates
|
|
|
+ bool keyEpsilonVariable = keyAxis->scaleType() == QCPAxis::stLogarithmic; // indicates whether keyEpsilon needs to be updated after every interval (for log axes)
|
|
|
+ int intervalDataCount = 1;
|
|
|
+ ++it; // advance iterator to second data point because adaptive sampling works in 1 point retrospect
|
|
|
+ while (it != end)
|
|
|
+ {
|
|
|
+ if (it->key < currentIntervalStartKey+keyEpsilon) // data point is still within same pixel, so skip it and expand value span of this cluster if necessary
|
|
|
+ {
|
|
|
+ if (it->value < minValue)
|
|
|
+ minValue = it->value;
|
|
|
+ else if (it->value > maxValue)
|
|
|
+ maxValue = it->value;
|
|
|
+ ++intervalDataCount;
|
|
|
+ } else // new pixel interval started
|
|
|
+ {
|
|
|
+ if (intervalDataCount >= 2) // last pixel had multiple data points, consolidate them to a cluster
|
|
|
+ {
|
|
|
+ if (lastIntervalEndKey < currentIntervalStartKey-keyEpsilon) // last point is further away, so first point of this cluster must be at a real data point
|
|
|
+ lineData->append(QCPGraphData(currentIntervalStartKey+keyEpsilon*0.2, currentIntervalFirstPoint->value));
|
|
|
+ lineData->append(QCPGraphData(currentIntervalStartKey+keyEpsilon*0.25, minValue));
|
|
|
+ lineData->append(QCPGraphData(currentIntervalStartKey+keyEpsilon*0.75, maxValue));
|
|
|
+ if (it->key > currentIntervalStartKey+keyEpsilon*2) // new pixel started further away from previous cluster, so make sure the last point of the cluster is at a real data point
|
|
|
+ lineData->append(QCPGraphData(currentIntervalStartKey+keyEpsilon*0.8, (it-1)->value));
|
|
|
+ } else
|
|
|
+ lineData->append(QCPGraphData(currentIntervalFirstPoint->key, currentIntervalFirstPoint->value));
|
|
|
+ lastIntervalEndKey = (it-1)->key;
|
|
|
+ minValue = it->value;
|
|
|
+ maxValue = it->value;
|
|
|
+ currentIntervalFirstPoint = it;
|
|
|
+ currentIntervalStartKey = keyAxis->pixelToCoord((int)(keyAxis->coordToPixel(it->key)+reversedRound));
|
|
|
+ if (keyEpsilonVariable)
|
|
|
+ keyEpsilon = qAbs(currentIntervalStartKey-keyAxis->pixelToCoord(keyAxis->coordToPixel(currentIntervalStartKey)+1.0*reversedFactor));
|
|
|
+ intervalDataCount = 1;
|
|
|
+ }
|
|
|
+ ++it;
|
|
|
+ }
|
|
|
+ // handle last interval:
|
|
|
+ if (intervalDataCount >= 2) // last pixel had multiple data points, consolidate them to a cluster
|
|
|
+ {
|
|
|
+ if (lastIntervalEndKey < currentIntervalStartKey-keyEpsilon) // last point wasn't a cluster, so first point of this cluster must be at a real data point
|
|
|
+ lineData->append(QCPGraphData(currentIntervalStartKey+keyEpsilon*0.2, currentIntervalFirstPoint->value));
|
|
|
+ lineData->append(QCPGraphData(currentIntervalStartKey+keyEpsilon*0.25, minValue));
|
|
|
+ lineData->append(QCPGraphData(currentIntervalStartKey+keyEpsilon*0.75, maxValue));
|
|
|
+ } else
|
|
|
+ lineData->append(QCPGraphData(currentIntervalFirstPoint->key, currentIntervalFirstPoint->value));
|
|
|
+
|
|
|
+ } else // don't use adaptive sampling algorithm, transfer points one-to-one from the data container into the output
|
|
|
+ {
|
|
|
+ lineData->resize(dataCount);
|
|
|
+ std::copy(begin, end, lineData->begin());
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns via \a scatterData the data points that need to be visualized for this graph when
|
|
|
+ plotting scatter points, taking into consideration the currently visible axis ranges and, if \ref
|
|
|
+ setAdaptiveSampling is enabled, local point densities. The considered data can be restricted
|
|
|
+ further by \a begin and \a end, e.g. to only plot a certain segment of the data (see \ref
|
|
|
+ getDataSegments).
|
|
|
+
|
|
|
+ This method is used by \ref getScatters to retrieve the basic working set of data.
|
|
|
+
|
|
|
+ \see getOptimizedLineData
|
|
|
+*/
|
|
|
+void QCPGraph::getOptimizedScatterData(QVector<QCPGraphData> *scatterData, QCPGraphDataContainer::const_iterator begin, QCPGraphDataContainer::const_iterator end) const
|
|
|
+{
|
|
|
+ if (!scatterData) return;
|
|
|
+ QCPAxis *keyAxis = mKeyAxis.data();
|
|
|
+ QCPAxis *valueAxis = mValueAxis.data();
|
|
|
+ if (!keyAxis || !valueAxis) { qDebug() << Q_FUNC_INFO << "invalid key or value axis"; return; }
|
|
|
+
|
|
|
+ const int scatterModulo = mScatterSkip+1;
|
|
|
+ const bool doScatterSkip = mScatterSkip > 0;
|
|
|
+ int beginIndex = begin-mDataContainer->constBegin();
|
|
|
+ int endIndex = end-mDataContainer->constBegin();
|
|
|
+ while (doScatterSkip && begin != end && beginIndex % scatterModulo != 0) // advance begin iterator to first non-skipped scatter
|
|
|
+ {
|
|
|
+ ++beginIndex;
|
|
|
+ ++begin;
|
|
|
+ }
|
|
|
+ if (begin == end) return;
|
|
|
+ int dataCount = end-begin;
|
|
|
+ int maxCount = std::numeric_limits<int>::max();
|
|
|
+ if (mAdaptiveSampling)
|
|
|
+ {
|
|
|
+ int keyPixelSpan = qAbs(keyAxis->coordToPixel(begin->key)-keyAxis->coordToPixel((end-1)->key));
|
|
|
+ maxCount = 2*keyPixelSpan+2;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (mAdaptiveSampling && dataCount >= maxCount) // use adaptive sampling only if there are at least two points per pixel on average
|
|
|
+ {
|
|
|
+ double valueMaxRange = valueAxis->range().upper;
|
|
|
+ double valueMinRange = valueAxis->range().lower;
|
|
|
+ QCPGraphDataContainer::const_iterator it = begin;
|
|
|
+ int itIndex = beginIndex;
|
|
|
+ double minValue = it->value;
|
|
|
+ double maxValue = it->value;
|
|
|
+ QCPGraphDataContainer::const_iterator minValueIt = it;
|
|
|
+ QCPGraphDataContainer::const_iterator maxValueIt = it;
|
|
|
+ QCPGraphDataContainer::const_iterator currentIntervalStart = it;
|
|
|
+ int reversedFactor = keyAxis->pixelOrientation(); // is used to calculate keyEpsilon pixel into the correct direction
|
|
|
+ int reversedRound = reversedFactor==-1 ? 1 : 0; // is used to switch between floor (normal) and ceil (reversed) rounding of currentIntervalStartKey
|
|
|
+ double currentIntervalStartKey = keyAxis->pixelToCoord((int)(keyAxis->coordToPixel(begin->key)+reversedRound));
|
|
|
+ double keyEpsilon = qAbs(currentIntervalStartKey-keyAxis->pixelToCoord(keyAxis->coordToPixel(currentIntervalStartKey)+1.0*reversedFactor)); // interval of one pixel on screen when mapped to plot key coordinates
|
|
|
+ bool keyEpsilonVariable = keyAxis->scaleType() == QCPAxis::stLogarithmic; // indicates whether keyEpsilon needs to be updated after every interval (for log axes)
|
|
|
+ int intervalDataCount = 1;
|
|
|
+ // advance iterator to second (non-skipped) data point because adaptive sampling works in 1 point retrospect:
|
|
|
+ if (!doScatterSkip)
|
|
|
+ ++it;
|
|
|
+ else
|
|
|
+ {
|
|
|
+ itIndex += scatterModulo;
|
|
|
+ if (itIndex < endIndex) // make sure we didn't jump over end
|
|
|
+ it += scatterModulo;
|
|
|
+ else
|
|
|
+ {
|
|
|
+ it = end;
|
|
|
+ itIndex = endIndex;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ // main loop over data points:
|
|
|
+ while (it != end)
|
|
|
+ {
|
|
|
+ if (it->key < currentIntervalStartKey+keyEpsilon) // data point is still within same pixel, so skip it and expand value span of this pixel if necessary
|
|
|
+ {
|
|
|
+ if (it->value < minValue && it->value > valueMinRange && it->value < valueMaxRange)
|
|
|
+ {
|
|
|
+ minValue = it->value;
|
|
|
+ minValueIt = it;
|
|
|
+ } else if (it->value > maxValue && it->value > valueMinRange && it->value < valueMaxRange)
|
|
|
+ {
|
|
|
+ maxValue = it->value;
|
|
|
+ maxValueIt = it;
|
|
|
+ }
|
|
|
+ ++intervalDataCount;
|
|
|
+ } else // new pixel started
|
|
|
+ {
|
|
|
+ if (intervalDataCount >= 2) // last pixel had multiple data points, consolidate them
|
|
|
+ {
|
|
|
+ // determine value pixel span and add as many points in interval to maintain certain vertical data density (this is specific to scatter plot):
|
|
|
+ double valuePixelSpan = qAbs(valueAxis->coordToPixel(minValue)-valueAxis->coordToPixel(maxValue));
|
|
|
+ int dataModulo = qMax(1, qRound(intervalDataCount/(valuePixelSpan/4.0))); // approximately every 4 value pixels one data point on average
|
|
|
+ QCPGraphDataContainer::const_iterator intervalIt = currentIntervalStart;
|
|
|
+ int c = 0;
|
|
|
+ while (intervalIt != it)
|
|
|
+ {
|
|
|
+ if ((c % dataModulo == 0 || intervalIt == minValueIt || intervalIt == maxValueIt) && intervalIt->value > valueMinRange && intervalIt->value < valueMaxRange)
|
|
|
+ scatterData->append(*intervalIt);
|
|
|
+ ++c;
|
|
|
+ if (!doScatterSkip)
|
|
|
+ ++intervalIt;
|
|
|
+ else
|
|
|
+ intervalIt += scatterModulo; // since we know indices of "currentIntervalStart", "intervalIt" and "it" are multiples of scatterModulo, we can't accidentally jump over "it" here
|
|
|
+ }
|
|
|
+ } else if (currentIntervalStart->value > valueMinRange && currentIntervalStart->value < valueMaxRange)
|
|
|
+ scatterData->append(*currentIntervalStart);
|
|
|
+ minValue = it->value;
|
|
|
+ maxValue = it->value;
|
|
|
+ currentIntervalStart = it;
|
|
|
+ currentIntervalStartKey = keyAxis->pixelToCoord((int)(keyAxis->coordToPixel(it->key)+reversedRound));
|
|
|
+ if (keyEpsilonVariable)
|
|
|
+ keyEpsilon = qAbs(currentIntervalStartKey-keyAxis->pixelToCoord(keyAxis->coordToPixel(currentIntervalStartKey)+1.0*reversedFactor));
|
|
|
+ intervalDataCount = 1;
|
|
|
+ }
|
|
|
+ // advance to next data point:
|
|
|
+ if (!doScatterSkip)
|
|
|
+ ++it;
|
|
|
+ else
|
|
|
+ {
|
|
|
+ itIndex += scatterModulo;
|
|
|
+ if (itIndex < endIndex) // make sure we didn't jump over end
|
|
|
+ it += scatterModulo;
|
|
|
+ else
|
|
|
+ {
|
|
|
+ it = end;
|
|
|
+ itIndex = endIndex;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ // handle last interval:
|
|
|
+ if (intervalDataCount >= 2) // last pixel had multiple data points, consolidate them
|
|
|
+ {
|
|
|
+ // determine value pixel span and add as many points in interval to maintain certain vertical data density (this is specific to scatter plot):
|
|
|
+ double valuePixelSpan = qAbs(valueAxis->coordToPixel(minValue)-valueAxis->coordToPixel(maxValue));
|
|
|
+ int dataModulo = qMax(1, qRound(intervalDataCount/(valuePixelSpan/4.0))); // approximately every 4 value pixels one data point on average
|
|
|
+ QCPGraphDataContainer::const_iterator intervalIt = currentIntervalStart;
|
|
|
+ int intervalItIndex = intervalIt-mDataContainer->constBegin();
|
|
|
+ int c = 0;
|
|
|
+ while (intervalIt != it)
|
|
|
+ {
|
|
|
+ if ((c % dataModulo == 0 || intervalIt == minValueIt || intervalIt == maxValueIt) && intervalIt->value > valueMinRange && intervalIt->value < valueMaxRange)
|
|
|
+ scatterData->append(*intervalIt);
|
|
|
+ ++c;
|
|
|
+ if (!doScatterSkip)
|
|
|
+ ++intervalIt;
|
|
|
+ else // here we can't guarantee that adding scatterModulo doesn't exceed "it" (because "it" is equal to "end" here, and "end" isn't scatterModulo-aligned), so check via index comparison:
|
|
|
+ {
|
|
|
+ intervalItIndex += scatterModulo;
|
|
|
+ if (intervalItIndex < itIndex)
|
|
|
+ intervalIt += scatterModulo;
|
|
|
+ else
|
|
|
+ {
|
|
|
+ intervalIt = it;
|
|
|
+ intervalItIndex = itIndex;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } else if (currentIntervalStart->value > valueMinRange && currentIntervalStart->value < valueMaxRange)
|
|
|
+ scatterData->append(*currentIntervalStart);
|
|
|
+
|
|
|
+ } else // don't use adaptive sampling algorithm, transfer points one-to-one from the data container into the output
|
|
|
+ {
|
|
|
+ QCPGraphDataContainer::const_iterator it = begin;
|
|
|
+ int itIndex = beginIndex;
|
|
|
+ scatterData->reserve(dataCount);
|
|
|
+ while (it != end)
|
|
|
+ {
|
|
|
+ scatterData->append(*it);
|
|
|
+ // advance to next data point:
|
|
|
+ if (!doScatterSkip)
|
|
|
+ ++it;
|
|
|
+ else
|
|
|
+ {
|
|
|
+ itIndex += scatterModulo;
|
|
|
+ if (itIndex < endIndex)
|
|
|
+ it += scatterModulo;
|
|
|
+ else
|
|
|
+ {
|
|
|
+ it = end;
|
|
|
+ itIndex = endIndex;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ This method outputs the currently visible data range via \a begin and \a end. The returned range
|
|
|
+ will also never exceed \a rangeRestriction.
|
|
|
+
|
|
|
+ This method takes into account that the drawing of data lines at the axis rect border always
|
|
|
+ requires the points just outside the visible axis range. So \a begin and \a end may actually
|
|
|
+ indicate a range that contains one additional data point to the left and right of the visible
|
|
|
+ axis range.
|
|
|
+*/
|
|
|
+void QCPGraph::getVisibleDataBounds(QCPGraphDataContainer::const_iterator &begin, QCPGraphDataContainer::const_iterator &end, const QCPDataRange &rangeRestriction) const
|
|
|
+{
|
|
|
+ if (rangeRestriction.isEmpty())
|
|
|
+ {
|
|
|
+ end = mDataContainer->constEnd();
|
|
|
+ begin = end;
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ QCPAxis *keyAxis = mKeyAxis.data();
|
|
|
+ QCPAxis *valueAxis = mValueAxis.data();
|
|
|
+ if (!keyAxis || !valueAxis) { qDebug() << Q_FUNC_INFO << "invalid key or value axis"; return; }
|
|
|
+ // get visible data range:
|
|
|
+ begin = mDataContainer->findBegin(keyAxis->range().lower);
|
|
|
+ end = mDataContainer->findEnd(keyAxis->range().upper);
|
|
|
+ // limit lower/upperEnd to rangeRestriction:
|
|
|
+ mDataContainer->limitIteratorsToDataRange(begin, end, rangeRestriction); // this also ensures rangeRestriction outside data bounds doesn't break anything
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ This method goes through the passed points in \a lineData and returns a list of the segments
|
|
|
+ which don't contain NaN data points.
|
|
|
+
|
|
|
+ \a keyOrientation defines whether the \a x or \a y member of the passed QPointF is used to check
|
|
|
+ for NaN. If \a keyOrientation is \c Qt::Horizontal, the \a y member is checked, if it is \c
|
|
|
+ Qt::Vertical, the \a x member is checked.
|
|
|
+
|
|
|
+ \see getOverlappingSegments, drawFill
|
|
|
+*/
|
|
|
+QVector<QCPDataRange> QCPGraph::getNonNanSegments(const QVector<QPointF> *lineData, Qt::Orientation keyOrientation) const
|
|
|
+{
|
|
|
+ QVector<QCPDataRange> result;
|
|
|
+ const int n = lineData->size();
|
|
|
+
|
|
|
+ QCPDataRange currentSegment(-1, -1);
|
|
|
+ int i = 0;
|
|
|
+
|
|
|
+ if (keyOrientation == Qt::Horizontal)
|
|
|
+ {
|
|
|
+ while (i < n)
|
|
|
+ {
|
|
|
+ while (i < n && qIsNaN(lineData->at(i).y())) // seek next non-NaN data point
|
|
|
+ ++i;
|
|
|
+ if (i == n)
|
|
|
+ break;
|
|
|
+ currentSegment.setBegin(i++);
|
|
|
+ while (i < n && !qIsNaN(lineData->at(i).y())) // seek next NaN data point or end of data
|
|
|
+ ++i;
|
|
|
+ currentSegment.setEnd(i++);
|
|
|
+ result.append(currentSegment);
|
|
|
+ }
|
|
|
+ } else // keyOrientation == Qt::Vertical
|
|
|
+ {
|
|
|
+ while (i < n)
|
|
|
+ {
|
|
|
+ while (i < n && qIsNaN(lineData->at(i).x())) // seek next non-NaN data point
|
|
|
+ ++i;
|
|
|
+ if (i == n)
|
|
|
+ break;
|
|
|
+ currentSegment.setBegin(i++);
|
|
|
+ while (i < n && !qIsNaN(lineData->at(i).x())) // seek next NaN data point or end of data
|
|
|
+ ++i;
|
|
|
+ currentSegment.setEnd(i++);
|
|
|
+ result.append(currentSegment);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ This method takes two segment lists (e.g. created by \ref getNonNanSegments) \a thisSegments and
|
|
|
+ \a otherSegments, and their associated point data \a thisData and \a otherData.
|
|
|
+
|
|
|
+ It returns all pairs of segments (the first from \a thisSegments, the second from \a
|
|
|
+ otherSegments), which overlap in plot coordinates.
|
|
|
+
|
|
|
+ This method is useful in the case of a channel fill between two graphs, when only those non-NaN
|
|
|
+ segments which actually overlap in their key coordinate shall be considered for drawing a channel
|
|
|
+ fill polygon.
|
|
|
+
|
|
|
+ It is assumed that the passed segments in \a thisSegments are ordered ascending by index, and
|
|
|
+ that the segments don't overlap themselves. The same is assumed for the segments in \a
|
|
|
+ otherSegments. This is fulfilled when the segments are obtained via \ref getNonNanSegments.
|
|
|
+
|
|
|
+ \see getNonNanSegments, segmentsIntersect, drawFill, getChannelFillPolygon
|
|
|
+*/
|
|
|
+QVector<QPair<QCPDataRange, QCPDataRange> > QCPGraph::getOverlappingSegments(QVector<QCPDataRange> thisSegments, const QVector<QPointF> *thisData, QVector<QCPDataRange> otherSegments, const QVector<QPointF> *otherData) const
|
|
|
+{
|
|
|
+ QVector<QPair<QCPDataRange, QCPDataRange> > result;
|
|
|
+ if (thisData->isEmpty() || otherData->isEmpty() || thisSegments.isEmpty() || otherSegments.isEmpty())
|
|
|
+ return result;
|
|
|
+
|
|
|
+ int thisIndex = 0;
|
|
|
+ int otherIndex = 0;
|
|
|
+ const bool verticalKey = mKeyAxis->orientation() == Qt::Vertical;
|
|
|
+ while (thisIndex < thisSegments.size() && otherIndex < otherSegments.size())
|
|
|
+ {
|
|
|
+ if (thisSegments.at(thisIndex).size() < 2) // segments with fewer than two points won't have a fill anyhow
|
|
|
+ {
|
|
|
+ ++thisIndex;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ if (otherSegments.at(otherIndex).size() < 2) // segments with fewer than two points won't have a fill anyhow
|
|
|
+ {
|
|
|
+ ++otherIndex;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ double thisLower, thisUpper, otherLower, otherUpper;
|
|
|
+ if (!verticalKey)
|
|
|
+ {
|
|
|
+ thisLower = thisData->at(thisSegments.at(thisIndex).begin()).x();
|
|
|
+ thisUpper = thisData->at(thisSegments.at(thisIndex).end()-1).x();
|
|
|
+ otherLower = otherData->at(otherSegments.at(otherIndex).begin()).x();
|
|
|
+ otherUpper = otherData->at(otherSegments.at(otherIndex).end()-1).x();
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ thisLower = thisData->at(thisSegments.at(thisIndex).begin()).y();
|
|
|
+ thisUpper = thisData->at(thisSegments.at(thisIndex).end()-1).y();
|
|
|
+ otherLower = otherData->at(otherSegments.at(otherIndex).begin()).y();
|
|
|
+ otherUpper = otherData->at(otherSegments.at(otherIndex).end()-1).y();
|
|
|
+ }
|
|
|
+
|
|
|
+ int bPrecedence;
|
|
|
+ if (segmentsIntersect(thisLower, thisUpper, otherLower, otherUpper, bPrecedence))
|
|
|
+ result.append(QPair<QCPDataRange, QCPDataRange>(thisSegments.at(thisIndex), otherSegments.at(otherIndex)));
|
|
|
+
|
|
|
+ if (bPrecedence <= 0) // otherSegment doesn't reach as far as thisSegment, so continue with next otherSegment, keeping current thisSegment
|
|
|
+ ++otherIndex;
|
|
|
+ else // otherSegment reaches further than thisSegment, so continue with next thisSegment, keeping current otherSegment
|
|
|
+ ++thisIndex;
|
|
|
+ }
|
|
|
+
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns whether the segments defined by the coordinates (aLower, aUpper) and (bLower, bUpper)
|
|
|
+ have overlap.
|
|
|
+
|
|
|
+ The output parameter \a bPrecedence indicates whether the \a b segment reaches farther than the
|
|
|
+ \a a segment or not. If \a bPrecedence returns 1, segment \a b reaches the farthest to higher
|
|
|
+ coordinates (i.e. bUpper > aUpper). If it returns -1, segment \a a reaches the farthest. Only if
|
|
|
+ both segment's upper bounds are identical, 0 is returned as \a bPrecedence.
|
|
|
+
|
|
|
+ It is assumed that the lower bounds always have smaller or equal values than the upper bounds.
|
|
|
+
|
|
|
+ \see getOverlappingSegments
|
|
|
+*/
|
|
|
+bool QCPGraph::segmentsIntersect(double aLower, double aUpper, double bLower, double bUpper, int &bPrecedence) const
|
|
|
+{
|
|
|
+ bPrecedence = 0;
|
|
|
+ if (aLower > bUpper)
|
|
|
+ {
|
|
|
+ bPrecedence = -1;
|
|
|
+ return false;
|
|
|
+ } else if (bLower > aUpper)
|
|
|
+ {
|
|
|
+ bPrecedence = 1;
|
|
|
+ return false;
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ if (aUpper > bUpper)
|
|
|
+ bPrecedence = -1;
|
|
|
+ else if (aUpper < bUpper)
|
|
|
+ bPrecedence = 1;
|
|
|
+
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the point which closes the fill polygon on the zero-value-line parallel to the key axis.
|
|
|
+ The logarithmic axis scale case is a bit special, since the zero-value-line in pixel coordinates
|
|
|
+ is in positive or negative infinity. So this case is handled separately by just closing the fill
|
|
|
+ polygon on the axis which lies in the direction towards the zero value.
|
|
|
+
|
|
|
+ \a matchingDataPoint will provide the key (in pixels) of the returned point. Depending on whether
|
|
|
+ the key axis of this graph is horizontal or vertical, \a matchingDataPoint will provide the x or
|
|
|
+ y value of the returned point, respectively.
|
|
|
+*/
|
|
|
+QPointF QCPGraph::getFillBasePoint(QPointF matchingDataPoint) const
|
|
|
+{
|
|
|
+ QCPAxis *keyAxis = mKeyAxis.data();
|
|
|
+ QCPAxis *valueAxis = mValueAxis.data();
|
|
|
+ if (!keyAxis || !valueAxis) { qDebug() << Q_FUNC_INFO << "invalid key or value axis"; return QPointF(); }
|
|
|
+
|
|
|
+ QPointF result;
|
|
|
+ if (valueAxis->scaleType() == QCPAxis::stLinear)
|
|
|
+ {
|
|
|
+ if (keyAxis->orientation() == Qt::Horizontal)
|
|
|
+ {
|
|
|
+ result.setX(matchingDataPoint.x());
|
|
|
+ result.setY(valueAxis->coordToPixel(0));
|
|
|
+ } else // keyAxis->orientation() == Qt::Vertical
|
|
|
+ {
|
|
|
+ result.setX(valueAxis->coordToPixel(0));
|
|
|
+ result.setY(matchingDataPoint.y());
|
|
|
+ }
|
|
|
+ } else // valueAxis->mScaleType == QCPAxis::stLogarithmic
|
|
|
+ {
|
|
|
+ // In logarithmic scaling we can't just draw to value 0 so we just fill all the way
|
|
|
+ // to the axis which is in the direction towards 0
|
|
|
+ if (keyAxis->orientation() == Qt::Vertical)
|
|
|
+ {
|
|
|
+ if ((valueAxis->range().upper < 0 && !valueAxis->rangeReversed()) ||
|
|
|
+ (valueAxis->range().upper > 0 && valueAxis->rangeReversed())) // if range is negative, zero is on opposite side of key axis
|
|
|
+ result.setX(keyAxis->axisRect()->right());
|
|
|
+ else
|
|
|
+ result.setX(keyAxis->axisRect()->left());
|
|
|
+ result.setY(matchingDataPoint.y());
|
|
|
+ } else if (keyAxis->axisType() == QCPAxis::atTop || keyAxis->axisType() == QCPAxis::atBottom)
|
|
|
+ {
|
|
|
+ result.setX(matchingDataPoint.x());
|
|
|
+ if ((valueAxis->range().upper < 0 && !valueAxis->rangeReversed()) ||
|
|
|
+ (valueAxis->range().upper > 0 && valueAxis->rangeReversed())) // if range is negative, zero is on opposite side of key axis
|
|
|
+ result.setY(keyAxis->axisRect()->top());
|
|
|
+ else
|
|
|
+ result.setY(keyAxis->axisRect()->bottom());
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the polygon needed for drawing normal fills between this graph and the key axis.
|
|
|
+
|
|
|
+ Pass the graph's data points (in pixel coordinates) as \a lineData, and specify the \a segment
|
|
|
+ which shall be used for the fill. The collection of \a lineData points described by \a segment
|
|
|
+ must not contain NaN data points (see \ref getNonNanSegments).
|
|
|
+
|
|
|
+ The returned fill polygon will be closed at the key axis (the zero-value line) for linear value
|
|
|
+ axes. For logarithmic value axes the polygon will reach just beyond the corresponding axis rect
|
|
|
+ side (see \ref getFillBasePoint).
|
|
|
+
|
|
|
+ For increased performance (due to implicit sharing), keep the returned QPolygonF const.
|
|
|
+
|
|
|
+ \see drawFill, getNonNanSegments
|
|
|
+*/
|
|
|
+const QPolygonF QCPGraph::getFillPolygon(const QVector<QPointF> *lineData, QCPDataRange segment) const
|
|
|
+{
|
|
|
+ if (segment.size() < 2)
|
|
|
+ return QPolygonF();
|
|
|
+ QPolygonF result(segment.size()+2);
|
|
|
+
|
|
|
+ result[0] = getFillBasePoint(lineData->at(segment.begin()));
|
|
|
+ std::copy(lineData->constBegin()+segment.begin(), lineData->constBegin()+segment.end(), result.begin()+1);
|
|
|
+ result[result.size()-1] = getFillBasePoint(lineData->at(segment.end()-1));
|
|
|
+
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the polygon needed for drawing (partial) channel fills between this graph and the graph
|
|
|
+ specified by \ref setChannelFillGraph.
|
|
|
+
|
|
|
+ The data points of this graph are passed as pixel coordinates via \a thisData, the data of the
|
|
|
+ other graph as \a otherData. The returned polygon will be calculated for the specified data
|
|
|
+ segments \a thisSegment and \a otherSegment, pertaining to the respective \a thisData and \a
|
|
|
+ otherData, respectively.
|
|
|
+
|
|
|
+ The passed \a thisSegment and \a otherSegment should correspond to the segment pairs returned by
|
|
|
+ \ref getOverlappingSegments, to make sure only segments that actually have key coordinate overlap
|
|
|
+ need to be processed here.
|
|
|
+
|
|
|
+ For increased performance due to implicit sharing, keep the returned QPolygonF const.
|
|
|
+
|
|
|
+ \see drawFill, getOverlappingSegments, getNonNanSegments
|
|
|
+*/
|
|
|
+const QPolygonF QCPGraph::getChannelFillPolygon(const QVector<QPointF> *thisData, QCPDataRange thisSegment, const QVector<QPointF> *otherData, QCPDataRange otherSegment) const
|
|
|
+{
|
|
|
+ if (!mChannelFillGraph)
|
|
|
+ return QPolygonF();
|
|
|
+
|
|
|
+ QCPAxis *keyAxis = mKeyAxis.data();
|
|
|
+ QCPAxis *valueAxis = mValueAxis.data();
|
|
|
+ if (!keyAxis || !valueAxis) { qDebug() << Q_FUNC_INFO << "invalid key or value axis"; return QPolygonF(); }
|
|
|
+ if (!mChannelFillGraph.data()->mKeyAxis) { qDebug() << Q_FUNC_INFO << "channel fill target key axis invalid"; return QPolygonF(); }
|
|
|
+
|
|
|
+ if (mChannelFillGraph.data()->mKeyAxis.data()->orientation() != keyAxis->orientation())
|
|
|
+ return QPolygonF(); // don't have same axis orientation, can't fill that (Note: if keyAxis fits, valueAxis will fit too, because it's always orthogonal to keyAxis)
|
|
|
+
|
|
|
+ if (thisData->isEmpty()) return QPolygonF();
|
|
|
+ QVector<QPointF> thisSegmentData(thisSegment.size());
|
|
|
+ QVector<QPointF> otherSegmentData(otherSegment.size());
|
|
|
+ std::copy(thisData->constBegin()+thisSegment.begin(), thisData->constBegin()+thisSegment.end(), thisSegmentData.begin());
|
|
|
+ std::copy(otherData->constBegin()+otherSegment.begin(), otherData->constBegin()+otherSegment.end(), otherSegmentData.begin());
|
|
|
+ // pointers to be able to swap them, depending which data range needs cropping:
|
|
|
+ QVector<QPointF> *staticData = &thisSegmentData;
|
|
|
+ QVector<QPointF> *croppedData = &otherSegmentData;
|
|
|
+
|
|
|
+ // crop both vectors to ranges in which the keys overlap (which coord is key, depends on axisType):
|
|
|
+ if (keyAxis->orientation() == Qt::Horizontal)
|
|
|
+ {
|
|
|
+ // x is key
|
|
|
+ // crop lower bound:
|
|
|
+ if (staticData->first().x() < croppedData->first().x()) // other one must be cropped
|
|
|
+ qSwap(staticData, croppedData);
|
|
|
+ const int lowBound = findIndexBelowX(croppedData, staticData->first().x());
|
|
|
+ if (lowBound == -1) return QPolygonF(); // key ranges have no overlap
|
|
|
+ croppedData->remove(0, lowBound);
|
|
|
+ // set lowest point of cropped data to fit exactly key position of first static data point via linear interpolation:
|
|
|
+ if (croppedData->size() < 2) return QPolygonF(); // need at least two points for interpolation
|
|
|
+ double slope;
|
|
|
+ if (!qFuzzyCompare(croppedData->at(1).x(), croppedData->at(0).x()))
|
|
|
+ slope = (croppedData->at(1).y()-croppedData->at(0).y())/(croppedData->at(1).x()-croppedData->at(0).x());
|
|
|
+ else
|
|
|
+ slope = 0;
|
|
|
+ (*croppedData)[0].setY(croppedData->at(0).y()+slope*(staticData->first().x()-croppedData->at(0).x()));
|
|
|
+ (*croppedData)[0].setX(staticData->first().x());
|
|
|
+
|
|
|
+ // crop upper bound:
|
|
|
+ if (staticData->last().x() > croppedData->last().x()) // other one must be cropped
|
|
|
+ qSwap(staticData, croppedData);
|
|
|
+ int highBound = findIndexAboveX(croppedData, staticData->last().x());
|
|
|
+ if (highBound == -1) return QPolygonF(); // key ranges have no overlap
|
|
|
+ croppedData->remove(highBound+1, croppedData->size()-(highBound+1));
|
|
|
+ // set highest point of cropped data to fit exactly key position of last static data point via linear interpolation:
|
|
|
+ if (croppedData->size() < 2) return QPolygonF(); // need at least two points for interpolation
|
|
|
+ const int li = croppedData->size()-1; // last index
|
|
|
+ if (!qFuzzyCompare(croppedData->at(li).x(), croppedData->at(li-1).x()))
|
|
|
+ slope = (croppedData->at(li).y()-croppedData->at(li-1).y())/(croppedData->at(li).x()-croppedData->at(li-1).x());
|
|
|
+ else
|
|
|
+ slope = 0;
|
|
|
+ (*croppedData)[li].setY(croppedData->at(li-1).y()+slope*(staticData->last().x()-croppedData->at(li-1).x()));
|
|
|
+ (*croppedData)[li].setX(staticData->last().x());
|
|
|
+ } else // mKeyAxis->orientation() == Qt::Vertical
|
|
|
+ {
|
|
|
+ // y is key
|
|
|
+ // crop lower bound:
|
|
|
+ if (staticData->first().y() < croppedData->first().y()) // other one must be cropped
|
|
|
+ qSwap(staticData, croppedData);
|
|
|
+ int lowBound = findIndexBelowY(croppedData, staticData->first().y());
|
|
|
+ if (lowBound == -1) return QPolygonF(); // key ranges have no overlap
|
|
|
+ croppedData->remove(0, lowBound);
|
|
|
+ // set lowest point of cropped data to fit exactly key position of first static data point via linear interpolation:
|
|
|
+ if (croppedData->size() < 2) return QPolygonF(); // need at least two points for interpolation
|
|
|
+ double slope;
|
|
|
+ if (!qFuzzyCompare(croppedData->at(1).y(), croppedData->at(0).y())) // avoid division by zero in step plots
|
|
|
+ slope = (croppedData->at(1).x()-croppedData->at(0).x())/(croppedData->at(1).y()-croppedData->at(0).y());
|
|
|
+ else
|
|
|
+ slope = 0;
|
|
|
+ (*croppedData)[0].setX(croppedData->at(0).x()+slope*(staticData->first().y()-croppedData->at(0).y()));
|
|
|
+ (*croppedData)[0].setY(staticData->first().y());
|
|
|
+
|
|
|
+ // crop upper bound:
|
|
|
+ if (staticData->last().y() > croppedData->last().y()) // other one must be cropped
|
|
|
+ qSwap(staticData, croppedData);
|
|
|
+ int highBound = findIndexAboveY(croppedData, staticData->last().y());
|
|
|
+ if (highBound == -1) return QPolygonF(); // key ranges have no overlap
|
|
|
+ croppedData->remove(highBound+1, croppedData->size()-(highBound+1));
|
|
|
+ // set highest point of cropped data to fit exactly key position of last static data point via linear interpolation:
|
|
|
+ if (croppedData->size() < 2) return QPolygonF(); // need at least two points for interpolation
|
|
|
+ int li = croppedData->size()-1; // last index
|
|
|
+ if (!qFuzzyCompare(croppedData->at(li).y(), croppedData->at(li-1).y())) // avoid division by zero in step plots
|
|
|
+ slope = (croppedData->at(li).x()-croppedData->at(li-1).x())/(croppedData->at(li).y()-croppedData->at(li-1).y());
|
|
|
+ else
|
|
|
+ slope = 0;
|
|
|
+ (*croppedData)[li].setX(croppedData->at(li-1).x()+slope*(staticData->last().y()-croppedData->at(li-1).y()));
|
|
|
+ (*croppedData)[li].setY(staticData->last().y());
|
|
|
+ }
|
|
|
+
|
|
|
+ // return joined:
|
|
|
+ for (int i=otherSegmentData.size()-1; i>=0; --i) // insert reversed, otherwise the polygon will be twisted
|
|
|
+ thisSegmentData << otherSegmentData.at(i);
|
|
|
+ return QPolygonF(thisSegmentData);
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Finds the smallest index of \a data, whose points x value is just above \a x. Assumes x values in
|
|
|
+ \a data points are ordered ascending, as is ensured by \ref getLines/\ref getScatters if the key
|
|
|
+ axis is horizontal.
|
|
|
+
|
|
|
+ Used to calculate the channel fill polygon, see \ref getChannelFillPolygon.
|
|
|
+*/
|
|
|
+int QCPGraph::findIndexAboveX(const QVector<QPointF> *data, double x) const
|
|
|
+{
|
|
|
+ for (int i=data->size()-1; i>=0; --i)
|
|
|
+ {
|
|
|
+ if (data->at(i).x() < x)
|
|
|
+ {
|
|
|
+ if (i<data->size()-1)
|
|
|
+ return i+1;
|
|
|
+ else
|
|
|
+ return data->size()-1;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return -1;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Finds the highest index of \a data, whose points x value is just below \a x. Assumes x values in
|
|
|
+ \a data points are ordered ascending, as is ensured by \ref getLines/\ref getScatters if the key
|
|
|
+ axis is horizontal.
|
|
|
+
|
|
|
+ Used to calculate the channel fill polygon, see \ref getChannelFillPolygon.
|
|
|
+*/
|
|
|
+int QCPGraph::findIndexBelowX(const QVector<QPointF> *data, double x) const
|
|
|
+{
|
|
|
+ for (int i=0; i<data->size(); ++i)
|
|
|
+ {
|
|
|
+ if (data->at(i).x() > x)
|
|
|
+ {
|
|
|
+ if (i>0)
|
|
|
+ return i-1;
|
|
|
+ else
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return -1;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Finds the smallest index of \a data, whose points y value is just above \a y. Assumes y values in
|
|
|
+ \a data points are ordered ascending, as is ensured by \ref getLines/\ref getScatters if the key
|
|
|
+ axis is vertical.
|
|
|
+
|
|
|
+ Used to calculate the channel fill polygon, see \ref getChannelFillPolygon.
|
|
|
+*/
|
|
|
+int QCPGraph::findIndexAboveY(const QVector<QPointF> *data, double y) const
|
|
|
+{
|
|
|
+ for (int i=data->size()-1; i>=0; --i)
|
|
|
+ {
|
|
|
+ if (data->at(i).y() < y)
|
|
|
+ {
|
|
|
+ if (i<data->size()-1)
|
|
|
+ return i+1;
|
|
|
+ else
|
|
|
+ return data->size()-1;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return -1;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Calculates the minimum distance in pixels the graph's representation has from the given \a
|
|
|
+ pixelPoint. This is used to determine whether the graph was clicked or not, e.g. in \ref
|
|
|
+ selectTest. The closest data point to \a pixelPoint is returned in \a closestData. Note that if
|
|
|
+ the graph has a line representation, the returned distance may be smaller than the distance to
|
|
|
+ the \a closestData point, since the distance to the graph line is also taken into account.
|
|
|
+
|
|
|
+ If either the graph has no data or if the line style is \ref lsNone and the scatter style's shape
|
|
|
+ is \ref QCPScatterStyle::ssNone (i.e. there is no visual representation of the graph), returns -1.0.
|
|
|
+*/
|
|
|
+double QCPGraph::pointDistance(const QPointF &pixelPoint, QCPGraphDataContainer::const_iterator &closestData) const
|
|
|
+{
|
|
|
+ closestData = mDataContainer->constEnd();
|
|
|
+ if (mDataContainer->isEmpty())
|
|
|
+ return -1.0;
|
|
|
+ if (mLineStyle == lsNone && mScatterStyle.isNone())
|
|
|
+ return -1.0;
|
|
|
+
|
|
|
+ // calculate minimum distances to graph data points and find closestData iterator:
|
|
|
+ double minDistSqr = std::numeric_limits<double>::max();
|
|
|
+ // determine which key range comes into question, taking selection tolerance around pos into account:
|
|
|
+ double posKeyMin, posKeyMax, dummy;
|
|
|
+ pixelsToCoords(pixelPoint-QPointF(mParentPlot->selectionTolerance(), mParentPlot->selectionTolerance()), posKeyMin, dummy);
|
|
|
+ pixelsToCoords(pixelPoint+QPointF(mParentPlot->selectionTolerance(), mParentPlot->selectionTolerance()), posKeyMax, dummy);
|
|
|
+ if (posKeyMin > posKeyMax)
|
|
|
+ qSwap(posKeyMin, posKeyMax);
|
|
|
+ // iterate over found data points and then choose the one with the shortest distance to pos:
|
|
|
+ QCPGraphDataContainer::const_iterator begin = mDataContainer->findBegin(posKeyMin, true);
|
|
|
+ QCPGraphDataContainer::const_iterator end = mDataContainer->findEnd(posKeyMax, true);
|
|
|
+ for (QCPGraphDataContainer::const_iterator it=begin; it!=end; ++it)
|
|
|
+ {
|
|
|
+ const double currentDistSqr = QCPVector2D(coordsToPixels(it->key, it->value)-pixelPoint).lengthSquared();
|
|
|
+ if (currentDistSqr < minDistSqr)
|
|
|
+ {
|
|
|
+ minDistSqr = currentDistSqr;
|
|
|
+ closestData = it;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // calculate distance to graph line if there is one (if so, will probably be smaller than distance to closest data point):
|
|
|
+ if (mLineStyle != lsNone)
|
|
|
+ {
|
|
|
+ // line displayed, calculate distance to line segments:
|
|
|
+ QVector<QPointF> lineData;
|
|
|
+ getLines(&lineData, QCPDataRange(0, dataCount()));
|
|
|
+ QCPVector2D p(pixelPoint);
|
|
|
+ const int step = mLineStyle==lsImpulse ? 2 : 1; // impulse plot differs from other line styles in that the lineData points are only pairwise connected
|
|
|
+ for (int i=0; i<lineData.size()-1; i+=step)
|
|
|
+ {
|
|
|
+ const double currentDistSqr = p.distanceSquaredToLine(lineData.at(i), lineData.at(i+1));
|
|
|
+ if (currentDistSqr < minDistSqr)
|
|
|
+ minDistSqr = currentDistSqr;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return qSqrt(minDistSqr);
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Finds the highest index of \a data, whose points y value is just below \a y. Assumes y values in
|
|
|
+ \a data points are ordered ascending, as is ensured by \ref getLines/\ref getScatters if the key
|
|
|
+ axis is vertical.
|
|
|
+
|
|
|
+ Used to calculate the channel fill polygon, see \ref getChannelFillPolygon.
|
|
|
+*/
|
|
|
+int QCPGraph::findIndexBelowY(const QVector<QPointF> *data, double y) const
|
|
|
+{
|
|
|
+ for (int i=0; i<data->size(); ++i)
|
|
|
+ {
|
|
|
+ if (data->at(i).y() > y)
|
|
|
+ {
|
|
|
+ if (i>0)
|
|
|
+ return i-1;
|
|
|
+ else
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return -1;
|
|
|
+}
|
|
|
+/* end of 'src/plottables/plottable-graph.cpp' */
|
|
|
+
|
|
|
+
|
|
|
+/* including file 'src/plottables/plottable-curve.cpp', size 63527 */
|
|
|
+/* commit 9868e55d3b412f2f89766bb482fcf299e93a0988 2017-09-04 01:56:22 +0200 */
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPCurveData
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+/*! \class QCPCurveData
|
|
|
+ \brief Holds the data of one single data point for QCPCurve.
|
|
|
+
|
|
|
+ The stored data is:
|
|
|
+ \li \a t: the free ordering parameter of this curve point, like in the mathematical vector <em>(x(t), y(t))</em>. (This is the \a sortKey)
|
|
|
+ \li \a key: coordinate on the key axis of this curve point (this is the \a mainKey)
|
|
|
+ \li \a value: coordinate on the value axis of this curve point (this is the \a mainValue)
|
|
|
+
|
|
|
+ The container for storing multiple data points is \ref QCPCurveDataContainer. It is a typedef for
|
|
|
+ \ref QCPDataContainer with \ref QCPCurveData as the DataType template parameter. See the
|
|
|
+ documentation there for an explanation regarding the data type's generic methods.
|
|
|
+
|
|
|
+ \see QCPCurveDataContainer
|
|
|
+*/
|
|
|
+
|
|
|
+/* start documentation of inline functions */
|
|
|
+
|
|
|
+/*! \fn double QCPCurveData::sortKey() const
|
|
|
+
|
|
|
+ Returns the \a t member of this data point.
|
|
|
+
|
|
|
+ For a general explanation of what this method is good for in the context of the data container,
|
|
|
+ see the documentation of \ref QCPDataContainer.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn static QCPCurveData QCPCurveData::fromSortKey(double sortKey)
|
|
|
+
|
|
|
+ Returns a data point with the specified \a sortKey (assigned to the data point's \a t member).
|
|
|
+ All other members are set to zero.
|
|
|
+
|
|
|
+ For a general explanation of what this method is good for in the context of the data container,
|
|
|
+ see the documentation of \ref QCPDataContainer.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn static static bool QCPCurveData::sortKeyIsMainKey()
|
|
|
+
|
|
|
+ Since the member \a key is the data point key coordinate and the member \a t is the data ordering
|
|
|
+ parameter, this method returns false.
|
|
|
+
|
|
|
+ For a general explanation of what this method is good for in the context of the data container,
|
|
|
+ see the documentation of \ref QCPDataContainer.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn double QCPCurveData::mainKey() const
|
|
|
+
|
|
|
+ Returns the \a key member of this data point.
|
|
|
+
|
|
|
+ For a general explanation of what this method is good for in the context of the data container,
|
|
|
+ see the documentation of \ref QCPDataContainer.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn double QCPCurveData::mainValue() const
|
|
|
+
|
|
|
+ Returns the \a value member of this data point.
|
|
|
+
|
|
|
+ For a general explanation of what this method is good for in the context of the data container,
|
|
|
+ see the documentation of \ref QCPDataContainer.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn QCPRange QCPCurveData::valueRange() const
|
|
|
+
|
|
|
+ Returns a QCPRange with both lower and upper boundary set to \a value of this data point.
|
|
|
+
|
|
|
+ For a general explanation of what this method is good for in the context of the data container,
|
|
|
+ see the documentation of \ref QCPDataContainer.
|
|
|
+*/
|
|
|
+
|
|
|
+/* end documentation of inline functions */
|
|
|
+
|
|
|
+/*!
|
|
|
+ Constructs a curve data point with t, key and value set to zero.
|
|
|
+*/
|
|
|
+QCPCurveData::QCPCurveData() :
|
|
|
+ t(0),
|
|
|
+ key(0),
|
|
|
+ value(0)
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Constructs a curve data point with the specified \a t, \a key and \a value.
|
|
|
+*/
|
|
|
+QCPCurveData::QCPCurveData(double t, double key, double value) :
|
|
|
+ t(t),
|
|
|
+ key(key),
|
|
|
+ value(value)
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPCurve
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+/*! \class QCPCurve
|
|
|
+ \brief A plottable representing a parametric curve in a plot.
|
|
|
+
|
|
|
+ \image html QCPCurve.png
|
|
|
+
|
|
|
+ Unlike QCPGraph, plottables of this type may have multiple points with the same key coordinate,
|
|
|
+ so their visual representation can have \a loops. This is realized by introducing a third
|
|
|
+ coordinate \a t, which defines the order of the points described by the other two coordinates \a
|
|
|
+ x and \a y.
|
|
|
+
|
|
|
+ To plot data, assign it with the \ref setData or \ref addData functions. Alternatively, you can
|
|
|
+ also access and modify the curve's data via the \ref data method, which returns a pointer to the
|
|
|
+ internal \ref QCPCurveDataContainer.
|
|
|
+
|
|
|
+ Gaps in the curve can be created by adding data points with NaN as key and value
|
|
|
+ (<tt>qQNaN()</tt> or <tt>std::numeric_limits<double>::quiet_NaN()</tt>) in between the two data points that shall be
|
|
|
+ separated.
|
|
|
+
|
|
|
+ \section qcpcurve-appearance Changing the appearance
|
|
|
+
|
|
|
+ The appearance of the curve is determined by the pen and the brush (\ref setPen, \ref setBrush).
|
|
|
+
|
|
|
+ \section qcpcurve-usage Usage
|
|
|
+
|
|
|
+ Like all data representing objects in QCustomPlot, the QCPCurve is a plottable
|
|
|
+ (QCPAbstractPlottable). So the plottable-interface of QCustomPlot applies
|
|
|
+ (QCustomPlot::plottable, QCustomPlot::removePlottable, etc.)
|
|
|
+
|
|
|
+ Usually, you first create an instance:
|
|
|
+ \snippet documentation/doc-code-snippets/mainwindow.cpp qcpcurve-creation-1
|
|
|
+ which registers it with the QCustomPlot instance of the passed axes. Note that this QCustomPlot instance takes
|
|
|
+ ownership of the plottable, so do not delete it manually but use QCustomPlot::removePlottable() instead.
|
|
|
+ The newly created plottable can be modified, e.g.:
|
|
|
+ \snippet documentation/doc-code-snippets/mainwindow.cpp qcpcurve-creation-2
|
|
|
+*/
|
|
|
+
|
|
|
+/* start of documentation of inline functions */
|
|
|
+
|
|
|
+/*! \fn QSharedPointer<QCPCurveDataContainer> QCPCurve::data() const
|
|
|
+
|
|
|
+ Returns a shared pointer to the internal data storage of type \ref QCPCurveDataContainer. You may
|
|
|
+ use it to directly manipulate the data, which may be more convenient and faster than using the
|
|
|
+ regular \ref setData or \ref addData methods.
|
|
|
+*/
|
|
|
+
|
|
|
+/* end of documentation of inline functions */
|
|
|
+
|
|
|
+/*!
|
|
|
+ Constructs a curve which uses \a keyAxis as its key axis ("x") and \a valueAxis as its value
|
|
|
+ axis ("y"). \a keyAxis and \a valueAxis must reside in the same QCustomPlot instance and not have
|
|
|
+ the same orientation. If either of these restrictions is violated, a corresponding message is
|
|
|
+ printed to the debug output (qDebug), the construction is not aborted, though.
|
|
|
+
|
|
|
+ The created QCPCurve is automatically registered with the QCustomPlot instance inferred from \a
|
|
|
+ keyAxis. This QCustomPlot instance takes ownership of the QCPCurve, so do not delete it manually
|
|
|
+ but use QCustomPlot::removePlottable() instead.
|
|
|
+*/
|
|
|
+QCPCurve::QCPCurve(QCPAxis *keyAxis, QCPAxis *valueAxis) :
|
|
|
+ QCPAbstractPlottable1D<QCPCurveData>(keyAxis, valueAxis)
|
|
|
+{
|
|
|
+ // modify inherited properties from abstract plottable:
|
|
|
+ setPen(QPen(Qt::blue, 0));
|
|
|
+ setBrush(Qt::NoBrush);
|
|
|
+
|
|
|
+ setScatterStyle(QCPScatterStyle());
|
|
|
+ setLineStyle(lsLine);
|
|
|
+ setScatterSkip(0);
|
|
|
+}
|
|
|
+
|
|
|
+QCPCurve::~QCPCurve()
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Replaces the current data container with the provided \a data container.
|
|
|
+
|
|
|
+ Since a QSharedPointer is used, multiple QCPCurves may share the same data container safely.
|
|
|
+ Modifying the data in the container will then affect all curves that share the container. Sharing
|
|
|
+ can be achieved by simply exchanging the data containers wrapped in shared pointers:
|
|
|
+ \snippet documentation/doc-code-snippets/mainwindow.cpp qcpcurve-datasharing-1
|
|
|
+
|
|
|
+ If you do not wish to share containers, but create a copy from an existing container, rather use
|
|
|
+ the \ref QCPDataContainer<DataType>::set method on the curve's data container directly:
|
|
|
+ \snippet documentation/doc-code-snippets/mainwindow.cpp qcpcurve-datasharing-2
|
|
|
+
|
|
|
+ \see addData
|
|
|
+*/
|
|
|
+void QCPCurve::setData(QSharedPointer<QCPCurveDataContainer> data)
|
|
|
+{
|
|
|
+ mDataContainer = data;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Replaces the current data with the provided points in \a t, \a keys and \a values. The provided
|
|
|
+ vectors should have equal length. Else, the number of added points will be the size of the
|
|
|
+ smallest vector.
|
|
|
+
|
|
|
+ If you can guarantee that the passed data points are sorted by \a t in ascending order, you can
|
|
|
+ set \a alreadySorted to true, to improve performance by saving a sorting run.
|
|
|
+
|
|
|
+ \see addData
|
|
|
+*/
|
|
|
+void QCPCurve::setData(const QVector<double> &t, const QVector<double> &keys, const QVector<double> &values, bool alreadySorted)
|
|
|
+{
|
|
|
+ mDataContainer->clear();
|
|
|
+ addData(t, keys, values, alreadySorted);
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Replaces the current data with the provided points in \a keys and \a values. The provided vectors
|
|
|
+ should have equal length. Else, the number of added points will be the size of the smallest
|
|
|
+ vector.
|
|
|
+
|
|
|
+ The t parameter of each data point will be set to the integer index of the respective key/value
|
|
|
+ pair.
|
|
|
+
|
|
|
+ \see addData
|
|
|
+*/
|
|
|
+void QCPCurve::setData(const QVector<double> &keys, const QVector<double> &values)
|
|
|
+{
|
|
|
+ mDataContainer->clear();
|
|
|
+ addData(keys, values);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the visual appearance of single data points in the plot. If set to \ref
|
|
|
+ QCPScatterStyle::ssNone, no scatter points are drawn (e.g. for line-only plots with appropriate
|
|
|
+ line style).
|
|
|
+
|
|
|
+ \see QCPScatterStyle, setLineStyle
|
|
|
+*/
|
|
|
+void QCPCurve::setScatterStyle(const QCPScatterStyle &style)
|
|
|
+{
|
|
|
+ mScatterStyle = style;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ If scatters are displayed (scatter style not \ref QCPScatterStyle::ssNone), \a skip number of
|
|
|
+ scatter points are skipped/not drawn after every drawn scatter point.
|
|
|
+
|
|
|
+ This can be used to make the data appear sparser while for example still having a smooth line,
|
|
|
+ and to improve performance for very high density plots.
|
|
|
+
|
|
|
+ If \a skip is set to 0 (default), all scatter points are drawn.
|
|
|
+
|
|
|
+ \see setScatterStyle
|
|
|
+*/
|
|
|
+void QCPCurve::setScatterSkip(int skip)
|
|
|
+{
|
|
|
+ mScatterSkip = qMax(0, skip);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets how the single data points are connected in the plot or how they are represented visually
|
|
|
+ apart from the scatter symbol. For scatter-only plots, set \a style to \ref lsNone and \ref
|
|
|
+ setScatterStyle to the desired scatter style.
|
|
|
+
|
|
|
+ \see setScatterStyle
|
|
|
+*/
|
|
|
+void QCPCurve::setLineStyle(QCPCurve::LineStyle style)
|
|
|
+{
|
|
|
+ mLineStyle = style;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Adds the provided points in \a t, \a keys and \a values to the current data. The provided vectors
|
|
|
+ should have equal length. Else, the number of added points will be the size of the smallest
|
|
|
+ vector.
|
|
|
+
|
|
|
+ If you can guarantee that the passed data points are sorted by \a keys in ascending order, you
|
|
|
+ can set \a alreadySorted to true, to improve performance by saving a sorting run.
|
|
|
+
|
|
|
+ Alternatively, you can also access and modify the data directly via the \ref data method, which
|
|
|
+ returns a pointer to the internal data container.
|
|
|
+*/
|
|
|
+void QCPCurve::addData(const QVector<double> &t, const QVector<double> &keys, const QVector<double> &values, bool alreadySorted)
|
|
|
+{
|
|
|
+ if (t.size() != keys.size() || t.size() != values.size())
|
|
|
+ qDebug() << Q_FUNC_INFO << "ts, keys and values have different sizes:" << t.size() << keys.size() << values.size();
|
|
|
+ const int n = qMin(qMin(t.size(), keys.size()), values.size());
|
|
|
+ QVector<QCPCurveData> tempData(n);
|
|
|
+ QVector<QCPCurveData>::iterator it = tempData.begin();
|
|
|
+ const QVector<QCPCurveData>::iterator itEnd = tempData.end();
|
|
|
+ int i = 0;
|
|
|
+ while (it != itEnd)
|
|
|
+ {
|
|
|
+ it->t = t[i];
|
|
|
+ it->key = keys[i];
|
|
|
+ it->value = values[i];
|
|
|
+ ++it;
|
|
|
+ ++i;
|
|
|
+ }
|
|
|
+ mDataContainer->add(tempData, alreadySorted); // don't modify tempData beyond this to prevent copy on write
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Adds the provided points in \a keys and \a values to the current data. The provided vectors
|
|
|
+ should have equal length. Else, the number of added points will be the size of the smallest
|
|
|
+ vector.
|
|
|
+
|
|
|
+ The t parameter of each data point will be set to the integer index of the respective key/value
|
|
|
+ pair.
|
|
|
+
|
|
|
+ Alternatively, you can also access and modify the data directly via the \ref data method, which
|
|
|
+ returns a pointer to the internal data container.
|
|
|
+*/
|
|
|
+void QCPCurve::addData(const QVector<double> &keys, const QVector<double> &values)
|
|
|
+{
|
|
|
+ if (keys.size() != values.size())
|
|
|
+ qDebug() << Q_FUNC_INFO << "keys and values have different sizes:" << keys.size() << values.size();
|
|
|
+ const int n = qMin(keys.size(), values.size());
|
|
|
+ double tStart;
|
|
|
+ if (!mDataContainer->isEmpty())
|
|
|
+ tStart = (mDataContainer->constEnd()-1)->t + 1.0;
|
|
|
+ else
|
|
|
+ tStart = 0;
|
|
|
+ QVector<QCPCurveData> tempData(n);
|
|
|
+ QVector<QCPCurveData>::iterator it = tempData.begin();
|
|
|
+ const QVector<QCPCurveData>::iterator itEnd = tempData.end();
|
|
|
+ int i = 0;
|
|
|
+ while (it != itEnd)
|
|
|
+ {
|
|
|
+ it->t = tStart + i;
|
|
|
+ it->key = keys[i];
|
|
|
+ it->value = values[i];
|
|
|
+ ++it;
|
|
|
+ ++i;
|
|
|
+ }
|
|
|
+ mDataContainer->add(tempData, true); // don't modify tempData beyond this to prevent copy on write
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+ Adds the provided data point as \a t, \a key and \a value to the current data.
|
|
|
+
|
|
|
+ Alternatively, you can also access and modify the data directly via the \ref data method, which
|
|
|
+ returns a pointer to the internal data container.
|
|
|
+*/
|
|
|
+void QCPCurve::addData(double t, double key, double value)
|
|
|
+{
|
|
|
+ mDataContainer->add(QCPCurveData(t, key, value));
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Adds the provided data point as \a key and \a value to the current data.
|
|
|
+
|
|
|
+ The t parameter is generated automatically by increments of 1 for each point, starting at the
|
|
|
+ highest t of previously existing data or 0, if the curve data is empty.
|
|
|
+
|
|
|
+ Alternatively, you can also access and modify the data directly via the \ref data method, which
|
|
|
+ returns a pointer to the internal data container.
|
|
|
+*/
|
|
|
+void QCPCurve::addData(double key, double value)
|
|
|
+{
|
|
|
+ if (!mDataContainer->isEmpty())
|
|
|
+ mDataContainer->add(QCPCurveData((mDataContainer->constEnd()-1)->t + 1.0, key, value));
|
|
|
+ else
|
|
|
+ mDataContainer->add(QCPCurveData(0.0, key, value));
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+double QCPCurve::selectTest(const QPointF &pos, bool onlySelectable, QVariant *details) const
|
|
|
+{
|
|
|
+ if ((onlySelectable && mSelectable == QCP::stNone) || mDataContainer->isEmpty())
|
|
|
+ return -1;
|
|
|
+ if (!mKeyAxis || !mValueAxis)
|
|
|
+ return -1;
|
|
|
+
|
|
|
+ if (mKeyAxis.data()->axisRect()->rect().contains(pos.toPoint()))
|
|
|
+ {
|
|
|
+ QCPCurveDataContainer::const_iterator closestDataPoint = mDataContainer->constEnd();
|
|
|
+ double result = pointDistance(pos, closestDataPoint);
|
|
|
+ if (details)
|
|
|
+ {
|
|
|
+ int pointIndex = closestDataPoint-mDataContainer->constBegin();
|
|
|
+ details->setValue(QCPDataSelection(QCPDataRange(pointIndex, pointIndex+1)));
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+ } else
|
|
|
+ return -1;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+QCPRange QCPCurve::getKeyRange(bool &foundRange, QCP::SignDomain inSignDomain) const
|
|
|
+{
|
|
|
+ return mDataContainer->keyRange(foundRange, inSignDomain);
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+QCPRange QCPCurve::getValueRange(bool &foundRange, QCP::SignDomain inSignDomain, const QCPRange &inKeyRange) const
|
|
|
+{
|
|
|
+ return mDataContainer->valueRange(foundRange, inSignDomain, inKeyRange);
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPCurve::draw(QCPPainter *painter)
|
|
|
+{
|
|
|
+ if (mDataContainer->isEmpty()) return;
|
|
|
+
|
|
|
+ // allocate line vector:
|
|
|
+ QVector<QPointF> lines, scatters;
|
|
|
+
|
|
|
+ // loop over and draw segments of unselected/selected data:
|
|
|
+ QList<QCPDataRange> selectedSegments, unselectedSegments, allSegments;
|
|
|
+ getDataSegments(selectedSegments, unselectedSegments);
|
|
|
+ allSegments << unselectedSegments << selectedSegments;
|
|
|
+ for (int i=0; i<allSegments.size(); ++i)
|
|
|
+ {
|
|
|
+ bool isSelectedSegment = i >= unselectedSegments.size();
|
|
|
+
|
|
|
+ // fill with curve data:
|
|
|
+ QPen finalCurvePen = mPen; // determine the final pen already here, because the line optimization depends on its stroke width
|
|
|
+ if (isSelectedSegment && mSelectionDecorator)
|
|
|
+ finalCurvePen = mSelectionDecorator->pen();
|
|
|
+
|
|
|
+ QCPDataRange lineDataRange = isSelectedSegment ? allSegments.at(i) : allSegments.at(i).adjusted(-1, 1); // unselected segments extend lines to bordering selected data point (safe to exceed total data bounds in first/last segment, getCurveLines takes care)
|
|
|
+ getCurveLines(&lines, lineDataRange, finalCurvePen.widthF());
|
|
|
+
|
|
|
+ // check data validity if flag set:
|
|
|
+ #ifdef QCUSTOMPLOT_CHECK_DATA
|
|
|
+ for (QCPCurveDataContainer::const_iterator it = mDataContainer->constBegin(); it != mDataContainer->constEnd(); ++it)
|
|
|
+ {
|
|
|
+ if (QCP::isInvalidData(it->t) ||
|
|
|
+ QCP::isInvalidData(it->key, it->value))
|
|
|
+ qDebug() << Q_FUNC_INFO << "Data point at" << it->key << "invalid." << "Plottable name:" << name();
|
|
|
+ }
|
|
|
+ #endif
|
|
|
+
|
|
|
+ // draw curve fill:
|
|
|
+ applyFillAntialiasingHint(painter);
|
|
|
+ if (isSelectedSegment && mSelectionDecorator)
|
|
|
+ mSelectionDecorator->applyBrush(painter);
|
|
|
+ else
|
|
|
+ painter->setBrush(mBrush);
|
|
|
+ painter->setPen(Qt::NoPen);
|
|
|
+ if (painter->brush().style() != Qt::NoBrush && painter->brush().color().alpha() != 0)
|
|
|
+ painter->drawPolygon(QPolygonF(lines));
|
|
|
+
|
|
|
+ // draw curve line:
|
|
|
+ if (mLineStyle != lsNone)
|
|
|
+ {
|
|
|
+ painter->setPen(finalCurvePen);
|
|
|
+ painter->setBrush(Qt::NoBrush);
|
|
|
+ drawCurveLine(painter, lines);
|
|
|
+ }
|
|
|
+
|
|
|
+ // draw scatters:
|
|
|
+ QCPScatterStyle finalScatterStyle = mScatterStyle;
|
|
|
+ if (isSelectedSegment && mSelectionDecorator)
|
|
|
+ finalScatterStyle = mSelectionDecorator->getFinalScatterStyle(mScatterStyle);
|
|
|
+ if (!finalScatterStyle.isNone())
|
|
|
+ {
|
|
|
+ getScatters(&scatters, allSegments.at(i), finalScatterStyle.size());
|
|
|
+ drawScatterPlot(painter, scatters, finalScatterStyle);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // draw other selection decoration that isn't just line/scatter pens and brushes:
|
|
|
+ if (mSelectionDecorator)
|
|
|
+ mSelectionDecorator->drawDecoration(painter, selection());
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPCurve::drawLegendIcon(QCPPainter *painter, const QRectF &rect) const
|
|
|
+{
|
|
|
+ // draw fill:
|
|
|
+ if (mBrush.style() != Qt::NoBrush)
|
|
|
+ {
|
|
|
+ applyFillAntialiasingHint(painter);
|
|
|
+ painter->fillRect(QRectF(rect.left(), rect.top()+rect.height()/2.0, rect.width(), rect.height()/3.0), mBrush);
|
|
|
+ }
|
|
|
+ // draw line vertically centered:
|
|
|
+ if (mLineStyle != lsNone)
|
|
|
+ {
|
|
|
+ applyDefaultAntialiasingHint(painter);
|
|
|
+ painter->setPen(mPen);
|
|
|
+ painter->drawLine(QLineF(rect.left(), rect.top()+rect.height()/2.0, rect.right()+5, rect.top()+rect.height()/2.0)); // +5 on x2 else last segment is missing from dashed/dotted pens
|
|
|
+ }
|
|
|
+ // draw scatter symbol:
|
|
|
+ if (!mScatterStyle.isNone())
|
|
|
+ {
|
|
|
+ applyScattersAntialiasingHint(painter);
|
|
|
+ // scale scatter pixmap if it's too large to fit in legend icon rect:
|
|
|
+ if (mScatterStyle.shape() == QCPScatterStyle::ssPixmap && (mScatterStyle.pixmap().size().width() > rect.width() || mScatterStyle.pixmap().size().height() > rect.height()))
|
|
|
+ {
|
|
|
+ QCPScatterStyle scaledStyle(mScatterStyle);
|
|
|
+ scaledStyle.setPixmap(scaledStyle.pixmap().scaled(rect.size().toSize(), Qt::KeepAspectRatio, Qt::SmoothTransformation));
|
|
|
+ scaledStyle.applyTo(painter, mPen);
|
|
|
+ scaledStyle.drawShape(painter, QRectF(rect).center());
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ mScatterStyle.applyTo(painter, mPen);
|
|
|
+ mScatterStyle.drawShape(painter, QRectF(rect).center());
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Draws lines between the points in \a lines, given in pixel coordinates.
|
|
|
+
|
|
|
+ \see drawScatterPlot, getCurveLines
|
|
|
+*/
|
|
|
+void QCPCurve::drawCurveLine(QCPPainter *painter, const QVector<QPointF> &lines) const
|
|
|
+{
|
|
|
+ if (painter->pen().style() != Qt::NoPen && painter->pen().color().alpha() != 0)
|
|
|
+ {
|
|
|
+ applyDefaultAntialiasingHint(painter);
|
|
|
+ drawPolyline(painter, lines);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Draws scatter symbols at every point passed in \a points, given in pixel coordinates. The
|
|
|
+ scatters will be drawn with \a painter and have the appearance as specified in \a style.
|
|
|
+
|
|
|
+ \see drawCurveLine, getCurveLines
|
|
|
+*/
|
|
|
+void QCPCurve::drawScatterPlot(QCPPainter *painter, const QVector<QPointF> &points, const QCPScatterStyle &style) const
|
|
|
+{
|
|
|
+ // draw scatter point symbols:
|
|
|
+ applyScattersAntialiasingHint(painter);
|
|
|
+ style.applyTo(painter, mPen);
|
|
|
+ for (int i=0; i<points.size(); ++i)
|
|
|
+ if (!qIsNaN(points.at(i).x()) && !qIsNaN(points.at(i).y()))
|
|
|
+ style.drawShape(painter, points.at(i));
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Called by \ref draw to generate points in pixel coordinates which represent the line of the
|
|
|
+ curve.
|
|
|
+
|
|
|
+ Line segments that aren't visible in the current axis rect are handled in an optimized way. They
|
|
|
+ are projected onto a rectangle slightly larger than the visible axis rect and simplified
|
|
|
+ regarding point count. The algorithm makes sure to preserve appearance of lines and fills inside
|
|
|
+ the visible axis rect by generating new temporary points on the outer rect if necessary.
|
|
|
+
|
|
|
+ \a lines will be filled with points in pixel coordinates, that can be drawn with \ref
|
|
|
+ drawCurveLine.
|
|
|
+
|
|
|
+ \a dataRange specifies the beginning and ending data indices that will be taken into account for
|
|
|
+ conversion. In this function, the specified range may exceed the total data bounds without harm:
|
|
|
+ a correspondingly trimmed data range will be used. This takes the burden off the user of this
|
|
|
+ function to check for valid indices in \a dataRange, e.g. when extending ranges coming from \ref
|
|
|
+ getDataSegments.
|
|
|
+
|
|
|
+ \a penWidth specifies the pen width that will be used to later draw the lines generated by this
|
|
|
+ function. This is needed here to calculate an accordingly wider margin around the axis rect when
|
|
|
+ performing the line optimization.
|
|
|
+
|
|
|
+ Methods that are also involved in the algorithm are: \ref getRegion, \ref getOptimizedPoint, \ref
|
|
|
+ getOptimizedCornerPoints \ref mayTraverse, \ref getTraverse, \ref getTraverseCornerPoints.
|
|
|
+
|
|
|
+ \see drawCurveLine, drawScatterPlot
|
|
|
+*/
|
|
|
+void QCPCurve::getCurveLines(QVector<QPointF> *lines, const QCPDataRange &dataRange, double penWidth) const
|
|
|
+{
|
|
|
+ if (!lines) return;
|
|
|
+ lines->clear();
|
|
|
+ QCPAxis *keyAxis = mKeyAxis.data();
|
|
|
+ QCPAxis *valueAxis = mValueAxis.data();
|
|
|
+ if (!keyAxis || !valueAxis) { qDebug() << Q_FUNC_INFO << "invalid key or value axis"; return; }
|
|
|
+
|
|
|
+ // add margins to rect to compensate for stroke width
|
|
|
+ const double strokeMargin = qMax(qreal(1.0), qreal(penWidth*0.75)); // stroke radius + 50% safety
|
|
|
+ const double keyMin = keyAxis->pixelToCoord(keyAxis->coordToPixel(keyAxis->range().lower)-strokeMargin*keyAxis->pixelOrientation());
|
|
|
+ const double keyMax = keyAxis->pixelToCoord(keyAxis->coordToPixel(keyAxis->range().upper)+strokeMargin*keyAxis->pixelOrientation());
|
|
|
+ const double valueMin = valueAxis->pixelToCoord(valueAxis->coordToPixel(valueAxis->range().lower)-strokeMargin*valueAxis->pixelOrientation());
|
|
|
+ const double valueMax = valueAxis->pixelToCoord(valueAxis->coordToPixel(valueAxis->range().upper)+strokeMargin*valueAxis->pixelOrientation());
|
|
|
+ QCPCurveDataContainer::const_iterator itBegin = mDataContainer->constBegin();
|
|
|
+ QCPCurveDataContainer::const_iterator itEnd = mDataContainer->constEnd();
|
|
|
+ mDataContainer->limitIteratorsToDataRange(itBegin, itEnd, dataRange);
|
|
|
+ if (itBegin == itEnd)
|
|
|
+ return;
|
|
|
+ QCPCurveDataContainer::const_iterator it = itBegin;
|
|
|
+ QCPCurveDataContainer::const_iterator prevIt = itEnd-1;
|
|
|
+ int prevRegion = getRegion(prevIt->key, prevIt->value, keyMin, valueMax, keyMax, valueMin);
|
|
|
+ QVector<QPointF> trailingPoints; // points that must be applied after all other points (are generated only when handling first point to get virtual segment between last and first point right)
|
|
|
+ while (it != itEnd)
|
|
|
+ {
|
|
|
+ const int currentRegion = getRegion(it->key, it->value, keyMin, valueMax, keyMax, valueMin);
|
|
|
+ if (currentRegion != prevRegion) // changed region, possibly need to add some optimized edge points or original points if entering R
|
|
|
+ {
|
|
|
+ if (currentRegion != 5) // segment doesn't end in R, so it's a candidate for removal
|
|
|
+ {
|
|
|
+ QPointF crossA, crossB;
|
|
|
+ if (prevRegion == 5) // we're coming from R, so add this point optimized
|
|
|
+ {
|
|
|
+ lines->append(getOptimizedPoint(currentRegion, it->key, it->value, prevIt->key, prevIt->value, keyMin, valueMax, keyMax, valueMin));
|
|
|
+ // in the situations 5->1/7/9/3 the segment may leave R and directly cross through two outer regions. In these cases we need to add an additional corner point
|
|
|
+ *lines << getOptimizedCornerPoints(prevRegion, currentRegion, prevIt->key, prevIt->value, it->key, it->value, keyMin, valueMax, keyMax, valueMin);
|
|
|
+ } else if (mayTraverse(prevRegion, currentRegion) &&
|
|
|
+ getTraverse(prevIt->key, prevIt->value, it->key, it->value, keyMin, valueMax, keyMax, valueMin, crossA, crossB))
|
|
|
+ {
|
|
|
+ // add the two cross points optimized if segment crosses R and if segment isn't virtual zeroth segment between last and first curve point:
|
|
|
+ QVector<QPointF> beforeTraverseCornerPoints, afterTraverseCornerPoints;
|
|
|
+ getTraverseCornerPoints(prevRegion, currentRegion, keyMin, valueMax, keyMax, valueMin, beforeTraverseCornerPoints, afterTraverseCornerPoints);
|
|
|
+ if (it != itBegin)
|
|
|
+ {
|
|
|
+ *lines << beforeTraverseCornerPoints;
|
|
|
+ lines->append(crossA);
|
|
|
+ lines->append(crossB);
|
|
|
+ *lines << afterTraverseCornerPoints;
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ lines->append(crossB);
|
|
|
+ *lines << afterTraverseCornerPoints;
|
|
|
+ trailingPoints << beforeTraverseCornerPoints << crossA ;
|
|
|
+ }
|
|
|
+ } else // doesn't cross R, line is just moving around in outside regions, so only need to add optimized point(s) at the boundary corner(s)
|
|
|
+ {
|
|
|
+ *lines << getOptimizedCornerPoints(prevRegion, currentRegion, prevIt->key, prevIt->value, it->key, it->value, keyMin, valueMax, keyMax, valueMin);
|
|
|
+ }
|
|
|
+ } else // segment does end in R, so we add previous point optimized and this point at original position
|
|
|
+ {
|
|
|
+ if (it == itBegin) // it is first point in curve and prevIt is last one. So save optimized point for adding it to the lineData in the end
|
|
|
+ trailingPoints << getOptimizedPoint(prevRegion, prevIt->key, prevIt->value, it->key, it->value, keyMin, valueMax, keyMax, valueMin);
|
|
|
+ else
|
|
|
+ lines->append(getOptimizedPoint(prevRegion, prevIt->key, prevIt->value, it->key, it->value, keyMin, valueMax, keyMax, valueMin));
|
|
|
+ lines->append(coordsToPixels(it->key, it->value));
|
|
|
+ }
|
|
|
+ } else // region didn't change
|
|
|
+ {
|
|
|
+ if (currentRegion == 5) // still in R, keep adding original points
|
|
|
+ {
|
|
|
+ lines->append(coordsToPixels(it->key, it->value));
|
|
|
+ } else // still outside R, no need to add anything
|
|
|
+ {
|
|
|
+ // see how this is not doing anything? That's the main optimization...
|
|
|
+ }
|
|
|
+ }
|
|
|
+ prevIt = it;
|
|
|
+ prevRegion = currentRegion;
|
|
|
+ ++it;
|
|
|
+ }
|
|
|
+ *lines << trailingPoints;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Called by \ref draw to generate points in pixel coordinates which represent the scatters of the
|
|
|
+ curve. If a scatter skip is configured (\ref setScatterSkip), the returned points are accordingly
|
|
|
+ sparser.
|
|
|
+
|
|
|
+ Scatters that aren't visible in the current axis rect are optimized away.
|
|
|
+
|
|
|
+ \a scatters will be filled with points in pixel coordinates, that can be drawn with \ref
|
|
|
+ drawScatterPlot.
|
|
|
+
|
|
|
+ \a dataRange specifies the beginning and ending data indices that will be taken into account for
|
|
|
+ conversion.
|
|
|
+
|
|
|
+ \a scatterWidth specifies the scatter width that will be used to later draw the scatters at pixel
|
|
|
+ coordinates generated by this function. This is needed here to calculate an accordingly wider
|
|
|
+ margin around the axis rect when performing the data point reduction.
|
|
|
+
|
|
|
+ \see draw, drawScatterPlot
|
|
|
+*/
|
|
|
+void QCPCurve::getScatters(QVector<QPointF> *scatters, const QCPDataRange &dataRange, double scatterWidth) const
|
|
|
+{
|
|
|
+ if (!scatters) return;
|
|
|
+ scatters->clear();
|
|
|
+ QCPAxis *keyAxis = mKeyAxis.data();
|
|
|
+ QCPAxis *valueAxis = mValueAxis.data();
|
|
|
+ if (!keyAxis || !valueAxis) { qDebug() << Q_FUNC_INFO << "invalid key or value axis"; return; }
|
|
|
+
|
|
|
+ QCPCurveDataContainer::const_iterator begin = mDataContainer->constBegin();
|
|
|
+ QCPCurveDataContainer::const_iterator end = mDataContainer->constEnd();
|
|
|
+ mDataContainer->limitIteratorsToDataRange(begin, end, dataRange);
|
|
|
+ if (begin == end)
|
|
|
+ return;
|
|
|
+ const int scatterModulo = mScatterSkip+1;
|
|
|
+ const bool doScatterSkip = mScatterSkip > 0;
|
|
|
+ int endIndex = end-mDataContainer->constBegin();
|
|
|
+
|
|
|
+ QCPRange keyRange = keyAxis->range();
|
|
|
+ QCPRange valueRange = valueAxis->range();
|
|
|
+ // extend range to include width of scatter symbols:
|
|
|
+ keyRange.lower = keyAxis->pixelToCoord(keyAxis->coordToPixel(keyRange.lower)-scatterWidth*keyAxis->pixelOrientation());
|
|
|
+ keyRange.upper = keyAxis->pixelToCoord(keyAxis->coordToPixel(keyRange.upper)+scatterWidth*keyAxis->pixelOrientation());
|
|
|
+ valueRange.lower = valueAxis->pixelToCoord(valueAxis->coordToPixel(valueRange.lower)-scatterWidth*valueAxis->pixelOrientation());
|
|
|
+ valueRange.upper = valueAxis->pixelToCoord(valueAxis->coordToPixel(valueRange.upper)+scatterWidth*valueAxis->pixelOrientation());
|
|
|
+
|
|
|
+ QCPCurveDataContainer::const_iterator it = begin;
|
|
|
+ int itIndex = begin-mDataContainer->constBegin();
|
|
|
+ while (doScatterSkip && it != end && itIndex % scatterModulo != 0) // advance begin iterator to first non-skipped scatter
|
|
|
+ {
|
|
|
+ ++itIndex;
|
|
|
+ ++it;
|
|
|
+ }
|
|
|
+ if (keyAxis->orientation() == Qt::Vertical)
|
|
|
+ {
|
|
|
+ while (it != end)
|
|
|
+ {
|
|
|
+ if (!qIsNaN(it->value) && keyRange.contains(it->key) && valueRange.contains(it->value))
|
|
|
+ scatters->append(QPointF(valueAxis->coordToPixel(it->value), keyAxis->coordToPixel(it->key)));
|
|
|
+
|
|
|
+ // advance iterator to next (non-skipped) data point:
|
|
|
+ if (!doScatterSkip)
|
|
|
+ ++it;
|
|
|
+ else
|
|
|
+ {
|
|
|
+ itIndex += scatterModulo;
|
|
|
+ if (itIndex < endIndex) // make sure we didn't jump over end
|
|
|
+ it += scatterModulo;
|
|
|
+ else
|
|
|
+ {
|
|
|
+ it = end;
|
|
|
+ itIndex = endIndex;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ while (it != end)
|
|
|
+ {
|
|
|
+ if (!qIsNaN(it->value) && keyRange.contains(it->key) && valueRange.contains(it->value))
|
|
|
+ scatters->append(QPointF(keyAxis->coordToPixel(it->key), valueAxis->coordToPixel(it->value)));
|
|
|
+
|
|
|
+ // advance iterator to next (non-skipped) data point:
|
|
|
+ if (!doScatterSkip)
|
|
|
+ ++it;
|
|
|
+ else
|
|
|
+ {
|
|
|
+ itIndex += scatterModulo;
|
|
|
+ if (itIndex < endIndex) // make sure we didn't jump over end
|
|
|
+ it += scatterModulo;
|
|
|
+ else
|
|
|
+ {
|
|
|
+ it = end;
|
|
|
+ itIndex = endIndex;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ This function is part of the curve optimization algorithm of \ref getCurveLines.
|
|
|
+
|
|
|
+ It returns the region of the given point (\a key, \a value) with respect to a rectangle defined
|
|
|
+ by \a keyMin, \a keyMax, \a valueMin, and \a valueMax.
|
|
|
+
|
|
|
+ The regions are enumerated from top to bottom (\a valueMin to \a valueMax) and left to right (\a
|
|
|
+ keyMin to \a keyMax):
|
|
|
+
|
|
|
+ <table style="width:10em; text-align:center">
|
|
|
+ <tr><td>1</td><td>4</td><td>7</td></tr>
|
|
|
+ <tr><td>2</td><td style="border:1px solid black">5</td><td>8</td></tr>
|
|
|
+ <tr><td>3</td><td>6</td><td>9</td></tr>
|
|
|
+ </table>
|
|
|
+
|
|
|
+ With the rectangle being region 5, and the outer regions extending infinitely outwards. In the
|
|
|
+ curve optimization algorithm, region 5 is considered to be the visible portion of the plot.
|
|
|
+*/
|
|
|
+int QCPCurve::getRegion(double key, double value, double keyMin, double valueMax, double keyMax, double valueMin) const
|
|
|
+{
|
|
|
+ if (key < keyMin) // region 123
|
|
|
+ {
|
|
|
+ if (value > valueMax)
|
|
|
+ return 1;
|
|
|
+ else if (value < valueMin)
|
|
|
+ return 3;
|
|
|
+ else
|
|
|
+ return 2;
|
|
|
+ } else if (key > keyMax) // region 789
|
|
|
+ {
|
|
|
+ if (value > valueMax)
|
|
|
+ return 7;
|
|
|
+ else if (value < valueMin)
|
|
|
+ return 9;
|
|
|
+ else
|
|
|
+ return 8;
|
|
|
+ } else // region 456
|
|
|
+ {
|
|
|
+ if (value > valueMax)
|
|
|
+ return 4;
|
|
|
+ else if (value < valueMin)
|
|
|
+ return 6;
|
|
|
+ else
|
|
|
+ return 5;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ This function is part of the curve optimization algorithm of \ref getCurveLines.
|
|
|
+
|
|
|
+ This method is used in case the current segment passes from inside the visible rect (region 5,
|
|
|
+ see \ref getRegion) to any of the outer regions (\a otherRegion). The current segment is given by
|
|
|
+ the line connecting (\a key, \a value) with (\a otherKey, \a otherValue).
|
|
|
+
|
|
|
+ It returns the intersection point of the segment with the border of region 5.
|
|
|
+
|
|
|
+ For this function it doesn't matter whether (\a key, \a value) is the point inside region 5 or
|
|
|
+ whether it's (\a otherKey, \a otherValue), i.e. whether the segment is coming from region 5 or
|
|
|
+ leaving it. It is important though that \a otherRegion correctly identifies the other region not
|
|
|
+ equal to 5.
|
|
|
+*/
|
|
|
+QPointF QCPCurve::getOptimizedPoint(int otherRegion, double otherKey, double otherValue, double key, double value, double keyMin, double valueMax, double keyMax, double valueMin) const
|
|
|
+{
|
|
|
+ // The intersection point interpolation here is done in pixel coordinates, so we don't need to
|
|
|
+ // differentiate between different axis scale types. Note that the nomenclature
|
|
|
+ // top/left/bottom/right/min/max is with respect to the rect in plot coordinates, wich may be
|
|
|
+ // different in pixel coordinates (horz/vert key axes, reversed ranges)
|
|
|
+
|
|
|
+ const double keyMinPx = mKeyAxis->coordToPixel(keyMin);
|
|
|
+ const double keyMaxPx = mKeyAxis->coordToPixel(keyMax);
|
|
|
+ const double valueMinPx = mValueAxis->coordToPixel(valueMin);
|
|
|
+ const double valueMaxPx = mValueAxis->coordToPixel(valueMax);
|
|
|
+ const double otherValuePx = mValueAxis->coordToPixel(otherValue);
|
|
|
+ const double valuePx = mValueAxis->coordToPixel(value);
|
|
|
+ const double otherKeyPx = mKeyAxis->coordToPixel(otherKey);
|
|
|
+ const double keyPx = mKeyAxis->coordToPixel(key);
|
|
|
+ double intersectKeyPx = keyMinPx; // initial key just a fail-safe
|
|
|
+ double intersectValuePx = valueMinPx; // initial value just a fail-safe
|
|
|
+ switch (otherRegion)
|
|
|
+ {
|
|
|
+ case 1: // top and left edge
|
|
|
+ {
|
|
|
+ intersectValuePx = valueMaxPx;
|
|
|
+ intersectKeyPx = otherKeyPx + (keyPx-otherKeyPx)/(valuePx-otherValuePx)*(intersectValuePx-otherValuePx);
|
|
|
+ if (intersectKeyPx < qMin(keyMinPx, keyMaxPx) || intersectKeyPx > qMax(keyMinPx, keyMaxPx)) // check whether top edge is not intersected, then it must be left edge (qMin/qMax necessary since axes may be reversed)
|
|
|
+ {
|
|
|
+ intersectKeyPx = keyMinPx;
|
|
|
+ intersectValuePx = otherValuePx + (valuePx-otherValuePx)/(keyPx-otherKeyPx)*(intersectKeyPx-otherKeyPx);
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case 2: // left edge
|
|
|
+ {
|
|
|
+ intersectKeyPx = keyMinPx;
|
|
|
+ intersectValuePx = otherValuePx + (valuePx-otherValuePx)/(keyPx-otherKeyPx)*(intersectKeyPx-otherKeyPx);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case 3: // bottom and left edge
|
|
|
+ {
|
|
|
+ intersectValuePx = valueMinPx;
|
|
|
+ intersectKeyPx = otherKeyPx + (keyPx-otherKeyPx)/(valuePx-otherValuePx)*(intersectValuePx-otherValuePx);
|
|
|
+ if (intersectKeyPx < qMin(keyMinPx, keyMaxPx) || intersectKeyPx > qMax(keyMinPx, keyMaxPx)) // check whether bottom edge is not intersected, then it must be left edge (qMin/qMax necessary since axes may be reversed)
|
|
|
+ {
|
|
|
+ intersectKeyPx = keyMinPx;
|
|
|
+ intersectValuePx = otherValuePx + (valuePx-otherValuePx)/(keyPx-otherKeyPx)*(intersectKeyPx-otherKeyPx);
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case 4: // top edge
|
|
|
+ {
|
|
|
+ intersectValuePx = valueMaxPx;
|
|
|
+ intersectKeyPx = otherKeyPx + (keyPx-otherKeyPx)/(valuePx-otherValuePx)*(intersectValuePx-otherValuePx);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case 5:
|
|
|
+ {
|
|
|
+ break; // case 5 shouldn't happen for this function but we add it anyway to prevent potential discontinuity in branch table
|
|
|
+ }
|
|
|
+ case 6: // bottom edge
|
|
|
+ {
|
|
|
+ intersectValuePx = valueMinPx;
|
|
|
+ intersectKeyPx = otherKeyPx + (keyPx-otherKeyPx)/(valuePx-otherValuePx)*(intersectValuePx-otherValuePx);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case 7: // top and right edge
|
|
|
+ {
|
|
|
+ intersectValuePx = valueMaxPx;
|
|
|
+ intersectKeyPx = otherKeyPx + (keyPx-otherKeyPx)/(valuePx-otherValuePx)*(intersectValuePx-otherValuePx);
|
|
|
+ if (intersectKeyPx < qMin(keyMinPx, keyMaxPx) || intersectKeyPx > qMax(keyMinPx, keyMaxPx)) // check whether top edge is not intersected, then it must be right edge (qMin/qMax necessary since axes may be reversed)
|
|
|
+ {
|
|
|
+ intersectKeyPx = keyMaxPx;
|
|
|
+ intersectValuePx = otherValuePx + (valuePx-otherValuePx)/(keyPx-otherKeyPx)*(intersectKeyPx-otherKeyPx);
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case 8: // right edge
|
|
|
+ {
|
|
|
+ intersectKeyPx = keyMaxPx;
|
|
|
+ intersectValuePx = otherValuePx + (valuePx-otherValuePx)/(keyPx-otherKeyPx)*(intersectKeyPx-otherKeyPx);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case 9: // bottom and right edge
|
|
|
+ {
|
|
|
+ intersectValuePx = valueMinPx;
|
|
|
+ intersectKeyPx = otherKeyPx + (keyPx-otherKeyPx)/(valuePx-otherValuePx)*(intersectValuePx-otherValuePx);
|
|
|
+ if (intersectKeyPx < qMin(keyMinPx, keyMaxPx) || intersectKeyPx > qMax(keyMinPx, keyMaxPx)) // check whether bottom edge is not intersected, then it must be right edge (qMin/qMax necessary since axes may be reversed)
|
|
|
+ {
|
|
|
+ intersectKeyPx = keyMaxPx;
|
|
|
+ intersectValuePx = otherValuePx + (valuePx-otherValuePx)/(keyPx-otherKeyPx)*(intersectKeyPx-otherKeyPx);
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (mKeyAxis->orientation() == Qt::Horizontal)
|
|
|
+ return QPointF(intersectKeyPx, intersectValuePx);
|
|
|
+ else
|
|
|
+ return QPointF(intersectValuePx, intersectKeyPx);
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ This function is part of the curve optimization algorithm of \ref getCurveLines.
|
|
|
+
|
|
|
+ In situations where a single segment skips over multiple regions it might become necessary to add
|
|
|
+ extra points at the corners of region 5 (see \ref getRegion) such that the optimized segment
|
|
|
+ doesn't unintentionally cut through the visible area of the axis rect and create plot artifacts.
|
|
|
+ This method provides these points that must be added, assuming the original segment doesn't
|
|
|
+ start, end, or traverse region 5. (Corner points where region 5 is traversed are calculated by
|
|
|
+ \ref getTraverseCornerPoints.)
|
|
|
+
|
|
|
+ For example, consider a segment which directly goes from region 4 to 2 but originally is far out
|
|
|
+ to the top left such that it doesn't cross region 5. Naively optimizing these points by
|
|
|
+ projecting them on the top and left borders of region 5 will create a segment that surely crosses
|
|
|
+ 5, creating a visual artifact in the plot. This method prevents this by providing extra points at
|
|
|
+ the top left corner, making the optimized curve correctly pass from region 4 to 1 to 2 without
|
|
|
+ traversing 5.
|
|
|
+*/
|
|
|
+QVector<QPointF> QCPCurve::getOptimizedCornerPoints(int prevRegion, int currentRegion, double prevKey, double prevValue, double key, double value, double keyMin, double valueMax, double keyMax, double valueMin) const
|
|
|
+{
|
|
|
+ QVector<QPointF> result;
|
|
|
+ switch (prevRegion)
|
|
|
+ {
|
|
|
+ case 1:
|
|
|
+ {
|
|
|
+ switch (currentRegion)
|
|
|
+ {
|
|
|
+ case 2: { result << coordsToPixels(keyMin, valueMax); break; }
|
|
|
+ case 4: { result << coordsToPixels(keyMin, valueMax); break; }
|
|
|
+ case 3: { result << coordsToPixels(keyMin, valueMax) << coordsToPixels(keyMin, valueMin); break; }
|
|
|
+ case 7: { result << coordsToPixels(keyMin, valueMax) << coordsToPixels(keyMax, valueMax); break; }
|
|
|
+ case 6: { result << coordsToPixels(keyMin, valueMax) << coordsToPixels(keyMin, valueMin); result.append(result.last()); break; }
|
|
|
+ case 8: { result << coordsToPixels(keyMin, valueMax) << coordsToPixels(keyMax, valueMax); result.append(result.last()); break; }
|
|
|
+ case 9: { // in this case we need another distinction of cases: segment may pass below or above rect, requiring either bottom right or top left corner points
|
|
|
+ if ((value-prevValue)/(key-prevKey)*(keyMin-key)+value < valueMin) // segment passes below R
|
|
|
+ { result << coordsToPixels(keyMin, valueMax) << coordsToPixels(keyMin, valueMin); result.append(result.last()); result << coordsToPixels(keyMax, valueMin); }
|
|
|
+ else
|
|
|
+ { result << coordsToPixels(keyMin, valueMax) << coordsToPixels(keyMax, valueMax); result.append(result.last()); result << coordsToPixels(keyMax, valueMin); }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case 2:
|
|
|
+ {
|
|
|
+ switch (currentRegion)
|
|
|
+ {
|
|
|
+ case 1: { result << coordsToPixels(keyMin, valueMax); break; }
|
|
|
+ case 3: { result << coordsToPixels(keyMin, valueMin); break; }
|
|
|
+ case 4: { result << coordsToPixels(keyMin, valueMax); result.append(result.last()); break; }
|
|
|
+ case 6: { result << coordsToPixels(keyMin, valueMin); result.append(result.last()); break; }
|
|
|
+ case 7: { result << coordsToPixels(keyMin, valueMax); result.append(result.last()); result << coordsToPixels(keyMax, valueMax); break; }
|
|
|
+ case 9: { result << coordsToPixels(keyMin, valueMin); result.append(result.last()); result << coordsToPixels(keyMax, valueMin); break; }
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case 3:
|
|
|
+ {
|
|
|
+ switch (currentRegion)
|
|
|
+ {
|
|
|
+ case 2: { result << coordsToPixels(keyMin, valueMin); break; }
|
|
|
+ case 6: { result << coordsToPixels(keyMin, valueMin); break; }
|
|
|
+ case 1: { result << coordsToPixels(keyMin, valueMin) << coordsToPixels(keyMin, valueMax); break; }
|
|
|
+ case 9: { result << coordsToPixels(keyMin, valueMin) << coordsToPixels(keyMax, valueMin); break; }
|
|
|
+ case 4: { result << coordsToPixels(keyMin, valueMin) << coordsToPixels(keyMin, valueMax); result.append(result.last()); break; }
|
|
|
+ case 8: { result << coordsToPixels(keyMin, valueMin) << coordsToPixels(keyMax, valueMin); result.append(result.last()); break; }
|
|
|
+ case 7: { // in this case we need another distinction of cases: segment may pass below or above rect, requiring either bottom right or top left corner points
|
|
|
+ if ((value-prevValue)/(key-prevKey)*(keyMax-key)+value < valueMin) // segment passes below R
|
|
|
+ { result << coordsToPixels(keyMin, valueMin) << coordsToPixels(keyMax, valueMin); result.append(result.last()); result << coordsToPixels(keyMax, valueMax); }
|
|
|
+ else
|
|
|
+ { result << coordsToPixels(keyMin, valueMin) << coordsToPixels(keyMin, valueMax); result.append(result.last()); result << coordsToPixels(keyMax, valueMax); }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case 4:
|
|
|
+ {
|
|
|
+ switch (currentRegion)
|
|
|
+ {
|
|
|
+ case 1: { result << coordsToPixels(keyMin, valueMax); break; }
|
|
|
+ case 7: { result << coordsToPixels(keyMax, valueMax); break; }
|
|
|
+ case 2: { result << coordsToPixels(keyMin, valueMax); result.append(result.last()); break; }
|
|
|
+ case 8: { result << coordsToPixels(keyMax, valueMax); result.append(result.last()); break; }
|
|
|
+ case 3: { result << coordsToPixels(keyMin, valueMax); result.append(result.last()); result << coordsToPixels(keyMin, valueMin); break; }
|
|
|
+ case 9: { result << coordsToPixels(keyMax, valueMax); result.append(result.last()); result << coordsToPixels(keyMax, valueMin); break; }
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case 5:
|
|
|
+ {
|
|
|
+ switch (currentRegion)
|
|
|
+ {
|
|
|
+ case 1: { result << coordsToPixels(keyMin, valueMax); break; }
|
|
|
+ case 7: { result << coordsToPixels(keyMax, valueMax); break; }
|
|
|
+ case 9: { result << coordsToPixels(keyMax, valueMin); break; }
|
|
|
+ case 3: { result << coordsToPixels(keyMin, valueMin); break; }
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case 6:
|
|
|
+ {
|
|
|
+ switch (currentRegion)
|
|
|
+ {
|
|
|
+ case 3: { result << coordsToPixels(keyMin, valueMin); break; }
|
|
|
+ case 9: { result << coordsToPixels(keyMax, valueMin); break; }
|
|
|
+ case 2: { result << coordsToPixels(keyMin, valueMin); result.append(result.last()); break; }
|
|
|
+ case 8: { result << coordsToPixels(keyMax, valueMin); result.append(result.last()); break; }
|
|
|
+ case 1: { result << coordsToPixels(keyMin, valueMin); result.append(result.last()); result << coordsToPixels(keyMin, valueMax); break; }
|
|
|
+ case 7: { result << coordsToPixels(keyMax, valueMin); result.append(result.last()); result << coordsToPixels(keyMax, valueMax); break; }
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case 7:
|
|
|
+ {
|
|
|
+ switch (currentRegion)
|
|
|
+ {
|
|
|
+ case 4: { result << coordsToPixels(keyMax, valueMax); break; }
|
|
|
+ case 8: { result << coordsToPixels(keyMax, valueMax); break; }
|
|
|
+ case 1: { result << coordsToPixels(keyMax, valueMax) << coordsToPixels(keyMin, valueMax); break; }
|
|
|
+ case 9: { result << coordsToPixels(keyMax, valueMax) << coordsToPixels(keyMax, valueMin); break; }
|
|
|
+ case 2: { result << coordsToPixels(keyMax, valueMax) << coordsToPixels(keyMin, valueMax); result.append(result.last()); break; }
|
|
|
+ case 6: { result << coordsToPixels(keyMax, valueMax) << coordsToPixels(keyMax, valueMin); result.append(result.last()); break; }
|
|
|
+ case 3: { // in this case we need another distinction of cases: segment may pass below or above rect, requiring either bottom right or top left corner points
|
|
|
+ if ((value-prevValue)/(key-prevKey)*(keyMax-key)+value < valueMin) // segment passes below R
|
|
|
+ { result << coordsToPixels(keyMax, valueMax) << coordsToPixels(keyMax, valueMin); result.append(result.last()); result << coordsToPixels(keyMin, valueMin); }
|
|
|
+ else
|
|
|
+ { result << coordsToPixels(keyMax, valueMax) << coordsToPixels(keyMin, valueMax); result.append(result.last()); result << coordsToPixels(keyMin, valueMin); }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case 8:
|
|
|
+ {
|
|
|
+ switch (currentRegion)
|
|
|
+ {
|
|
|
+ case 7: { result << coordsToPixels(keyMax, valueMax); break; }
|
|
|
+ case 9: { result << coordsToPixels(keyMax, valueMin); break; }
|
|
|
+ case 4: { result << coordsToPixels(keyMax, valueMax); result.append(result.last()); break; }
|
|
|
+ case 6: { result << coordsToPixels(keyMax, valueMin); result.append(result.last()); break; }
|
|
|
+ case 1: { result << coordsToPixels(keyMax, valueMax); result.append(result.last()); result << coordsToPixels(keyMin, valueMax); break; }
|
|
|
+ case 3: { result << coordsToPixels(keyMax, valueMin); result.append(result.last()); result << coordsToPixels(keyMin, valueMin); break; }
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case 9:
|
|
|
+ {
|
|
|
+ switch (currentRegion)
|
|
|
+ {
|
|
|
+ case 6: { result << coordsToPixels(keyMax, valueMin); break; }
|
|
|
+ case 8: { result << coordsToPixels(keyMax, valueMin); break; }
|
|
|
+ case 3: { result << coordsToPixels(keyMax, valueMin) << coordsToPixels(keyMin, valueMin); break; }
|
|
|
+ case 7: { result << coordsToPixels(keyMax, valueMin) << coordsToPixels(keyMax, valueMax); break; }
|
|
|
+ case 2: { result << coordsToPixels(keyMax, valueMin) << coordsToPixels(keyMin, valueMin); result.append(result.last()); break; }
|
|
|
+ case 4: { result << coordsToPixels(keyMax, valueMin) << coordsToPixels(keyMax, valueMax); result.append(result.last()); break; }
|
|
|
+ case 1: { // in this case we need another distinction of cases: segment may pass below or above rect, requiring either bottom right or top left corner points
|
|
|
+ if ((value-prevValue)/(key-prevKey)*(keyMin-key)+value < valueMin) // segment passes below R
|
|
|
+ { result << coordsToPixels(keyMax, valueMin) << coordsToPixels(keyMin, valueMin); result.append(result.last()); result << coordsToPixels(keyMin, valueMax); }
|
|
|
+ else
|
|
|
+ { result << coordsToPixels(keyMax, valueMin) << coordsToPixels(keyMax, valueMax); result.append(result.last()); result << coordsToPixels(keyMin, valueMax); }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ This function is part of the curve optimization algorithm of \ref getCurveLines.
|
|
|
+
|
|
|
+ This method returns whether a segment going from \a prevRegion to \a currentRegion (see \ref
|
|
|
+ getRegion) may traverse the visible region 5. This function assumes that neither \a prevRegion
|
|
|
+ nor \a currentRegion is 5 itself.
|
|
|
+
|
|
|
+ If this method returns false, the segment for sure doesn't pass region 5. If it returns true, the
|
|
|
+ segment may or may not pass region 5 and a more fine-grained calculation must be used (\ref
|
|
|
+ getTraverse).
|
|
|
+*/
|
|
|
+bool QCPCurve::mayTraverse(int prevRegion, int currentRegion) const
|
|
|
+{
|
|
|
+ switch (prevRegion)
|
|
|
+ {
|
|
|
+ case 1:
|
|
|
+ {
|
|
|
+ switch (currentRegion)
|
|
|
+ {
|
|
|
+ case 4:
|
|
|
+ case 7:
|
|
|
+ case 2:
|
|
|
+ case 3: return false;
|
|
|
+ default: return true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ case 2:
|
|
|
+ {
|
|
|
+ switch (currentRegion)
|
|
|
+ {
|
|
|
+ case 1:
|
|
|
+ case 3: return false;
|
|
|
+ default: return true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ case 3:
|
|
|
+ {
|
|
|
+ switch (currentRegion)
|
|
|
+ {
|
|
|
+ case 1:
|
|
|
+ case 2:
|
|
|
+ case 6:
|
|
|
+ case 9: return false;
|
|
|
+ default: return true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ case 4:
|
|
|
+ {
|
|
|
+ switch (currentRegion)
|
|
|
+ {
|
|
|
+ case 1:
|
|
|
+ case 7: return false;
|
|
|
+ default: return true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ case 5: return false; // should never occur
|
|
|
+ case 6:
|
|
|
+ {
|
|
|
+ switch (currentRegion)
|
|
|
+ {
|
|
|
+ case 3:
|
|
|
+ case 9: return false;
|
|
|
+ default: return true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ case 7:
|
|
|
+ {
|
|
|
+ switch (currentRegion)
|
|
|
+ {
|
|
|
+ case 1:
|
|
|
+ case 4:
|
|
|
+ case 8:
|
|
|
+ case 9: return false;
|
|
|
+ default: return true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ case 8:
|
|
|
+ {
|
|
|
+ switch (currentRegion)
|
|
|
+ {
|
|
|
+ case 7:
|
|
|
+ case 9: return false;
|
|
|
+ default: return true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ case 9:
|
|
|
+ {
|
|
|
+ switch (currentRegion)
|
|
|
+ {
|
|
|
+ case 3:
|
|
|
+ case 6:
|
|
|
+ case 8:
|
|
|
+ case 7: return false;
|
|
|
+ default: return true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ default: return true;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ This function is part of the curve optimization algorithm of \ref getCurveLines.
|
|
|
+
|
|
|
+ This method assumes that the \ref mayTraverse test has returned true, so there is a chance the
|
|
|
+ segment defined by (\a prevKey, \a prevValue) and (\a key, \a value) goes through the visible
|
|
|
+ region 5.
|
|
|
+
|
|
|
+ The return value of this method indicates whether the segment actually traverses region 5 or not.
|
|
|
+
|
|
|
+ If the segment traverses 5, the output parameters \a crossA and \a crossB indicate the entry and
|
|
|
+ exit points of region 5. They will become the optimized points for that segment.
|
|
|
+*/
|
|
|
+bool QCPCurve::getTraverse(double prevKey, double prevValue, double key, double value, double keyMin, double valueMax, double keyMax, double valueMin, QPointF &crossA, QPointF &crossB) const
|
|
|
+{
|
|
|
+ // The intersection point interpolation here is done in pixel coordinates, so we don't need to
|
|
|
+ // differentiate between different axis scale types. Note that the nomenclature
|
|
|
+ // top/left/bottom/right/min/max is with respect to the rect in plot coordinates, wich may be
|
|
|
+ // different in pixel coordinates (horz/vert key axes, reversed ranges)
|
|
|
+
|
|
|
+ QList<QPointF> intersections;
|
|
|
+ const double valueMinPx = mValueAxis->coordToPixel(valueMin);
|
|
|
+ const double valueMaxPx = mValueAxis->coordToPixel(valueMax);
|
|
|
+ const double keyMinPx = mKeyAxis->coordToPixel(keyMin);
|
|
|
+ const double keyMaxPx = mKeyAxis->coordToPixel(keyMax);
|
|
|
+ const double keyPx = mKeyAxis->coordToPixel(key);
|
|
|
+ const double valuePx = mValueAxis->coordToPixel(value);
|
|
|
+ const double prevKeyPx = mKeyAxis->coordToPixel(prevKey);
|
|
|
+ const double prevValuePx = mValueAxis->coordToPixel(prevValue);
|
|
|
+ if (qFuzzyIsNull(key-prevKey)) // line is parallel to value axis
|
|
|
+ {
|
|
|
+ // due to region filter in mayTraverse(), if line is parallel to value or key axis, region 5 is traversed here
|
|
|
+ intersections.append(mKeyAxis->orientation() == Qt::Horizontal ? QPointF(keyPx, valueMinPx) : QPointF(valueMinPx, keyPx)); // direction will be taken care of at end of method
|
|
|
+ intersections.append(mKeyAxis->orientation() == Qt::Horizontal ? QPointF(keyPx, valueMaxPx) : QPointF(valueMaxPx, keyPx));
|
|
|
+ } else if (qFuzzyIsNull(value-prevValue)) // line is parallel to key axis
|
|
|
+ {
|
|
|
+ // due to region filter in mayTraverse(), if line is parallel to value or key axis, region 5 is traversed here
|
|
|
+ intersections.append(mKeyAxis->orientation() == Qt::Horizontal ? QPointF(keyMinPx, valuePx) : QPointF(valuePx, keyMinPx)); // direction will be taken care of at end of method
|
|
|
+ intersections.append(mKeyAxis->orientation() == Qt::Horizontal ? QPointF(keyMaxPx, valuePx) : QPointF(valuePx, keyMaxPx));
|
|
|
+ } else // line is skewed
|
|
|
+ {
|
|
|
+ double gamma;
|
|
|
+ double keyPerValuePx = (keyPx-prevKeyPx)/(valuePx-prevValuePx);
|
|
|
+ // check top of rect:
|
|
|
+ gamma = prevKeyPx + (valueMaxPx-prevValuePx)*keyPerValuePx;
|
|
|
+ if (gamma >= qMin(keyMinPx, keyMaxPx) && gamma <= qMax(keyMinPx, keyMaxPx)) // qMin/qMax necessary since axes may be reversed
|
|
|
+ intersections.append(mKeyAxis->orientation() == Qt::Horizontal ? QPointF(gamma, valueMaxPx) : QPointF(valueMaxPx, gamma));
|
|
|
+ // check bottom of rect:
|
|
|
+ gamma = prevKeyPx + (valueMinPx-prevValuePx)*keyPerValuePx;
|
|
|
+ if (gamma >= qMin(keyMinPx, keyMaxPx) && gamma <= qMax(keyMinPx, keyMaxPx)) // qMin/qMax necessary since axes may be reversed
|
|
|
+ intersections.append(mKeyAxis->orientation() == Qt::Horizontal ? QPointF(gamma, valueMinPx) : QPointF(valueMinPx, gamma));
|
|
|
+ const double valuePerKeyPx = 1.0/keyPerValuePx;
|
|
|
+ // check left of rect:
|
|
|
+ gamma = prevValuePx + (keyMinPx-prevKeyPx)*valuePerKeyPx;
|
|
|
+ if (gamma >= qMin(valueMinPx, valueMaxPx) && gamma <= qMax(valueMinPx, valueMaxPx)) // qMin/qMax necessary since axes may be reversed
|
|
|
+ intersections.append(mKeyAxis->orientation() == Qt::Horizontal ? QPointF(keyMinPx, gamma) : QPointF(gamma, keyMinPx));
|
|
|
+ // check right of rect:
|
|
|
+ gamma = prevValuePx + (keyMaxPx-prevKeyPx)*valuePerKeyPx;
|
|
|
+ if (gamma >= qMin(valueMinPx, valueMaxPx) && gamma <= qMax(valueMinPx, valueMaxPx)) // qMin/qMax necessary since axes may be reversed
|
|
|
+ intersections.append(mKeyAxis->orientation() == Qt::Horizontal ? QPointF(keyMaxPx, gamma) : QPointF(gamma, keyMaxPx));
|
|
|
+ }
|
|
|
+
|
|
|
+ // handle cases where found points isn't exactly 2:
|
|
|
+ if (intersections.size() > 2)
|
|
|
+ {
|
|
|
+ // line probably goes through corner of rect, and we got duplicate points there. single out the point pair with greatest distance in between:
|
|
|
+ double distSqrMax = 0;
|
|
|
+ QPointF pv1, pv2;
|
|
|
+ for (int i=0; i<intersections.size()-1; ++i)
|
|
|
+ {
|
|
|
+ for (int k=i+1; k<intersections.size(); ++k)
|
|
|
+ {
|
|
|
+ QPointF distPoint = intersections.at(i)-intersections.at(k);
|
|
|
+ double distSqr = distPoint.x()*distPoint.x()+distPoint.y()+distPoint.y();
|
|
|
+ if (distSqr > distSqrMax)
|
|
|
+ {
|
|
|
+ pv1 = intersections.at(i);
|
|
|
+ pv2 = intersections.at(k);
|
|
|
+ distSqrMax = distSqr;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ intersections = QList<QPointF>() << pv1 << pv2;
|
|
|
+ } else if (intersections.size() != 2)
|
|
|
+ {
|
|
|
+ // one or even zero points found (shouldn't happen unless line perfectly tangent to corner), no need to draw segment
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ // possibly re-sort points so optimized point segment has same direction as original segment:
|
|
|
+ double xDelta = keyPx-prevKeyPx;
|
|
|
+ double yDelta = valuePx-prevValuePx;
|
|
|
+ if (mKeyAxis->orientation() != Qt::Horizontal)
|
|
|
+ qSwap(xDelta, yDelta);
|
|
|
+ if (xDelta*(intersections.at(1).x()-intersections.at(0).x()) + yDelta*(intersections.at(1).y()-intersections.at(0).y()) < 0) // scalar product of both segments < 0 -> opposite direction
|
|
|
+ intersections.move(0, 1);
|
|
|
+ crossA = intersections.at(0);
|
|
|
+ crossB = intersections.at(1);
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ This function is part of the curve optimization algorithm of \ref getCurveLines.
|
|
|
+
|
|
|
+ This method assumes that the \ref getTraverse test has returned true, so the segment definitely
|
|
|
+ traverses the visible region 5 when going from \a prevRegion to \a currentRegion.
|
|
|
+
|
|
|
+ In certain situations it is not sufficient to merely generate the entry and exit points of the
|
|
|
+ segment into/out of region 5, as \ref getTraverse provides. It may happen that a single segment, in
|
|
|
+ addition to traversing region 5, skips another region outside of region 5, which makes it
|
|
|
+ necessary to add an optimized corner point there (very similar to the job \ref
|
|
|
+ getOptimizedCornerPoints does for segments that are completely in outside regions and don't
|
|
|
+ traverse 5).
|
|
|
+
|
|
|
+ As an example, consider a segment going from region 1 to region 6, traversing the lower left
|
|
|
+ corner of region 5. In this configuration, the segment additionally crosses the border between
|
|
|
+ region 1 and 2 before entering region 5. This makes it necessary to add an additional point in
|
|
|
+ the top left corner, before adding the optimized traverse points. So in this case, the output
|
|
|
+ parameter \a beforeTraverse will contain the top left corner point, and \a afterTraverse will be
|
|
|
+ empty.
|
|
|
+
|
|
|
+ In some cases, such as when going from region 1 to 9, it may even be necessary to add additional
|
|
|
+ corner points before and after the traverse. Then both \a beforeTraverse and \a afterTraverse
|
|
|
+ return the respective corner points.
|
|
|
+*/
|
|
|
+void QCPCurve::getTraverseCornerPoints(int prevRegion, int currentRegion, double keyMin, double valueMax, double keyMax, double valueMin, QVector<QPointF> &beforeTraverse, QVector<QPointF> &afterTraverse) const
|
|
|
+{
|
|
|
+ switch (prevRegion)
|
|
|
+ {
|
|
|
+ case 1:
|
|
|
+ {
|
|
|
+ switch (currentRegion)
|
|
|
+ {
|
|
|
+ case 6: { beforeTraverse << coordsToPixels(keyMin, valueMax); break; }
|
|
|
+ case 9: { beforeTraverse << coordsToPixels(keyMin, valueMax); afterTraverse << coordsToPixels(keyMax, valueMin); break; }
|
|
|
+ case 8: { beforeTraverse << coordsToPixels(keyMin, valueMax); break; }
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case 2:
|
|
|
+ {
|
|
|
+ switch (currentRegion)
|
|
|
+ {
|
|
|
+ case 7: { afterTraverse << coordsToPixels(keyMax, valueMax); break; }
|
|
|
+ case 9: { afterTraverse << coordsToPixels(keyMax, valueMin); break; }
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case 3:
|
|
|
+ {
|
|
|
+ switch (currentRegion)
|
|
|
+ {
|
|
|
+ case 4: { beforeTraverse << coordsToPixels(keyMin, valueMin); break; }
|
|
|
+ case 7: { beforeTraverse << coordsToPixels(keyMin, valueMin); afterTraverse << coordsToPixels(keyMax, valueMax); break; }
|
|
|
+ case 8: { beforeTraverse << coordsToPixels(keyMin, valueMin); break; }
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case 4:
|
|
|
+ {
|
|
|
+ switch (currentRegion)
|
|
|
+ {
|
|
|
+ case 3: { afterTraverse << coordsToPixels(keyMin, valueMin); break; }
|
|
|
+ case 9: { afterTraverse << coordsToPixels(keyMax, valueMin); break; }
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case 5: { break; } // shouldn't happen because this method only handles full traverses
|
|
|
+ case 6:
|
|
|
+ {
|
|
|
+ switch (currentRegion)
|
|
|
+ {
|
|
|
+ case 1: { afterTraverse << coordsToPixels(keyMin, valueMax); break; }
|
|
|
+ case 7: { afterTraverse << coordsToPixels(keyMax, valueMax); break; }
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case 7:
|
|
|
+ {
|
|
|
+ switch (currentRegion)
|
|
|
+ {
|
|
|
+ case 2: { beforeTraverse << coordsToPixels(keyMax, valueMax); break; }
|
|
|
+ case 3: { beforeTraverse << coordsToPixels(keyMax, valueMax); afterTraverse << coordsToPixels(keyMin, valueMin); break; }
|
|
|
+ case 6: { beforeTraverse << coordsToPixels(keyMax, valueMax); break; }
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case 8:
|
|
|
+ {
|
|
|
+ switch (currentRegion)
|
|
|
+ {
|
|
|
+ case 1: { afterTraverse << coordsToPixels(keyMin, valueMax); break; }
|
|
|
+ case 3: { afterTraverse << coordsToPixels(keyMin, valueMin); break; }
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case 9:
|
|
|
+ {
|
|
|
+ switch (currentRegion)
|
|
|
+ {
|
|
|
+ case 2: { beforeTraverse << coordsToPixels(keyMax, valueMin); break; }
|
|
|
+ case 1: { beforeTraverse << coordsToPixels(keyMax, valueMin); afterTraverse << coordsToPixels(keyMin, valueMax); break; }
|
|
|
+ case 4: { beforeTraverse << coordsToPixels(keyMax, valueMin); break; }
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Calculates the (minimum) distance (in pixels) the curve's representation has from the given \a
|
|
|
+ pixelPoint in pixels. This is used to determine whether the curve was clicked or not, e.g. in
|
|
|
+ \ref selectTest. The closest data point to \a pixelPoint is returned in \a closestData. Note that
|
|
|
+ if the curve has a line representation, the returned distance may be smaller than the distance to
|
|
|
+ the \a closestData point, since the distance to the curve line is also taken into account.
|
|
|
+
|
|
|
+ If either the curve has no data or if the line style is \ref lsNone and the scatter style's shape
|
|
|
+ is \ref QCPScatterStyle::ssNone (i.e. there is no visual representation of the curve), returns
|
|
|
+ -1.0.
|
|
|
+*/
|
|
|
+double QCPCurve::pointDistance(const QPointF &pixelPoint, QCPCurveDataContainer::const_iterator &closestData) const
|
|
|
+{
|
|
|
+ closestData = mDataContainer->constEnd();
|
|
|
+ if (mDataContainer->isEmpty())
|
|
|
+ return -1.0;
|
|
|
+ if (mLineStyle == lsNone && mScatterStyle.isNone())
|
|
|
+ return -1.0;
|
|
|
+
|
|
|
+ if (mDataContainer->size() == 1)
|
|
|
+ {
|
|
|
+ QPointF dataPoint = coordsToPixels(mDataContainer->constBegin()->key, mDataContainer->constBegin()->value);
|
|
|
+ closestData = mDataContainer->constBegin();
|
|
|
+ return QCPVector2D(dataPoint-pixelPoint).length();
|
|
|
+ }
|
|
|
+
|
|
|
+ // calculate minimum distances to curve data points and find closestData iterator:
|
|
|
+ double minDistSqr = std::numeric_limits<double>::max();
|
|
|
+ // iterate over found data points and then choose the one with the shortest distance to pos:
|
|
|
+ QCPCurveDataContainer::const_iterator begin = mDataContainer->constBegin();
|
|
|
+ QCPCurveDataContainer::const_iterator end = mDataContainer->constEnd();
|
|
|
+ for (QCPCurveDataContainer::const_iterator it=begin; it!=end; ++it)
|
|
|
+ {
|
|
|
+ const double currentDistSqr = QCPVector2D(coordsToPixels(it->key, it->value)-pixelPoint).lengthSquared();
|
|
|
+ if (currentDistSqr < minDistSqr)
|
|
|
+ {
|
|
|
+ minDistSqr = currentDistSqr;
|
|
|
+ closestData = it;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // calculate distance to line if there is one (if so, will probably be smaller than distance to closest data point):
|
|
|
+ if (mLineStyle != lsNone)
|
|
|
+ {
|
|
|
+ QVector<QPointF> lines;
|
|
|
+ getCurveLines(&lines, QCPDataRange(0, dataCount()), mParentPlot->selectionTolerance()*1.2); // optimized lines outside axis rect shouldn't respond to clicks at the edge, so use 1.2*tolerance as pen width
|
|
|
+ for (int i=0; i<lines.size()-1; ++i)
|
|
|
+ {
|
|
|
+ double currentDistSqr = QCPVector2D(pixelPoint).distanceSquaredToLine(lines.at(i), lines.at(i+1));
|
|
|
+ if (currentDistSqr < minDistSqr)
|
|
|
+ minDistSqr = currentDistSqr;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return qSqrt(minDistSqr);
|
|
|
+}
|
|
|
+/* end of 'src/plottables/plottable-curve.cpp' */
|
|
|
+
|
|
|
+
|
|
|
+/* including file 'src/plottables/plottable-bars.cpp', size 43512 */
|
|
|
+/* commit 9868e55d3b412f2f89766bb482fcf299e93a0988 2017-09-04 01:56:22 +0200 */
|
|
|
+
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPBarsGroup
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+/*! \class QCPBarsGroup
|
|
|
+ \brief Groups multiple QCPBars together so they appear side by side
|
|
|
+
|
|
|
+ \image html QCPBarsGroup.png
|
|
|
+
|
|
|
+ When showing multiple QCPBars in one plot which have bars at identical keys, it may be desirable
|
|
|
+ to have them appearing next to each other at each key. This is what adding the respective QCPBars
|
|
|
+ plottables to a QCPBarsGroup achieves. (An alternative approach is to stack them on top of each
|
|
|
+ other, see \ref QCPBars::moveAbove.)
|
|
|
+
|
|
|
+ \section qcpbarsgroup-usage Usage
|
|
|
+
|
|
|
+ To add a QCPBars plottable to the group, create a new group and then add the respective bars
|
|
|
+ intances:
|
|
|
+ \snippet documentation/doc-code-snippets/mainwindow.cpp qcpbarsgroup-creation
|
|
|
+ Alternatively to appending to the group like shown above, you can also set the group on the
|
|
|
+ QCPBars plottable via \ref QCPBars::setBarsGroup.
|
|
|
+
|
|
|
+ The spacing between the bars can be configured via \ref setSpacingType and \ref setSpacing. The
|
|
|
+ bars in this group appear in the plot in the order they were appended. To insert a bars plottable
|
|
|
+ at a certain index position, or to reposition a bars plottable which is already in the group, use
|
|
|
+ \ref insert.
|
|
|
+
|
|
|
+ To remove specific bars from the group, use either \ref remove or call \ref
|
|
|
+ QCPBars::setBarsGroup "QCPBars::setBarsGroup(0)" on the respective bars plottable.
|
|
|
+
|
|
|
+ To clear the entire group, call \ref clear, or simply delete the group.
|
|
|
+
|
|
|
+ \section qcpbarsgroup-example Example
|
|
|
+
|
|
|
+ The image above is generated with the following code:
|
|
|
+ \snippet documentation/doc-image-generator/mainwindow.cpp qcpbarsgroup-example
|
|
|
+*/
|
|
|
+
|
|
|
+/* start of documentation of inline functions */
|
|
|
+
|
|
|
+/*! \fn QList<QCPBars*> QCPBarsGroup::bars() const
|
|
|
+
|
|
|
+ Returns all bars currently in this group.
|
|
|
+
|
|
|
+ \see bars(int index)
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn int QCPBarsGroup::size() const
|
|
|
+
|
|
|
+ Returns the number of QCPBars plottables that are part of this group.
|
|
|
+
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn bool QCPBarsGroup::isEmpty() const
|
|
|
+
|
|
|
+ Returns whether this bars group is empty.
|
|
|
+
|
|
|
+ \see size
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn bool QCPBarsGroup::contains(QCPBars *bars)
|
|
|
+
|
|
|
+ Returns whether the specified \a bars plottable is part of this group.
|
|
|
+
|
|
|
+*/
|
|
|
+
|
|
|
+/* end of documentation of inline functions */
|
|
|
+
|
|
|
+/*!
|
|
|
+ Constructs a new bars group for the specified QCustomPlot instance.
|
|
|
+*/
|
|
|
+QCPBarsGroup::QCPBarsGroup(QCustomPlot *parentPlot) :
|
|
|
+ QObject(parentPlot),
|
|
|
+ mParentPlot(parentPlot),
|
|
|
+ mSpacingType(stAbsolute),
|
|
|
+ mSpacing(4)
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+QCPBarsGroup::~QCPBarsGroup()
|
|
|
+{
|
|
|
+ clear();
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets how the spacing between adjacent bars is interpreted. See \ref SpacingType.
|
|
|
+
|
|
|
+ The actual spacing can then be specified with \ref setSpacing.
|
|
|
+
|
|
|
+ \see setSpacing
|
|
|
+*/
|
|
|
+void QCPBarsGroup::setSpacingType(SpacingType spacingType)
|
|
|
+{
|
|
|
+ mSpacingType = spacingType;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the spacing between adjacent bars. What the number passed as \a spacing actually means, is
|
|
|
+ defined by the current \ref SpacingType, which can be set with \ref setSpacingType.
|
|
|
+
|
|
|
+ \see setSpacingType
|
|
|
+*/
|
|
|
+void QCPBarsGroup::setSpacing(double spacing)
|
|
|
+{
|
|
|
+ mSpacing = spacing;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns the QCPBars instance with the specified \a index in this group. If no such QCPBars
|
|
|
+ exists, returns 0.
|
|
|
+
|
|
|
+ \see bars(), size
|
|
|
+*/
|
|
|
+QCPBars *QCPBarsGroup::bars(int index) const
|
|
|
+{
|
|
|
+ if (index >= 0 && index < mBars.size())
|
|
|
+ {
|
|
|
+ return mBars.at(index);
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "index out of bounds:" << index;
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Removes all QCPBars plottables from this group.
|
|
|
+
|
|
|
+ \see isEmpty
|
|
|
+*/
|
|
|
+void QCPBarsGroup::clear()
|
|
|
+{
|
|
|
+ foreach (QCPBars *bars, mBars) // since foreach takes a copy, removing bars in the loop is okay
|
|
|
+ bars->setBarsGroup(0); // removes itself via removeBars
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Adds the specified \a bars plottable to this group. Alternatively, you can also use \ref
|
|
|
+ QCPBars::setBarsGroup on the \a bars instance.
|
|
|
+
|
|
|
+ \see insert, remove
|
|
|
+*/
|
|
|
+void QCPBarsGroup::append(QCPBars *bars)
|
|
|
+{
|
|
|
+ if (!bars)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "bars is 0";
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!mBars.contains(bars))
|
|
|
+ bars->setBarsGroup(this);
|
|
|
+ else
|
|
|
+ qDebug() << Q_FUNC_INFO << "bars plottable is already in this bars group:" << reinterpret_cast<quintptr>(bars);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Inserts the specified \a bars plottable into this group at the specified index position \a i.
|
|
|
+ This gives you full control over the ordering of the bars.
|
|
|
+
|
|
|
+ \a bars may already be part of this group. In that case, \a bars is just moved to the new index
|
|
|
+ position.
|
|
|
+
|
|
|
+ \see append, remove
|
|
|
+*/
|
|
|
+void QCPBarsGroup::insert(int i, QCPBars *bars)
|
|
|
+{
|
|
|
+ if (!bars)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "bars is 0";
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ // first append to bars list normally:
|
|
|
+ if (!mBars.contains(bars))
|
|
|
+ bars->setBarsGroup(this);
|
|
|
+ // then move to according position:
|
|
|
+ mBars.move(mBars.indexOf(bars), qBound(0, i, mBars.size()-1));
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Removes the specified \a bars plottable from this group.
|
|
|
+
|
|
|
+ \see contains, clear
|
|
|
+*/
|
|
|
+void QCPBarsGroup::remove(QCPBars *bars)
|
|
|
+{
|
|
|
+ if (!bars)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "bars is 0";
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (mBars.contains(bars))
|
|
|
+ bars->setBarsGroup(0);
|
|
|
+ else
|
|
|
+ qDebug() << Q_FUNC_INFO << "bars plottable is not in this bars group:" << reinterpret_cast<quintptr>(bars);
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Adds the specified \a bars to the internal mBars list of bars. This method does not change the
|
|
|
+ barsGroup property on \a bars.
|
|
|
+
|
|
|
+ \see unregisterBars
|
|
|
+*/
|
|
|
+void QCPBarsGroup::registerBars(QCPBars *bars)
|
|
|
+{
|
|
|
+ if (!mBars.contains(bars))
|
|
|
+ mBars.append(bars);
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Removes the specified \a bars from the internal mBars list of bars. This method does not change
|
|
|
+ the barsGroup property on \a bars.
|
|
|
+
|
|
|
+ \see registerBars
|
|
|
+*/
|
|
|
+void QCPBarsGroup::unregisterBars(QCPBars *bars)
|
|
|
+{
|
|
|
+ mBars.removeOne(bars);
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the pixel offset in the key dimension the specified \a bars plottable should have at the
|
|
|
+ given key coordinate \a keyCoord. The offset is relative to the pixel position of the key
|
|
|
+ coordinate \a keyCoord.
|
|
|
+*/
|
|
|
+double QCPBarsGroup::keyPixelOffset(const QCPBars *bars, double keyCoord)
|
|
|
+{
|
|
|
+ // find list of all base bars in case some mBars are stacked:
|
|
|
+ QList<const QCPBars*> baseBars;
|
|
|
+ foreach (const QCPBars *b, mBars)
|
|
|
+ {
|
|
|
+ while (b->barBelow())
|
|
|
+ b = b->barBelow();
|
|
|
+ if (!baseBars.contains(b))
|
|
|
+ baseBars.append(b);
|
|
|
+ }
|
|
|
+ // find base bar this "bars" is stacked on:
|
|
|
+ const QCPBars *thisBase = bars;
|
|
|
+ while (thisBase->barBelow())
|
|
|
+ thisBase = thisBase->barBelow();
|
|
|
+
|
|
|
+ // determine key pixel offset of this base bars considering all other base bars in this barsgroup:
|
|
|
+ double result = 0;
|
|
|
+ int index = baseBars.indexOf(thisBase);
|
|
|
+ if (index >= 0)
|
|
|
+ {
|
|
|
+ if (baseBars.size() % 2 == 1 && index == (baseBars.size()-1)/2) // is center bar (int division on purpose)
|
|
|
+ {
|
|
|
+ return result;
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ double lowerPixelWidth, upperPixelWidth;
|
|
|
+ int startIndex;
|
|
|
+ int dir = (index <= (baseBars.size()-1)/2) ? -1 : 1; // if bar is to lower keys of center, dir is negative
|
|
|
+ if (baseBars.size() % 2 == 0) // even number of bars
|
|
|
+ {
|
|
|
+ startIndex = baseBars.size()/2 + (dir < 0 ? -1 : 0);
|
|
|
+ result += getPixelSpacing(baseBars.at(startIndex), keyCoord)*0.5; // half of middle spacing
|
|
|
+ } else // uneven number of bars
|
|
|
+ {
|
|
|
+ startIndex = (baseBars.size()-1)/2+dir;
|
|
|
+ baseBars.at((baseBars.size()-1)/2)->getPixelWidth(keyCoord, lowerPixelWidth, upperPixelWidth);
|
|
|
+ result += qAbs(upperPixelWidth-lowerPixelWidth)*0.5; // half of center bar
|
|
|
+ result += getPixelSpacing(baseBars.at((baseBars.size()-1)/2), keyCoord); // center bar spacing
|
|
|
+ }
|
|
|
+ for (int i = startIndex; i != index; i += dir) // add widths and spacings of bars in between center and our bars
|
|
|
+ {
|
|
|
+ baseBars.at(i)->getPixelWidth(keyCoord, lowerPixelWidth, upperPixelWidth);
|
|
|
+ result += qAbs(upperPixelWidth-lowerPixelWidth);
|
|
|
+ result += getPixelSpacing(baseBars.at(i), keyCoord);
|
|
|
+ }
|
|
|
+ // finally half of our bars width:
|
|
|
+ baseBars.at(index)->getPixelWidth(keyCoord, lowerPixelWidth, upperPixelWidth);
|
|
|
+ result += qAbs(upperPixelWidth-lowerPixelWidth)*0.5;
|
|
|
+ // correct sign of result depending on orientation and direction of key axis:
|
|
|
+ result *= dir*thisBase->keyAxis()->pixelOrientation();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the spacing in pixels which is between this \a bars and the following one, both at the
|
|
|
+ key coordinate \a keyCoord.
|
|
|
+
|
|
|
+ \note Typically the returned value doesn't depend on \a bars or \a keyCoord. \a bars is only
|
|
|
+ needed to get access to the key axis transformation and axis rect for the modes \ref
|
|
|
+ stAxisRectRatio and \ref stPlotCoords. The \a keyCoord is only relevant for spacings given in
|
|
|
+ \ref stPlotCoords on a logarithmic axis.
|
|
|
+*/
|
|
|
+double QCPBarsGroup::getPixelSpacing(const QCPBars *bars, double keyCoord)
|
|
|
+{
|
|
|
+ switch (mSpacingType)
|
|
|
+ {
|
|
|
+ case stAbsolute:
|
|
|
+ {
|
|
|
+ return mSpacing;
|
|
|
+ }
|
|
|
+ case stAxisRectRatio:
|
|
|
+ {
|
|
|
+ if (bars->keyAxis()->orientation() == Qt::Horizontal)
|
|
|
+ return bars->keyAxis()->axisRect()->width()*mSpacing;
|
|
|
+ else
|
|
|
+ return bars->keyAxis()->axisRect()->height()*mSpacing;
|
|
|
+ }
|
|
|
+ case stPlotCoords:
|
|
|
+ {
|
|
|
+ double keyPixel = bars->keyAxis()->coordToPixel(keyCoord);
|
|
|
+ return qAbs(bars->keyAxis()->coordToPixel(keyCoord+mSpacing)-keyPixel);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPBarsData
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+/*! \class QCPBarsData
|
|
|
+ \brief Holds the data of one single data point (one bar) for QCPBars.
|
|
|
+
|
|
|
+ The stored data is:
|
|
|
+ \li \a key: coordinate on the key axis of this bar (this is the \a mainKey and the \a sortKey)
|
|
|
+ \li \a value: height coordinate on the value axis of this bar (this is the \a mainValue)
|
|
|
+
|
|
|
+ The container for storing multiple data points is \ref QCPBarsDataContainer. It is a typedef for
|
|
|
+ \ref QCPDataContainer with \ref QCPBarsData as the DataType template parameter. See the
|
|
|
+ documentation there for an explanation regarding the data type's generic methods.
|
|
|
+
|
|
|
+ \see QCPBarsDataContainer
|
|
|
+*/
|
|
|
+
|
|
|
+/* start documentation of inline functions */
|
|
|
+
|
|
|
+/*! \fn double QCPBarsData::sortKey() const
|
|
|
+
|
|
|
+ Returns the \a key member of this data point.
|
|
|
+
|
|
|
+ For a general explanation of what this method is good for in the context of the data container,
|
|
|
+ see the documentation of \ref QCPDataContainer.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn static QCPBarsData QCPBarsData::fromSortKey(double sortKey)
|
|
|
+
|
|
|
+ Returns a data point with the specified \a sortKey. All other members are set to zero.
|
|
|
+
|
|
|
+ For a general explanation of what this method is good for in the context of the data container,
|
|
|
+ see the documentation of \ref QCPDataContainer.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn static static bool QCPBarsData::sortKeyIsMainKey()
|
|
|
+
|
|
|
+ Since the member \a key is both the data point key coordinate and the data ordering parameter,
|
|
|
+ this method returns true.
|
|
|
+
|
|
|
+ For a general explanation of what this method is good for in the context of the data container,
|
|
|
+ see the documentation of \ref QCPDataContainer.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn double QCPBarsData::mainKey() const
|
|
|
+
|
|
|
+ Returns the \a key member of this data point.
|
|
|
+
|
|
|
+ For a general explanation of what this method is good for in the context of the data container,
|
|
|
+ see the documentation of \ref QCPDataContainer.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn double QCPBarsData::mainValue() const
|
|
|
+
|
|
|
+ Returns the \a value member of this data point.
|
|
|
+
|
|
|
+ For a general explanation of what this method is good for in the context of the data container,
|
|
|
+ see the documentation of \ref QCPDataContainer.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn QCPRange QCPBarsData::valueRange() const
|
|
|
+
|
|
|
+ Returns a QCPRange with both lower and upper boundary set to \a value of this data point.
|
|
|
+
|
|
|
+ For a general explanation of what this method is good for in the context of the data container,
|
|
|
+ see the documentation of \ref QCPDataContainer.
|
|
|
+*/
|
|
|
+
|
|
|
+/* end documentation of inline functions */
|
|
|
+
|
|
|
+/*!
|
|
|
+ Constructs a bar data point with key and value set to zero.
|
|
|
+*/
|
|
|
+QCPBarsData::QCPBarsData() :
|
|
|
+ key(0),
|
|
|
+ value(0)
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Constructs a bar data point with the specified \a key and \a value.
|
|
|
+*/
|
|
|
+QCPBarsData::QCPBarsData(double key, double value) :
|
|
|
+ key(key),
|
|
|
+ value(value)
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPBars
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+/*! \class QCPBars
|
|
|
+ \brief A plottable representing a bar chart in a plot.
|
|
|
+
|
|
|
+ \image html QCPBars.png
|
|
|
+
|
|
|
+ To plot data, assign it with the \ref setData or \ref addData functions.
|
|
|
+
|
|
|
+ \section qcpbars-appearance Changing the appearance
|
|
|
+
|
|
|
+ The appearance of the bars is determined by the pen and the brush (\ref setPen, \ref setBrush).
|
|
|
+ The width of the individual bars can be controlled with \ref setWidthType and \ref setWidth.
|
|
|
+
|
|
|
+ Bar charts are stackable. This means, two QCPBars plottables can be placed on top of each other
|
|
|
+ (see \ref QCPBars::moveAbove). So when two bars are at the same key position, they will appear
|
|
|
+ stacked.
|
|
|
+
|
|
|
+ If you would like to group multiple QCPBars plottables together so they appear side by side as
|
|
|
+ shown below, use QCPBarsGroup.
|
|
|
+
|
|
|
+ \image html QCPBarsGroup.png
|
|
|
+
|
|
|
+ \section qcpbars-usage Usage
|
|
|
+
|
|
|
+ Like all data representing objects in QCustomPlot, the QCPBars is a plottable
|
|
|
+ (QCPAbstractPlottable). So the plottable-interface of QCustomPlot applies
|
|
|
+ (QCustomPlot::plottable, QCustomPlot::removePlottable, etc.)
|
|
|
+
|
|
|
+ Usually, you first create an instance:
|
|
|
+ \snippet documentation/doc-code-snippets/mainwindow.cpp qcpbars-creation-1
|
|
|
+ which registers it with the QCustomPlot instance of the passed axes. Note that this QCustomPlot instance takes
|
|
|
+ ownership of the plottable, so do not delete it manually but use QCustomPlot::removePlottable() instead.
|
|
|
+ The newly created plottable can be modified, e.g.:
|
|
|
+ \snippet documentation/doc-code-snippets/mainwindow.cpp qcpbars-creation-2
|
|
|
+*/
|
|
|
+
|
|
|
+/* start of documentation of inline functions */
|
|
|
+
|
|
|
+/*! \fn QSharedPointer<QCPBarsDataContainer> QCPBars::data() const
|
|
|
+
|
|
|
+ Returns a shared pointer to the internal data storage of type \ref QCPBarsDataContainer. You may
|
|
|
+ use it to directly manipulate the data, which may be more convenient and faster than using the
|
|
|
+ regular \ref setData or \ref addData methods.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn QCPBars *QCPBars::barBelow() const
|
|
|
+ Returns the bars plottable that is directly below this bars plottable.
|
|
|
+ If there is no such plottable, returns 0.
|
|
|
+
|
|
|
+ \see barAbove, moveBelow, moveAbove
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn QCPBars *QCPBars::barAbove() const
|
|
|
+ Returns the bars plottable that is directly above this bars plottable.
|
|
|
+ If there is no such plottable, returns 0.
|
|
|
+
|
|
|
+ \see barBelow, moveBelow, moveAbove
|
|
|
+*/
|
|
|
+
|
|
|
+/* end of documentation of inline functions */
|
|
|
+
|
|
|
+/*!
|
|
|
+ Constructs a bar chart which uses \a keyAxis as its key axis ("x") and \a valueAxis as its value
|
|
|
+ axis ("y"). \a keyAxis and \a valueAxis must reside in the same QCustomPlot instance and not have
|
|
|
+ the same orientation. If either of these restrictions is violated, a corresponding message is
|
|
|
+ printed to the debug output (qDebug), the construction is not aborted, though.
|
|
|
+
|
|
|
+ The created QCPBars is automatically registered with the QCustomPlot instance inferred from \a
|
|
|
+ keyAxis. This QCustomPlot instance takes ownership of the QCPBars, so do not delete it manually
|
|
|
+ but use QCustomPlot::removePlottable() instead.
|
|
|
+*/
|
|
|
+QCPBars::QCPBars(QCPAxis *keyAxis, QCPAxis *valueAxis) :
|
|
|
+ QCPAbstractPlottable1D<QCPBarsData>(keyAxis, valueAxis),
|
|
|
+ mWidth(0.75),
|
|
|
+ mWidthType(wtPlotCoords),
|
|
|
+ mBarsGroup(0),
|
|
|
+ mBaseValue(0),
|
|
|
+ mStackingGap(0)
|
|
|
+{
|
|
|
+ // modify inherited properties from abstract plottable:
|
|
|
+ mPen.setColor(Qt::blue);
|
|
|
+ mPen.setStyle(Qt::SolidLine);
|
|
|
+ mBrush.setColor(QColor(40, 50, 255, 30));
|
|
|
+ mBrush.setStyle(Qt::SolidPattern);
|
|
|
+ mSelectionDecorator->setBrush(QBrush(QColor(160, 160, 255)));
|
|
|
+}
|
|
|
+
|
|
|
+QCPBars::~QCPBars()
|
|
|
+{
|
|
|
+ setBarsGroup(0);
|
|
|
+ if (mBarBelow || mBarAbove)
|
|
|
+ connectBars(mBarBelow.data(), mBarAbove.data()); // take this bar out of any stacking
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Replaces the current data container with the provided \a data container.
|
|
|
+
|
|
|
+ Since a QSharedPointer is used, multiple QCPBars may share the same data container safely.
|
|
|
+ Modifying the data in the container will then affect all bars that share the container. Sharing
|
|
|
+ can be achieved by simply exchanging the data containers wrapped in shared pointers:
|
|
|
+ \snippet documentation/doc-code-snippets/mainwindow.cpp qcpbars-datasharing-1
|
|
|
+
|
|
|
+ If you do not wish to share containers, but create a copy from an existing container, rather use
|
|
|
+ the \ref QCPDataContainer<DataType>::set method on the bar's data container directly:
|
|
|
+ \snippet documentation/doc-code-snippets/mainwindow.cpp qcpbars-datasharing-2
|
|
|
+
|
|
|
+ \see addData
|
|
|
+*/
|
|
|
+void QCPBars::setData(QSharedPointer<QCPBarsDataContainer> data)
|
|
|
+{
|
|
|
+ mDataContainer = data;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Replaces the current data with the provided points in \a keys and \a values. The provided
|
|
|
+ vectors should have equal length. Else, the number of added points will be the size of the
|
|
|
+ smallest vector.
|
|
|
+
|
|
|
+ If you can guarantee that the passed data points are sorted by \a keys in ascending order, you
|
|
|
+ can set \a alreadySorted to true, to improve performance by saving a sorting run.
|
|
|
+
|
|
|
+ \see addData
|
|
|
+*/
|
|
|
+void QCPBars::setData(const QVector<double> &keys, const QVector<double> &values, bool alreadySorted)
|
|
|
+{
|
|
|
+ mDataContainer->clear();
|
|
|
+ addData(keys, values, alreadySorted);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the width of the bars.
|
|
|
+
|
|
|
+ How the number passed as \a width is interpreted (e.g. screen pixels, plot coordinates,...),
|
|
|
+ depends on the currently set width type, see \ref setWidthType and \ref WidthType.
|
|
|
+*/
|
|
|
+void QCPBars::setWidth(double width)
|
|
|
+{
|
|
|
+ mWidth = width;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets how the width of the bars is defined. See the documentation of \ref WidthType for an
|
|
|
+ explanation of the possible values for \a widthType.
|
|
|
+
|
|
|
+ The default value is \ref wtPlotCoords.
|
|
|
+
|
|
|
+ \see setWidth
|
|
|
+*/
|
|
|
+void QCPBars::setWidthType(QCPBars::WidthType widthType)
|
|
|
+{
|
|
|
+ mWidthType = widthType;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets to which QCPBarsGroup this QCPBars instance belongs to. Alternatively, you can also use \ref
|
|
|
+ QCPBarsGroup::append.
|
|
|
+
|
|
|
+ To remove this QCPBars from any group, set \a barsGroup to 0.
|
|
|
+*/
|
|
|
+void QCPBars::setBarsGroup(QCPBarsGroup *barsGroup)
|
|
|
+{
|
|
|
+ // deregister at old group:
|
|
|
+ if (mBarsGroup)
|
|
|
+ mBarsGroup->unregisterBars(this);
|
|
|
+ mBarsGroup = barsGroup;
|
|
|
+ // register at new group:
|
|
|
+ if (mBarsGroup)
|
|
|
+ mBarsGroup->registerBars(this);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the base value of this bars plottable.
|
|
|
+
|
|
|
+ The base value defines where on the value coordinate the bars start. How far the bars extend from
|
|
|
+ the base value is given by their individual value data. For example, if the base value is set to
|
|
|
+ 1, a bar with data value 2 will have its lowest point at value coordinate 1 and highest point at
|
|
|
+ 3.
|
|
|
+
|
|
|
+ For stacked bars, only the base value of the bottom-most QCPBars has meaning.
|
|
|
+
|
|
|
+ The default base value is 0.
|
|
|
+*/
|
|
|
+void QCPBars::setBaseValue(double baseValue)
|
|
|
+{
|
|
|
+ mBaseValue = baseValue;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ If this bars plottable is stacked on top of another bars plottable (\ref moveAbove), this method
|
|
|
+ allows specifying a distance in \a pixels, by which the drawn bar rectangles will be separated by
|
|
|
+ the bars below it.
|
|
|
+*/
|
|
|
+void QCPBars::setStackingGap(double pixels)
|
|
|
+{
|
|
|
+ mStackingGap = pixels;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Adds the provided points in \a keys and \a values to the current data. The provided vectors
|
|
|
+ should have equal length. Else, the number of added points will be the size of the smallest
|
|
|
+ vector.
|
|
|
+
|
|
|
+ If you can guarantee that the passed data points are sorted by \a keys in ascending order, you
|
|
|
+ can set \a alreadySorted to true, to improve performance by saving a sorting run.
|
|
|
+
|
|
|
+ Alternatively, you can also access and modify the data directly via the \ref data method, which
|
|
|
+ returns a pointer to the internal data container.
|
|
|
+*/
|
|
|
+void QCPBars::addData(const QVector<double> &keys, const QVector<double> &values, bool alreadySorted)
|
|
|
+{
|
|
|
+ if (keys.size() != values.size())
|
|
|
+ qDebug() << Q_FUNC_INFO << "keys and values have different sizes:" << keys.size() << values.size();
|
|
|
+ const int n = qMin(keys.size(), values.size());
|
|
|
+ QVector<QCPBarsData> tempData(n);
|
|
|
+ QVector<QCPBarsData>::iterator it = tempData.begin();
|
|
|
+ const QVector<QCPBarsData>::iterator itEnd = tempData.end();
|
|
|
+ int i = 0;
|
|
|
+ while (it != itEnd)
|
|
|
+ {
|
|
|
+ it->key = keys[i];
|
|
|
+ it->value = values[i];
|
|
|
+ ++it;
|
|
|
+ ++i;
|
|
|
+ }
|
|
|
+ mDataContainer->add(tempData, alreadySorted); // don't modify tempData beyond this to prevent copy on write
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+ Adds the provided data point as \a key and \a value to the current data.
|
|
|
+
|
|
|
+ Alternatively, you can also access and modify the data directly via the \ref data method, which
|
|
|
+ returns a pointer to the internal data container.
|
|
|
+*/
|
|
|
+void QCPBars::addData(double key, double value)
|
|
|
+{
|
|
|
+ mDataContainer->add(QCPBarsData(key, value));
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Moves this bars plottable below \a bars. In other words, the bars of this plottable will appear
|
|
|
+ below the bars of \a bars. The move target \a bars must use the same key and value axis as this
|
|
|
+ plottable.
|
|
|
+
|
|
|
+ Inserting into and removing from existing bar stacking is handled gracefully. If \a bars already
|
|
|
+ has a bars object below itself, this bars object is inserted between the two. If this bars object
|
|
|
+ is already between two other bars, the two other bars will be stacked on top of each other after
|
|
|
+ the operation.
|
|
|
+
|
|
|
+ To remove this bars plottable from any stacking, set \a bars to 0.
|
|
|
+
|
|
|
+ \see moveBelow, barAbove, barBelow
|
|
|
+*/
|
|
|
+void QCPBars::moveBelow(QCPBars *bars)
|
|
|
+{
|
|
|
+ if (bars == this) return;
|
|
|
+ if (bars && (bars->keyAxis() != mKeyAxis.data() || bars->valueAxis() != mValueAxis.data()))
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "passed QCPBars* doesn't have same key and value axis as this QCPBars";
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ // remove from stacking:
|
|
|
+ connectBars(mBarBelow.data(), mBarAbove.data()); // Note: also works if one (or both) of them is 0
|
|
|
+ // if new bar given, insert this bar below it:
|
|
|
+ if (bars)
|
|
|
+ {
|
|
|
+ if (bars->mBarBelow)
|
|
|
+ connectBars(bars->mBarBelow.data(), this);
|
|
|
+ connectBars(this, bars);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Moves this bars plottable above \a bars. In other words, the bars of this plottable will appear
|
|
|
+ above the bars of \a bars. The move target \a bars must use the same key and value axis as this
|
|
|
+ plottable.
|
|
|
+
|
|
|
+ Inserting into and removing from existing bar stacking is handled gracefully. If \a bars already
|
|
|
+ has a bars object above itself, this bars object is inserted between the two. If this bars object
|
|
|
+ is already between two other bars, the two other bars will be stacked on top of each other after
|
|
|
+ the operation.
|
|
|
+
|
|
|
+ To remove this bars plottable from any stacking, set \a bars to 0.
|
|
|
+
|
|
|
+ \see moveBelow, barBelow, barAbove
|
|
|
+*/
|
|
|
+void QCPBars::moveAbove(QCPBars *bars)
|
|
|
+{
|
|
|
+ if (bars == this) return;
|
|
|
+ if (bars && (bars->keyAxis() != mKeyAxis.data() || bars->valueAxis() != mValueAxis.data()))
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "passed QCPBars* doesn't have same key and value axis as this QCPBars";
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ // remove from stacking:
|
|
|
+ connectBars(mBarBelow.data(), mBarAbove.data()); // Note: also works if one (or both) of them is 0
|
|
|
+ // if new bar given, insert this bar above it:
|
|
|
+ if (bars)
|
|
|
+ {
|
|
|
+ if (bars->mBarAbove)
|
|
|
+ connectBars(this, bars->mBarAbove.data());
|
|
|
+ connectBars(bars, this);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ \copydoc QCPPlottableInterface1D::selectTestRect
|
|
|
+*/
|
|
|
+QCPDataSelection QCPBars::selectTestRect(const QRectF &rect, bool onlySelectable) const
|
|
|
+{
|
|
|
+ QCPDataSelection result;
|
|
|
+ if ((onlySelectable && mSelectable == QCP::stNone) || mDataContainer->isEmpty())
|
|
|
+ return result;
|
|
|
+ if (!mKeyAxis || !mValueAxis)
|
|
|
+ return result;
|
|
|
+
|
|
|
+ QCPBarsDataContainer::const_iterator visibleBegin, visibleEnd;
|
|
|
+ getVisibleDataBounds(visibleBegin, visibleEnd);
|
|
|
+
|
|
|
+ for (QCPBarsDataContainer::const_iterator it=visibleBegin; it!=visibleEnd; ++it)
|
|
|
+ {
|
|
|
+ if (rect.intersects(getBarRect(it->key, it->value)))
|
|
|
+ result.addDataRange(QCPDataRange(it-mDataContainer->constBegin(), it-mDataContainer->constBegin()+1), false);
|
|
|
+ }
|
|
|
+ result.simplify();
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+double QCPBars::selectTest(const QPointF &pos, bool onlySelectable, QVariant *details) const
|
|
|
+{
|
|
|
+ Q_UNUSED(details)
|
|
|
+ if ((onlySelectable && mSelectable == QCP::stNone) || mDataContainer->isEmpty())
|
|
|
+ return -1;
|
|
|
+ if (!mKeyAxis || !mValueAxis)
|
|
|
+ return -1;
|
|
|
+
|
|
|
+ if (mKeyAxis.data()->axisRect()->rect().contains(pos.toPoint()))
|
|
|
+ {
|
|
|
+ // get visible data range:
|
|
|
+ QCPBarsDataContainer::const_iterator visibleBegin, visibleEnd;
|
|
|
+ getVisibleDataBounds(visibleBegin, visibleEnd);
|
|
|
+ for (QCPBarsDataContainer::const_iterator it=visibleBegin; it!=visibleEnd; ++it)
|
|
|
+ {
|
|
|
+ if (getBarRect(it->key, it->value).contains(pos))
|
|
|
+ {
|
|
|
+ if (details)
|
|
|
+ {
|
|
|
+ int pointIndex = it-mDataContainer->constBegin();
|
|
|
+ details->setValue(QCPDataSelection(QCPDataRange(pointIndex, pointIndex+1)));
|
|
|
+ }
|
|
|
+ return mParentPlot->selectionTolerance()*0.99;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return -1;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+QCPRange QCPBars::getKeyRange(bool &foundRange, QCP::SignDomain inSignDomain) const
|
|
|
+{
|
|
|
+ /* Note: If this QCPBars uses absolute pixels as width (or is in a QCPBarsGroup with spacing in
|
|
|
+ absolute pixels), using this method to adapt the key axis range to fit the bars into the
|
|
|
+ currently visible axis range will not work perfectly. Because in the moment the axis range is
|
|
|
+ changed to the new range, the fixed pixel widths/spacings will represent different coordinate
|
|
|
+ spans than before, which in turn would require a different key range to perfectly fit, and so on.
|
|
|
+ The only solution would be to iteratively approach the perfect fitting axis range, but the
|
|
|
+ mismatch isn't large enough in most applications, to warrant this here. If a user does need a
|
|
|
+ better fit, he should call the corresponding axis rescale multiple times in a row.
|
|
|
+ */
|
|
|
+ QCPRange range;
|
|
|
+ range = mDataContainer->keyRange(foundRange, inSignDomain);
|
|
|
+
|
|
|
+ // determine exact range of bars by including bar width and barsgroup offset:
|
|
|
+ if (foundRange && mKeyAxis)
|
|
|
+ {
|
|
|
+ double lowerPixelWidth, upperPixelWidth, keyPixel;
|
|
|
+ // lower range bound:
|
|
|
+ getPixelWidth(range.lower, lowerPixelWidth, upperPixelWidth);
|
|
|
+ keyPixel = mKeyAxis.data()->coordToPixel(range.lower) + lowerPixelWidth;
|
|
|
+ if (mBarsGroup)
|
|
|
+ keyPixel += mBarsGroup->keyPixelOffset(this, range.lower);
|
|
|
+ const double lowerCorrected = mKeyAxis.data()->pixelToCoord(keyPixel);
|
|
|
+ if (!qIsNaN(lowerCorrected) && qIsFinite(lowerCorrected) && range.lower > lowerCorrected)
|
|
|
+ range.lower = lowerCorrected;
|
|
|
+ // upper range bound:
|
|
|
+ getPixelWidth(range.upper, lowerPixelWidth, upperPixelWidth);
|
|
|
+ keyPixel = mKeyAxis.data()->coordToPixel(range.upper) + upperPixelWidth;
|
|
|
+ if (mBarsGroup)
|
|
|
+ keyPixel += mBarsGroup->keyPixelOffset(this, range.upper);
|
|
|
+ const double upperCorrected = mKeyAxis.data()->pixelToCoord(keyPixel);
|
|
|
+ if (!qIsNaN(upperCorrected) && qIsFinite(upperCorrected) && range.upper < upperCorrected)
|
|
|
+ range.upper = upperCorrected;
|
|
|
+ }
|
|
|
+ return range;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+QCPRange QCPBars::getValueRange(bool &foundRange, QCP::SignDomain inSignDomain, const QCPRange &inKeyRange) const
|
|
|
+{
|
|
|
+ // Note: can't simply use mDataContainer->valueRange here because we need to
|
|
|
+ // take into account bar base value and possible stacking of multiple bars
|
|
|
+ QCPRange range;
|
|
|
+ range.lower = mBaseValue;
|
|
|
+ range.upper = mBaseValue;
|
|
|
+ bool haveLower = true; // set to true, because baseValue should always be visible in bar charts
|
|
|
+ bool haveUpper = true; // set to true, because baseValue should always be visible in bar charts
|
|
|
+ QCPBarsDataContainer::const_iterator itBegin = mDataContainer->constBegin();
|
|
|
+ QCPBarsDataContainer::const_iterator itEnd = mDataContainer->constEnd();
|
|
|
+ if (inKeyRange != QCPRange())
|
|
|
+ {
|
|
|
+ itBegin = mDataContainer->findBegin(inKeyRange.lower);
|
|
|
+ itEnd = mDataContainer->findEnd(inKeyRange.upper);
|
|
|
+ }
|
|
|
+ for (QCPBarsDataContainer::const_iterator it = itBegin; it != itEnd; ++it)
|
|
|
+ {
|
|
|
+ const double current = it->value + getStackedBaseValue(it->key, it->value >= 0);
|
|
|
+ if (qIsNaN(current)) continue;
|
|
|
+ if (inSignDomain == QCP::sdBoth || (inSignDomain == QCP::sdNegative && current < 0) || (inSignDomain == QCP::sdPositive && current > 0))
|
|
|
+ {
|
|
|
+ if (current < range.lower || !haveLower)
|
|
|
+ {
|
|
|
+ range.lower = current;
|
|
|
+ haveLower = true;
|
|
|
+ }
|
|
|
+ if (current > range.upper || !haveUpper)
|
|
|
+ {
|
|
|
+ range.upper = current;
|
|
|
+ haveUpper = true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ foundRange = true; // return true because bar charts always have the 0-line visible
|
|
|
+ return range;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+QPointF QCPBars::dataPixelPosition(int index) const
|
|
|
+{
|
|
|
+ if (index >= 0 && index < mDataContainer->size())
|
|
|
+ {
|
|
|
+ QCPAxis *keyAxis = mKeyAxis.data();
|
|
|
+ QCPAxis *valueAxis = mValueAxis.data();
|
|
|
+ if (!keyAxis || !valueAxis) { qDebug() << Q_FUNC_INFO << "invalid key or value axis"; return QPointF(); }
|
|
|
+
|
|
|
+ const QCPDataContainer<QCPBarsData>::const_iterator it = mDataContainer->constBegin()+index;
|
|
|
+ const double valuePixel = valueAxis->coordToPixel(getStackedBaseValue(it->key, it->value >= 0) + it->value);
|
|
|
+ const double keyPixel = keyAxis->coordToPixel(it->key) + (mBarsGroup ? mBarsGroup->keyPixelOffset(this, it->key) : 0);
|
|
|
+ if (keyAxis->orientation() == Qt::Horizontal)
|
|
|
+ return QPointF(keyPixel, valuePixel);
|
|
|
+ else
|
|
|
+ return QPointF(valuePixel, keyPixel);
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "Index out of bounds" << index;
|
|
|
+ return QPointF();
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPBars::draw(QCPPainter *painter)
|
|
|
+{
|
|
|
+ if (!mKeyAxis || !mValueAxis) { qDebug() << Q_FUNC_INFO << "invalid key or value axis"; return; }
|
|
|
+ if (mDataContainer->isEmpty()) return;
|
|
|
+
|
|
|
+ QCPBarsDataContainer::const_iterator visibleBegin, visibleEnd;
|
|
|
+ getVisibleDataBounds(visibleBegin, visibleEnd);
|
|
|
+
|
|
|
+ // loop over and draw segments of unselected/selected data:
|
|
|
+ QList<QCPDataRange> selectedSegments, unselectedSegments, allSegments;
|
|
|
+ getDataSegments(selectedSegments, unselectedSegments);
|
|
|
+ allSegments << unselectedSegments << selectedSegments;
|
|
|
+ for (int i=0; i<allSegments.size(); ++i)
|
|
|
+ {
|
|
|
+ bool isSelectedSegment = i >= unselectedSegments.size();
|
|
|
+ QCPBarsDataContainer::const_iterator begin = visibleBegin;
|
|
|
+ QCPBarsDataContainer::const_iterator end = visibleEnd;
|
|
|
+ mDataContainer->limitIteratorsToDataRange(begin, end, allSegments.at(i));
|
|
|
+ if (begin == end)
|
|
|
+ continue;
|
|
|
+
|
|
|
+ for (QCPBarsDataContainer::const_iterator it=begin; it!=end; ++it)
|
|
|
+ {
|
|
|
+ // check data validity if flag set:
|
|
|
+#ifdef QCUSTOMPLOT_CHECK_DATA
|
|
|
+ if (QCP::isInvalidData(it->key, it->value))
|
|
|
+ qDebug() << Q_FUNC_INFO << "Data point at" << it->key << "of drawn range invalid." << "Plottable name:" << name();
|
|
|
+#endif
|
|
|
+ // draw bar:
|
|
|
+ if (isSelectedSegment && mSelectionDecorator)
|
|
|
+ {
|
|
|
+ mSelectionDecorator->applyBrush(painter);
|
|
|
+ mSelectionDecorator->applyPen(painter);
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ painter->setBrush(mBrush);
|
|
|
+ painter->setPen(mPen);
|
|
|
+ }
|
|
|
+ applyDefaultAntialiasingHint(painter);
|
|
|
+ painter->drawPolygon(getBarRect(it->key, it->value));
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // draw other selection decoration that isn't just line/scatter pens and brushes:
|
|
|
+ if (mSelectionDecorator)
|
|
|
+ mSelectionDecorator->drawDecoration(painter, selection());
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPBars::drawLegendIcon(QCPPainter *painter, const QRectF &rect) const
|
|
|
+{
|
|
|
+ // draw filled rect:
|
|
|
+ applyDefaultAntialiasingHint(painter);
|
|
|
+ painter->setBrush(mBrush);
|
|
|
+ painter->setPen(mPen);
|
|
|
+ QRectF r = QRectF(0, 0, rect.width()*0.67, rect.height()*0.67);
|
|
|
+ r.moveCenter(rect.center());
|
|
|
+ painter->drawRect(r);
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ called by \ref draw to determine which data (key) range is visible at the current key axis range
|
|
|
+ setting, so only that needs to be processed. It also takes into account the bar width.
|
|
|
+
|
|
|
+ \a begin returns an iterator to the lowest data point that needs to be taken into account when
|
|
|
+ plotting. Note that in order to get a clean plot all the way to the edge of the axis rect, \a
|
|
|
+ lower may still be just outside the visible range.
|
|
|
+
|
|
|
+ \a end returns an iterator one higher than the highest visible data point. Same as before, \a end
|
|
|
+ may also lie just outside of the visible range.
|
|
|
+
|
|
|
+ if the plottable contains no data, both \a begin and \a end point to constEnd.
|
|
|
+*/
|
|
|
+void QCPBars::getVisibleDataBounds(QCPBarsDataContainer::const_iterator &begin, QCPBarsDataContainer::const_iterator &end) const
|
|
|
+{
|
|
|
+ if (!mKeyAxis)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "invalid key axis";
|
|
|
+ begin = mDataContainer->constEnd();
|
|
|
+ end = mDataContainer->constEnd();
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ if (mDataContainer->isEmpty())
|
|
|
+ {
|
|
|
+ begin = mDataContainer->constEnd();
|
|
|
+ end = mDataContainer->constEnd();
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ // get visible data range as QMap iterators
|
|
|
+ begin = mDataContainer->findBegin(mKeyAxis.data()->range().lower);
|
|
|
+ end = mDataContainer->findEnd(mKeyAxis.data()->range().upper);
|
|
|
+ double lowerPixelBound = mKeyAxis.data()->coordToPixel(mKeyAxis.data()->range().lower);
|
|
|
+ double upperPixelBound = mKeyAxis.data()->coordToPixel(mKeyAxis.data()->range().upper);
|
|
|
+ bool isVisible = false;
|
|
|
+ // walk left from begin to find lower bar that actually is completely outside visible pixel range:
|
|
|
+ QCPBarsDataContainer::const_iterator it = begin;
|
|
|
+ while (it != mDataContainer->constBegin())
|
|
|
+ {
|
|
|
+ --it;
|
|
|
+ const QRectF barRect = getBarRect(it->key, it->value);
|
|
|
+ if (mKeyAxis.data()->orientation() == Qt::Horizontal)
|
|
|
+ isVisible = ((!mKeyAxis.data()->rangeReversed() && barRect.right() >= lowerPixelBound) || (mKeyAxis.data()->rangeReversed() && barRect.left() <= lowerPixelBound));
|
|
|
+ else // keyaxis is vertical
|
|
|
+ isVisible = ((!mKeyAxis.data()->rangeReversed() && barRect.top() <= lowerPixelBound) || (mKeyAxis.data()->rangeReversed() && barRect.bottom() >= lowerPixelBound));
|
|
|
+ if (isVisible)
|
|
|
+ begin = it;
|
|
|
+ else
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ // walk right from ubound to find upper bar that actually is completely outside visible pixel range:
|
|
|
+ it = end;
|
|
|
+ while (it != mDataContainer->constEnd())
|
|
|
+ {
|
|
|
+ const QRectF barRect = getBarRect(it->key, it->value);
|
|
|
+ if (mKeyAxis.data()->orientation() == Qt::Horizontal)
|
|
|
+ isVisible = ((!mKeyAxis.data()->rangeReversed() && barRect.left() <= upperPixelBound) || (mKeyAxis.data()->rangeReversed() && barRect.right() >= upperPixelBound));
|
|
|
+ else // keyaxis is vertical
|
|
|
+ isVisible = ((!mKeyAxis.data()->rangeReversed() && barRect.bottom() >= upperPixelBound) || (mKeyAxis.data()->rangeReversed() && barRect.top() <= upperPixelBound));
|
|
|
+ if (isVisible)
|
|
|
+ end = it+1;
|
|
|
+ else
|
|
|
+ break;
|
|
|
+ ++it;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the rect in pixel coordinates of a single bar with the specified \a key and \a value. The
|
|
|
+ rect is shifted according to the bar stacking (see \ref moveAbove) and base value (see \ref
|
|
|
+ setBaseValue), and to have non-overlapping border lines with the bars stacked below.
|
|
|
+*/
|
|
|
+QRectF QCPBars::getBarRect(double key, double value) const
|
|
|
+{
|
|
|
+ QCPAxis *keyAxis = mKeyAxis.data();
|
|
|
+ QCPAxis *valueAxis = mValueAxis.data();
|
|
|
+ if (!keyAxis || !valueAxis) { qDebug() << Q_FUNC_INFO << "invalid key or value axis"; return QRectF(); }
|
|
|
+
|
|
|
+ double lowerPixelWidth, upperPixelWidth;
|
|
|
+ getPixelWidth(key, lowerPixelWidth, upperPixelWidth);
|
|
|
+ double base = getStackedBaseValue(key, value >= 0);
|
|
|
+ double basePixel = valueAxis->coordToPixel(base);
|
|
|
+ double valuePixel = valueAxis->coordToPixel(base+value);
|
|
|
+ double keyPixel = keyAxis->coordToPixel(key);
|
|
|
+ if (mBarsGroup)
|
|
|
+ keyPixel += mBarsGroup->keyPixelOffset(this, key);
|
|
|
+ double bottomOffset = (mBarBelow && mPen != Qt::NoPen ? 1 : 0)*(mPen.isCosmetic() ? 1 : mPen.widthF());
|
|
|
+ bottomOffset += mBarBelow ? mStackingGap : 0;
|
|
|
+ bottomOffset *= (value<0 ? -1 : 1)*valueAxis->pixelOrientation();
|
|
|
+ if (qAbs(valuePixel-basePixel) <= qAbs(bottomOffset))
|
|
|
+ bottomOffset = valuePixel-basePixel;
|
|
|
+ if (keyAxis->orientation() == Qt::Horizontal)
|
|
|
+ {
|
|
|
+ return QRectF(QPointF(keyPixel+lowerPixelWidth, valuePixel), QPointF(keyPixel+upperPixelWidth, basePixel+bottomOffset)).normalized();
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ return QRectF(QPointF(basePixel+bottomOffset, keyPixel+lowerPixelWidth), QPointF(valuePixel, keyPixel+upperPixelWidth)).normalized();
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ This function is used to determine the width of the bar at coordinate \a key, according to the
|
|
|
+ specified width (\ref setWidth) and width type (\ref setWidthType).
|
|
|
+
|
|
|
+ The output parameters \a lower and \a upper return the number of pixels the bar extends to lower
|
|
|
+ and higher keys, relative to the \a key coordinate (so with a non-reversed horizontal axis, \a
|
|
|
+ lower is negative and \a upper positive).
|
|
|
+*/
|
|
|
+void QCPBars::getPixelWidth(double key, double &lower, double &upper) const
|
|
|
+{
|
|
|
+ lower = 0;
|
|
|
+ upper = 0;
|
|
|
+ switch (mWidthType)
|
|
|
+ {
|
|
|
+ case wtAbsolute:
|
|
|
+ {
|
|
|
+ upper = mWidth*0.5*mKeyAxis.data()->pixelOrientation();
|
|
|
+ lower = -upper;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case wtAxisRectRatio:
|
|
|
+ {
|
|
|
+ if (mKeyAxis && mKeyAxis.data()->axisRect())
|
|
|
+ {
|
|
|
+ if (mKeyAxis.data()->orientation() == Qt::Horizontal)
|
|
|
+ upper = mKeyAxis.data()->axisRect()->width()*mWidth*0.5*mKeyAxis.data()->pixelOrientation();
|
|
|
+ else
|
|
|
+ upper = mKeyAxis.data()->axisRect()->height()*mWidth*0.5*mKeyAxis.data()->pixelOrientation();
|
|
|
+ lower = -upper;
|
|
|
+ } else
|
|
|
+ qDebug() << Q_FUNC_INFO << "No key axis or axis rect defined";
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case wtPlotCoords:
|
|
|
+ {
|
|
|
+ if (mKeyAxis)
|
|
|
+ {
|
|
|
+ double keyPixel = mKeyAxis.data()->coordToPixel(key);
|
|
|
+ upper = mKeyAxis.data()->coordToPixel(key+mWidth*0.5)-keyPixel;
|
|
|
+ lower = mKeyAxis.data()->coordToPixel(key-mWidth*0.5)-keyPixel;
|
|
|
+ // no need to qSwap(lower, higher) when range reversed, because higher/lower are gained by
|
|
|
+ // coordinate transform which includes range direction
|
|
|
+ } else
|
|
|
+ qDebug() << Q_FUNC_INFO << "No key axis defined";
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ This function is called to find at which value to start drawing the base of a bar at \a key, when
|
|
|
+ it is stacked on top of another QCPBars (e.g. with \ref moveAbove).
|
|
|
+
|
|
|
+ positive and negative bars are separated per stack (positive are stacked above baseValue upwards,
|
|
|
+ negative are stacked below baseValue downwards). This can be indicated with \a positive. So if the
|
|
|
+ bar for which we need the base value is negative, set \a positive to false.
|
|
|
+*/
|
|
|
+double QCPBars::getStackedBaseValue(double key, bool positive) const
|
|
|
+{
|
|
|
+ if (mBarBelow)
|
|
|
+ {
|
|
|
+ double max = 0; // don't initialize with mBaseValue here because only base value of bottom-most bar has meaning in a bar stack
|
|
|
+ // find bars of mBarBelow that are approximately at key and find largest one:
|
|
|
+ double epsilon = qAbs(key)*(sizeof(key)==4 ? 1e-6 : 1e-14); // should be safe even when changed to use float at some point
|
|
|
+ if (key == 0)
|
|
|
+ epsilon = (sizeof(key)==4 ? 1e-6 : 1e-14);
|
|
|
+ QCPBarsDataContainer::const_iterator it = mBarBelow.data()->mDataContainer->findBegin(key-epsilon);
|
|
|
+ QCPBarsDataContainer::const_iterator itEnd = mBarBelow.data()->mDataContainer->findEnd(key+epsilon);
|
|
|
+ while (it != itEnd)
|
|
|
+ {
|
|
|
+ if (it->key > key-epsilon && it->key < key+epsilon)
|
|
|
+ {
|
|
|
+ if ((positive && it->value > max) ||
|
|
|
+ (!positive && it->value < max))
|
|
|
+ max = it->value;
|
|
|
+ }
|
|
|
+ ++it;
|
|
|
+ }
|
|
|
+ // recurse down the bar-stack to find the total height:
|
|
|
+ return max + mBarBelow.data()->getStackedBaseValue(key, positive);
|
|
|
+ } else
|
|
|
+ return mBaseValue;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Connects \a below and \a above to each other via their mBarAbove/mBarBelow properties. The bar(s)
|
|
|
+ currently above lower and below upper will become disconnected to lower/upper.
|
|
|
+
|
|
|
+ If lower is zero, upper will be disconnected at the bottom.
|
|
|
+ If upper is zero, lower will be disconnected at the top.
|
|
|
+*/
|
|
|
+void QCPBars::connectBars(QCPBars *lower, QCPBars *upper)
|
|
|
+{
|
|
|
+ if (!lower && !upper) return;
|
|
|
+
|
|
|
+ if (!lower) // disconnect upper at bottom
|
|
|
+ {
|
|
|
+ // disconnect old bar below upper:
|
|
|
+ if (upper->mBarBelow && upper->mBarBelow.data()->mBarAbove.data() == upper)
|
|
|
+ upper->mBarBelow.data()->mBarAbove = 0;
|
|
|
+ upper->mBarBelow = 0;
|
|
|
+ } else if (!upper) // disconnect lower at top
|
|
|
+ {
|
|
|
+ // disconnect old bar above lower:
|
|
|
+ if (lower->mBarAbove && lower->mBarAbove.data()->mBarBelow.data() == lower)
|
|
|
+ lower->mBarAbove.data()->mBarBelow = 0;
|
|
|
+ lower->mBarAbove = 0;
|
|
|
+ } else // connect lower and upper
|
|
|
+ {
|
|
|
+ // disconnect old bar above lower:
|
|
|
+ if (lower->mBarAbove && lower->mBarAbove.data()->mBarBelow.data() == lower)
|
|
|
+ lower->mBarAbove.data()->mBarBelow = 0;
|
|
|
+ // disconnect old bar below upper:
|
|
|
+ if (upper->mBarBelow && upper->mBarBelow.data()->mBarAbove.data() == upper)
|
|
|
+ upper->mBarBelow.data()->mBarAbove = 0;
|
|
|
+ lower->mBarAbove = upper;
|
|
|
+ upper->mBarBelow = lower;
|
|
|
+ }
|
|
|
+}
|
|
|
+/* end of 'src/plottables/plottable-bars.cpp' */
|
|
|
+
|
|
|
+
|
|
|
+/* including file 'src/plottables/plottable-statisticalbox.cpp', size 28622 */
|
|
|
+/* commit 9868e55d3b412f2f89766bb482fcf299e93a0988 2017-09-04 01:56:22 +0200 */
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPStatisticalBoxData
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+/*! \class QCPStatisticalBoxData
|
|
|
+ \brief Holds the data of one single data point for QCPStatisticalBox.
|
|
|
+
|
|
|
+ The stored data is:
|
|
|
+
|
|
|
+ \li \a key: coordinate on the key axis of this data point (this is the \a mainKey and the \a sortKey)
|
|
|
+
|
|
|
+ \li \a minimum: the position of the lower whisker, typically the minimum measurement of the
|
|
|
+ sample that's not considered an outlier.
|
|
|
+
|
|
|
+ \li \a lowerQuartile: the lower end of the box. The lower and the upper quartiles are the two
|
|
|
+ statistical quartiles around the median of the sample, they should contain 50% of the sample
|
|
|
+ data.
|
|
|
+
|
|
|
+ \li \a median: the value of the median mark inside the quartile box. The median separates the
|
|
|
+ sample data in half (50% of the sample data is below/above the median). (This is the \a mainValue)
|
|
|
+
|
|
|
+ \li \a upperQuartile: the upper end of the box. The lower and the upper quartiles are the two
|
|
|
+ statistical quartiles around the median of the sample, they should contain 50% of the sample
|
|
|
+ data.
|
|
|
+
|
|
|
+ \li \a maximum: the position of the upper whisker, typically the maximum measurement of the
|
|
|
+ sample that's not considered an outlier.
|
|
|
+
|
|
|
+ \li \a outliers: a QVector of outlier values that will be drawn as scatter points at the \a key
|
|
|
+ coordinate of this data point (see \ref QCPStatisticalBox::setOutlierStyle)
|
|
|
+
|
|
|
+ The container for storing multiple data points is \ref QCPStatisticalBoxDataContainer. It is a
|
|
|
+ typedef for \ref QCPDataContainer with \ref QCPStatisticalBoxData as the DataType template
|
|
|
+ parameter. See the documentation there for an explanation regarding the data type's generic
|
|
|
+ methods.
|
|
|
+
|
|
|
+ \see QCPStatisticalBoxDataContainer
|
|
|
+*/
|
|
|
+
|
|
|
+/* start documentation of inline functions */
|
|
|
+
|
|
|
+/*! \fn double QCPStatisticalBoxData::sortKey() const
|
|
|
+
|
|
|
+ Returns the \a key member of this data point.
|
|
|
+
|
|
|
+ For a general explanation of what this method is good for in the context of the data container,
|
|
|
+ see the documentation of \ref QCPDataContainer.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn static QCPStatisticalBoxData QCPStatisticalBoxData::fromSortKey(double sortKey)
|
|
|
+
|
|
|
+ Returns a data point with the specified \a sortKey. All other members are set to zero.
|
|
|
+
|
|
|
+ For a general explanation of what this method is good for in the context of the data container,
|
|
|
+ see the documentation of \ref QCPDataContainer.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn static static bool QCPStatisticalBoxData::sortKeyIsMainKey()
|
|
|
+
|
|
|
+ Since the member \a key is both the data point key coordinate and the data ordering parameter,
|
|
|
+ this method returns true.
|
|
|
+
|
|
|
+ For a general explanation of what this method is good for in the context of the data container,
|
|
|
+ see the documentation of \ref QCPDataContainer.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn double QCPStatisticalBoxData::mainKey() const
|
|
|
+
|
|
|
+ Returns the \a key member of this data point.
|
|
|
+
|
|
|
+ For a general explanation of what this method is good for in the context of the data container,
|
|
|
+ see the documentation of \ref QCPDataContainer.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn double QCPStatisticalBoxData::mainValue() const
|
|
|
+
|
|
|
+ Returns the \a median member of this data point.
|
|
|
+
|
|
|
+ For a general explanation of what this method is good for in the context of the data container,
|
|
|
+ see the documentation of \ref QCPDataContainer.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn QCPRange QCPStatisticalBoxData::valueRange() const
|
|
|
+
|
|
|
+ Returns a QCPRange spanning from the \a minimum to the \a maximum member of this statistical box
|
|
|
+ data point, possibly further expanded by outliers.
|
|
|
+
|
|
|
+ For a general explanation of what this method is good for in the context of the data container,
|
|
|
+ see the documentation of \ref QCPDataContainer.
|
|
|
+*/
|
|
|
+
|
|
|
+/* end documentation of inline functions */
|
|
|
+
|
|
|
+/*!
|
|
|
+ Constructs a data point with key and all values set to zero.
|
|
|
+*/
|
|
|
+QCPStatisticalBoxData::QCPStatisticalBoxData() :
|
|
|
+ key(0),
|
|
|
+ minimum(0),
|
|
|
+ lowerQuartile(0),
|
|
|
+ median(0),
|
|
|
+ upperQuartile(0),
|
|
|
+ maximum(0)
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Constructs a data point with the specified \a key, \a minimum, \a lowerQuartile, \a median, \a
|
|
|
+ upperQuartile, \a maximum and optionally a number of \a outliers.
|
|
|
+*/
|
|
|
+QCPStatisticalBoxData::QCPStatisticalBoxData(double key, double minimum, double lowerQuartile, double median, double upperQuartile, double maximum, const QVector<double> &outliers) :
|
|
|
+ key(key),
|
|
|
+ minimum(minimum),
|
|
|
+ lowerQuartile(lowerQuartile),
|
|
|
+ median(median),
|
|
|
+ upperQuartile(upperQuartile),
|
|
|
+ maximum(maximum),
|
|
|
+ outliers(outliers)
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPStatisticalBox
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+/*! \class QCPStatisticalBox
|
|
|
+ \brief A plottable representing a single statistical box in a plot.
|
|
|
+
|
|
|
+ \image html QCPStatisticalBox.png
|
|
|
+
|
|
|
+ To plot data, assign it with the \ref setData or \ref addData functions. Alternatively, you can
|
|
|
+ also access and modify the data via the \ref data method, which returns a pointer to the internal
|
|
|
+ \ref QCPStatisticalBoxDataContainer.
|
|
|
+
|
|
|
+ Additionally each data point can itself have a list of outliers, drawn as scatter points at the
|
|
|
+ key coordinate of the respective statistical box data point. They can either be set by using the
|
|
|
+ respective \ref addData(double,double,double,double,double,double,const QVector<double>&)
|
|
|
+ "addData" method or accessing the individual data points through \ref data, and setting the
|
|
|
+ <tt>QVector<double> outliers</tt> of the data points directly.
|
|
|
+
|
|
|
+ \section qcpstatisticalbox-appearance Changing the appearance
|
|
|
+
|
|
|
+ The appearance of each data point box, ranging from the lower to the upper quartile, is
|
|
|
+ controlled via \ref setPen and \ref setBrush. You may change the width of the boxes with \ref
|
|
|
+ setWidth in plot coordinates.
|
|
|
+
|
|
|
+ Each data point's visual representation also consists of two whiskers. Whiskers are the lines
|
|
|
+ which reach from the upper quartile to the maximum, and from the lower quartile to the minimum.
|
|
|
+ The appearance of the whiskers can be modified with: \ref setWhiskerPen, \ref setWhiskerBarPen,
|
|
|
+ \ref setWhiskerWidth. The whisker width is the width of the bar perpendicular to the whisker at
|
|
|
+ the top (for maximum) and bottom (for minimum). If the whisker pen is changed, make sure to set
|
|
|
+ the \c capStyle to \c Qt::FlatCap. Otherwise the backbone line might exceed the whisker bars by a
|
|
|
+ few pixels due to the pen cap being not perfectly flat.
|
|
|
+
|
|
|
+ The median indicator line inside the box has its own pen, \ref setMedianPen.
|
|
|
+
|
|
|
+ The outlier data points are drawn as normal scatter points. Their look can be controlled with
|
|
|
+ \ref setOutlierStyle
|
|
|
+
|
|
|
+ \section qcpstatisticalbox-usage Usage
|
|
|
+
|
|
|
+ Like all data representing objects in QCustomPlot, the QCPStatisticalBox is a plottable
|
|
|
+ (QCPAbstractPlottable). So the plottable-interface of QCustomPlot applies
|
|
|
+ (QCustomPlot::plottable, QCustomPlot::removePlottable, etc.)
|
|
|
+
|
|
|
+ Usually, you first create an instance:
|
|
|
+ \snippet documentation/doc-code-snippets/mainwindow.cpp qcpstatisticalbox-creation-1
|
|
|
+ which registers it with the QCustomPlot instance of the passed axes. Note that this QCustomPlot instance takes
|
|
|
+ ownership of the plottable, so do not delete it manually but use QCustomPlot::removePlottable() instead.
|
|
|
+ The newly created plottable can be modified, e.g.:
|
|
|
+ \snippet documentation/doc-code-snippets/mainwindow.cpp qcpstatisticalbox-creation-2
|
|
|
+*/
|
|
|
+
|
|
|
+/* start documentation of inline functions */
|
|
|
+
|
|
|
+/*! \fn QSharedPointer<QCPStatisticalBoxDataContainer> QCPStatisticalBox::data() const
|
|
|
+
|
|
|
+ Returns a shared pointer to the internal data storage of type \ref
|
|
|
+ QCPStatisticalBoxDataContainer. You may use it to directly manipulate the data, which may be more
|
|
|
+ convenient and faster than using the regular \ref setData or \ref addData methods.
|
|
|
+*/
|
|
|
+
|
|
|
+/* end documentation of inline functions */
|
|
|
+
|
|
|
+/*!
|
|
|
+ Constructs a statistical box which uses \a keyAxis as its key axis ("x") and \a valueAxis as its
|
|
|
+ value axis ("y"). \a keyAxis and \a valueAxis must reside in the same QCustomPlot instance and
|
|
|
+ not have the same orientation. If either of these restrictions is violated, a corresponding
|
|
|
+ message is printed to the debug output (qDebug), the construction is not aborted, though.
|
|
|
+
|
|
|
+ The created QCPStatisticalBox is automatically registered with the QCustomPlot instance inferred
|
|
|
+ from \a keyAxis. This QCustomPlot instance takes ownership of the QCPStatisticalBox, so do not
|
|
|
+ delete it manually but use QCustomPlot::removePlottable() instead.
|
|
|
+*/
|
|
|
+QCPStatisticalBox::QCPStatisticalBox(QCPAxis *keyAxis, QCPAxis *valueAxis) :
|
|
|
+ QCPAbstractPlottable1D<QCPStatisticalBoxData>(keyAxis, valueAxis),
|
|
|
+ mWidth(0.5),
|
|
|
+ mWhiskerWidth(0.2),
|
|
|
+ mWhiskerPen(Qt::black, 0, Qt::DashLine, Qt::FlatCap),
|
|
|
+ mWhiskerBarPen(Qt::black),
|
|
|
+ mWhiskerAntialiased(false),
|
|
|
+ mMedianPen(Qt::black, 3, Qt::SolidLine, Qt::FlatCap),
|
|
|
+ mOutlierStyle(QCPScatterStyle::ssCircle, Qt::blue, 6)
|
|
|
+{
|
|
|
+ setPen(QPen(Qt::black));
|
|
|
+ setBrush(Qt::NoBrush);
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Replaces the current data container with the provided \a data container.
|
|
|
+
|
|
|
+ Since a QSharedPointer is used, multiple QCPStatisticalBoxes may share the same data container
|
|
|
+ safely. Modifying the data in the container will then affect all statistical boxes that share the
|
|
|
+ container. Sharing can be achieved by simply exchanging the data containers wrapped in shared
|
|
|
+ pointers:
|
|
|
+ \snippet documentation/doc-code-snippets/mainwindow.cpp qcpstatisticalbox-datasharing-1
|
|
|
+
|
|
|
+ If you do not wish to share containers, but create a copy from an existing container, rather use
|
|
|
+ the \ref QCPDataContainer<DataType>::set method on the statistical box data container directly:
|
|
|
+ \snippet documentation/doc-code-snippets/mainwindow.cpp qcpstatisticalbox-datasharing-2
|
|
|
+
|
|
|
+ \see addData
|
|
|
+*/
|
|
|
+void QCPStatisticalBox::setData(QSharedPointer<QCPStatisticalBoxDataContainer> data)
|
|
|
+{
|
|
|
+ mDataContainer = data;
|
|
|
+}
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Replaces the current data with the provided points in \a keys, \a minimum, \a lowerQuartile, \a
|
|
|
+ median, \a upperQuartile and \a maximum. The provided vectors should have equal length. Else, the
|
|
|
+ number of added points will be the size of the smallest vector.
|
|
|
+
|
|
|
+ If you can guarantee that the passed data points are sorted by \a keys in ascending order, you
|
|
|
+ can set \a alreadySorted to true, to improve performance by saving a sorting run.
|
|
|
+
|
|
|
+ \see addData
|
|
|
+*/
|
|
|
+void QCPStatisticalBox::setData(const QVector<double> &keys, const QVector<double> &minimum, const QVector<double> &lowerQuartile, const QVector<double> &median, const QVector<double> &upperQuartile, const QVector<double> &maximum, bool alreadySorted)
|
|
|
+{
|
|
|
+ mDataContainer->clear();
|
|
|
+ addData(keys, minimum, lowerQuartile, median, upperQuartile, maximum, alreadySorted);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the width of the boxes in key coordinates.
|
|
|
+
|
|
|
+ \see setWhiskerWidth
|
|
|
+*/
|
|
|
+void QCPStatisticalBox::setWidth(double width)
|
|
|
+{
|
|
|
+ mWidth = width;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the width of the whiskers in key coordinates.
|
|
|
+
|
|
|
+ Whiskers are the lines which reach from the upper quartile to the maximum, and from the lower
|
|
|
+ quartile to the minimum.
|
|
|
+
|
|
|
+ \see setWidth
|
|
|
+*/
|
|
|
+void QCPStatisticalBox::setWhiskerWidth(double width)
|
|
|
+{
|
|
|
+ mWhiskerWidth = width;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the pen used for drawing the whisker backbone.
|
|
|
+
|
|
|
+ Whiskers are the lines which reach from the upper quartile to the maximum, and from the lower
|
|
|
+ quartile to the minimum.
|
|
|
+
|
|
|
+ Make sure to set the \c capStyle of the passed \a pen to \c Qt::FlatCap. Otherwise the backbone
|
|
|
+ line might exceed the whisker bars by a few pixels due to the pen cap being not perfectly flat.
|
|
|
+
|
|
|
+ \see setWhiskerBarPen
|
|
|
+*/
|
|
|
+void QCPStatisticalBox::setWhiskerPen(const QPen &pen)
|
|
|
+{
|
|
|
+ mWhiskerPen = pen;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the pen used for drawing the whisker bars. Those are the lines parallel to the key axis at
|
|
|
+ each end of the whisker backbone.
|
|
|
+
|
|
|
+ Whiskers are the lines which reach from the upper quartile to the maximum, and from the lower
|
|
|
+ quartile to the minimum.
|
|
|
+
|
|
|
+ \see setWhiskerPen
|
|
|
+*/
|
|
|
+void QCPStatisticalBox::setWhiskerBarPen(const QPen &pen)
|
|
|
+{
|
|
|
+ mWhiskerBarPen = pen;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets whether the statistical boxes whiskers are drawn with antialiasing or not.
|
|
|
+
|
|
|
+ Note that antialiasing settings may be overridden by QCustomPlot::setAntialiasedElements and
|
|
|
+ QCustomPlot::setNotAntialiasedElements.
|
|
|
+*/
|
|
|
+void QCPStatisticalBox::setWhiskerAntialiased(bool enabled)
|
|
|
+{
|
|
|
+ mWhiskerAntialiased = enabled;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the pen used for drawing the median indicator line inside the statistical boxes.
|
|
|
+*/
|
|
|
+void QCPStatisticalBox::setMedianPen(const QPen &pen)
|
|
|
+{
|
|
|
+ mMedianPen = pen;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the appearance of the outlier data points.
|
|
|
+
|
|
|
+ Outliers can be specified with the method
|
|
|
+ \ref addData(double key, double minimum, double lowerQuartile, double median, double upperQuartile, double maximum, const QVector<double> &outliers)
|
|
|
+*/
|
|
|
+void QCPStatisticalBox::setOutlierStyle(const QCPScatterStyle &style)
|
|
|
+{
|
|
|
+ mOutlierStyle = style;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Adds the provided points in \a keys, \a minimum, \a lowerQuartile, \a median, \a upperQuartile and
|
|
|
+ \a maximum to the current data. The provided vectors should have equal length. Else, the number
|
|
|
+ of added points will be the size of the smallest vector.
|
|
|
+
|
|
|
+ If you can guarantee that the passed data points are sorted by \a keys in ascending order, you
|
|
|
+ can set \a alreadySorted to true, to improve performance by saving a sorting run.
|
|
|
+
|
|
|
+ Alternatively, you can also access and modify the data directly via the \ref data method, which
|
|
|
+ returns a pointer to the internal data container.
|
|
|
+*/
|
|
|
+void QCPStatisticalBox::addData(const QVector<double> &keys, const QVector<double> &minimum, const QVector<double> &lowerQuartile, const QVector<double> &median, const QVector<double> &upperQuartile, const QVector<double> &maximum, bool alreadySorted)
|
|
|
+{
|
|
|
+ if (keys.size() != minimum.size() || minimum.size() != lowerQuartile.size() || lowerQuartile.size() != median.size() ||
|
|
|
+ median.size() != upperQuartile.size() || upperQuartile.size() != maximum.size() || maximum.size() != keys.size())
|
|
|
+ qDebug() << Q_FUNC_INFO << "keys, minimum, lowerQuartile, median, upperQuartile, maximum have different sizes:"
|
|
|
+ << keys.size() << minimum.size() << lowerQuartile.size() << median.size() << upperQuartile.size() << maximum.size();
|
|
|
+ const int n = qMin(keys.size(), qMin(minimum.size(), qMin(lowerQuartile.size(), qMin(median.size(), qMin(upperQuartile.size(), maximum.size())))));
|
|
|
+ QVector<QCPStatisticalBoxData> tempData(n);
|
|
|
+ QVector<QCPStatisticalBoxData>::iterator it = tempData.begin();
|
|
|
+ const QVector<QCPStatisticalBoxData>::iterator itEnd = tempData.end();
|
|
|
+ int i = 0;
|
|
|
+ while (it != itEnd)
|
|
|
+ {
|
|
|
+ it->key = keys[i];
|
|
|
+ it->minimum = minimum[i];
|
|
|
+ it->lowerQuartile = lowerQuartile[i];
|
|
|
+ it->median = median[i];
|
|
|
+ it->upperQuartile = upperQuartile[i];
|
|
|
+ it->maximum = maximum[i];
|
|
|
+ ++it;
|
|
|
+ ++i;
|
|
|
+ }
|
|
|
+ mDataContainer->add(tempData, alreadySorted); // don't modify tempData beyond this to prevent copy on write
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Adds the provided data point as \a key, \a minimum, \a lowerQuartile, \a median, \a upperQuartile
|
|
|
+ and \a maximum to the current data.
|
|
|
+
|
|
|
+ Alternatively, you can also access and modify the data directly via the \ref data method, which
|
|
|
+ returns a pointer to the internal data container.
|
|
|
+*/
|
|
|
+void QCPStatisticalBox::addData(double key, double minimum, double lowerQuartile, double median, double upperQuartile, double maximum, const QVector<double> &outliers)
|
|
|
+{
|
|
|
+ mDataContainer->add(QCPStatisticalBoxData(key, minimum, lowerQuartile, median, upperQuartile, maximum, outliers));
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ \copydoc QCPPlottableInterface1D::selectTestRect
|
|
|
+*/
|
|
|
+QCPDataSelection QCPStatisticalBox::selectTestRect(const QRectF &rect, bool onlySelectable) const
|
|
|
+{
|
|
|
+ QCPDataSelection result;
|
|
|
+ if ((onlySelectable && mSelectable == QCP::stNone) || mDataContainer->isEmpty())
|
|
|
+ return result;
|
|
|
+ if (!mKeyAxis || !mValueAxis)
|
|
|
+ return result;
|
|
|
+
|
|
|
+ QCPStatisticalBoxDataContainer::const_iterator visibleBegin, visibleEnd;
|
|
|
+ getVisibleDataBounds(visibleBegin, visibleEnd);
|
|
|
+
|
|
|
+ for (QCPStatisticalBoxDataContainer::const_iterator it=visibleBegin; it!=visibleEnd; ++it)
|
|
|
+ {
|
|
|
+ if (rect.intersects(getQuartileBox(it)))
|
|
|
+ result.addDataRange(QCPDataRange(it-mDataContainer->constBegin(), it-mDataContainer->constBegin()+1), false);
|
|
|
+ }
|
|
|
+ result.simplify();
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+double QCPStatisticalBox::selectTest(const QPointF &pos, bool onlySelectable, QVariant *details) const
|
|
|
+{
|
|
|
+ Q_UNUSED(details)
|
|
|
+ if ((onlySelectable && mSelectable == QCP::stNone) || mDataContainer->isEmpty())
|
|
|
+ return -1;
|
|
|
+ if (!mKeyAxis || !mValueAxis)
|
|
|
+ return -1;
|
|
|
+
|
|
|
+ if (mKeyAxis->axisRect()->rect().contains(pos.toPoint()))
|
|
|
+ {
|
|
|
+ // get visible data range:
|
|
|
+ QCPStatisticalBoxDataContainer::const_iterator visibleBegin, visibleEnd;
|
|
|
+ QCPStatisticalBoxDataContainer::const_iterator closestDataPoint = mDataContainer->constEnd();
|
|
|
+ getVisibleDataBounds(visibleBegin, visibleEnd);
|
|
|
+ double minDistSqr = std::numeric_limits<double>::max();
|
|
|
+ for (QCPStatisticalBoxDataContainer::const_iterator it=visibleBegin; it!=visibleEnd; ++it)
|
|
|
+ {
|
|
|
+ if (getQuartileBox(it).contains(pos)) // quartile box
|
|
|
+ {
|
|
|
+ double currentDistSqr = mParentPlot->selectionTolerance()*0.99 * mParentPlot->selectionTolerance()*0.99;
|
|
|
+ if (currentDistSqr < minDistSqr)
|
|
|
+ {
|
|
|
+ minDistSqr = currentDistSqr;
|
|
|
+ closestDataPoint = it;
|
|
|
+ }
|
|
|
+ } else // whiskers
|
|
|
+ {
|
|
|
+ const QVector<QLineF> whiskerBackbones(getWhiskerBackboneLines(it));
|
|
|
+ for (int i=0; i<whiskerBackbones.size(); ++i)
|
|
|
+ {
|
|
|
+ double currentDistSqr = QCPVector2D(pos).distanceSquaredToLine(whiskerBackbones.at(i));
|
|
|
+ if (currentDistSqr < minDistSqr)
|
|
|
+ {
|
|
|
+ minDistSqr = currentDistSqr;
|
|
|
+ closestDataPoint = it;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (details)
|
|
|
+ {
|
|
|
+ int pointIndex = closestDataPoint-mDataContainer->constBegin();
|
|
|
+ details->setValue(QCPDataSelection(QCPDataRange(pointIndex, pointIndex+1)));
|
|
|
+ }
|
|
|
+ return qSqrt(minDistSqr);
|
|
|
+ }
|
|
|
+ return -1;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+QCPRange QCPStatisticalBox::getKeyRange(bool &foundRange, QCP::SignDomain inSignDomain) const
|
|
|
+{
|
|
|
+ QCPRange range = mDataContainer->keyRange(foundRange, inSignDomain);
|
|
|
+ // determine exact range by including width of bars/flags:
|
|
|
+ if (foundRange)
|
|
|
+ {
|
|
|
+ if (inSignDomain != QCP::sdPositive || range.lower-mWidth*0.5 > 0)
|
|
|
+ range.lower -= mWidth*0.5;
|
|
|
+ if (inSignDomain != QCP::sdNegative || range.upper+mWidth*0.5 < 0)
|
|
|
+ range.upper += mWidth*0.5;
|
|
|
+ }
|
|
|
+ return range;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+QCPRange QCPStatisticalBox::getValueRange(bool &foundRange, QCP::SignDomain inSignDomain, const QCPRange &inKeyRange) const
|
|
|
+{
|
|
|
+ return mDataContainer->valueRange(foundRange, inSignDomain, inKeyRange);
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPStatisticalBox::draw(QCPPainter *painter)
|
|
|
+{
|
|
|
+ if (mDataContainer->isEmpty()) return;
|
|
|
+ QCPAxis *keyAxis = mKeyAxis.data();
|
|
|
+ QCPAxis *valueAxis = mValueAxis.data();
|
|
|
+ if (!keyAxis || !valueAxis) { qDebug() << Q_FUNC_INFO << "invalid key or value axis"; return; }
|
|
|
+
|
|
|
+ QCPStatisticalBoxDataContainer::const_iterator visibleBegin, visibleEnd;
|
|
|
+ getVisibleDataBounds(visibleBegin, visibleEnd);
|
|
|
+
|
|
|
+ // loop over and draw segments of unselected/selected data:
|
|
|
+ QList<QCPDataRange> selectedSegments, unselectedSegments, allSegments;
|
|
|
+ getDataSegments(selectedSegments, unselectedSegments);
|
|
|
+ allSegments << unselectedSegments << selectedSegments;
|
|
|
+ for (int i=0; i<allSegments.size(); ++i)
|
|
|
+ {
|
|
|
+ bool isSelectedSegment = i >= unselectedSegments.size();
|
|
|
+ QCPStatisticalBoxDataContainer::const_iterator begin = visibleBegin;
|
|
|
+ QCPStatisticalBoxDataContainer::const_iterator end = visibleEnd;
|
|
|
+ mDataContainer->limitIteratorsToDataRange(begin, end, allSegments.at(i));
|
|
|
+ if (begin == end)
|
|
|
+ continue;
|
|
|
+
|
|
|
+ for (QCPStatisticalBoxDataContainer::const_iterator it=begin; it!=end; ++it)
|
|
|
+ {
|
|
|
+ // check data validity if flag set:
|
|
|
+# ifdef QCUSTOMPLOT_CHECK_DATA
|
|
|
+ if (QCP::isInvalidData(it->key, it->minimum) ||
|
|
|
+ QCP::isInvalidData(it->lowerQuartile, it->median) ||
|
|
|
+ QCP::isInvalidData(it->upperQuartile, it->maximum))
|
|
|
+ qDebug() << Q_FUNC_INFO << "Data point at" << it->key << "of drawn range has invalid data." << "Plottable name:" << name();
|
|
|
+ for (int i=0; i<it->outliers.size(); ++i)
|
|
|
+ if (QCP::isInvalidData(it->outliers.at(i)))
|
|
|
+ qDebug() << Q_FUNC_INFO << "Data point outlier at" << it->key << "of drawn range invalid." << "Plottable name:" << name();
|
|
|
+# endif
|
|
|
+
|
|
|
+ if (isSelectedSegment && mSelectionDecorator)
|
|
|
+ {
|
|
|
+ mSelectionDecorator->applyPen(painter);
|
|
|
+ mSelectionDecorator->applyBrush(painter);
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ painter->setPen(mPen);
|
|
|
+ painter->setBrush(mBrush);
|
|
|
+ }
|
|
|
+ QCPScatterStyle finalOutlierStyle = mOutlierStyle;
|
|
|
+ if (isSelectedSegment && mSelectionDecorator)
|
|
|
+ finalOutlierStyle = mSelectionDecorator->getFinalScatterStyle(mOutlierStyle);
|
|
|
+ drawStatisticalBox(painter, it, finalOutlierStyle);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // draw other selection decoration that isn't just line/scatter pens and brushes:
|
|
|
+ if (mSelectionDecorator)
|
|
|
+ mSelectionDecorator->drawDecoration(painter, selection());
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPStatisticalBox::drawLegendIcon(QCPPainter *painter, const QRectF &rect) const
|
|
|
+{
|
|
|
+ // draw filled rect:
|
|
|
+ applyDefaultAntialiasingHint(painter);
|
|
|
+ painter->setPen(mPen);
|
|
|
+ painter->setBrush(mBrush);
|
|
|
+ QRectF r = QRectF(0, 0, rect.width()*0.67, rect.height()*0.67);
|
|
|
+ r.moveCenter(rect.center());
|
|
|
+ painter->drawRect(r);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Draws the graphical representation of a single statistical box with the data given by the
|
|
|
+ iterator \a it with the provided \a painter.
|
|
|
+
|
|
|
+ If the statistical box has a set of outlier data points, they are drawn with \a outlierStyle.
|
|
|
+
|
|
|
+ \see getQuartileBox, getWhiskerBackboneLines, getWhiskerBarLines
|
|
|
+*/
|
|
|
+void QCPStatisticalBox::drawStatisticalBox(QCPPainter *painter, QCPStatisticalBoxDataContainer::const_iterator it, const QCPScatterStyle &outlierStyle) const
|
|
|
+{
|
|
|
+ // draw quartile box:
|
|
|
+ applyDefaultAntialiasingHint(painter);
|
|
|
+ const QRectF quartileBox = getQuartileBox(it);
|
|
|
+ painter->drawRect(quartileBox);
|
|
|
+ // draw median line with cliprect set to quartile box:
|
|
|
+ painter->save();
|
|
|
+ painter->setClipRect(quartileBox, Qt::IntersectClip);
|
|
|
+ painter->setPen(mMedianPen);
|
|
|
+ painter->drawLine(QLineF(coordsToPixels(it->key-mWidth*0.5, it->median), coordsToPixels(it->key+mWidth*0.5, it->median)));
|
|
|
+ painter->restore();
|
|
|
+ // draw whisker lines:
|
|
|
+ applyAntialiasingHint(painter, mWhiskerAntialiased, QCP::aePlottables);
|
|
|
+ painter->setPen(mWhiskerPen);
|
|
|
+ painter->drawLines(getWhiskerBackboneLines(it));
|
|
|
+ painter->setPen(mWhiskerBarPen);
|
|
|
+ painter->drawLines(getWhiskerBarLines(it));
|
|
|
+ // draw outliers:
|
|
|
+ applyScattersAntialiasingHint(painter);
|
|
|
+ outlierStyle.applyTo(painter, mPen);
|
|
|
+ for (int i=0; i<it->outliers.size(); ++i)
|
|
|
+ outlierStyle.drawShape(painter, coordsToPixels(it->key, it->outliers.at(i)));
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ called by \ref draw to determine which data (key) range is visible at the current key axis range
|
|
|
+ setting, so only that needs to be processed. It also takes into account the bar width.
|
|
|
+
|
|
|
+ \a begin returns an iterator to the lowest data point that needs to be taken into account when
|
|
|
+ plotting. Note that in order to get a clean plot all the way to the edge of the axis rect, \a
|
|
|
+ lower may still be just outside the visible range.
|
|
|
+
|
|
|
+ \a end returns an iterator one higher than the highest visible data point. Same as before, \a end
|
|
|
+ may also lie just outside of the visible range.
|
|
|
+
|
|
|
+ if the plottable contains no data, both \a begin and \a end point to constEnd.
|
|
|
+*/
|
|
|
+void QCPStatisticalBox::getVisibleDataBounds(QCPStatisticalBoxDataContainer::const_iterator &begin, QCPStatisticalBoxDataContainer::const_iterator &end) const
|
|
|
+{
|
|
|
+ if (!mKeyAxis)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "invalid key axis";
|
|
|
+ begin = mDataContainer->constEnd();
|
|
|
+ end = mDataContainer->constEnd();
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ begin = mDataContainer->findBegin(mKeyAxis.data()->range().lower-mWidth*0.5); // subtract half width of box to include partially visible data points
|
|
|
+ end = mDataContainer->findEnd(mKeyAxis.data()->range().upper+mWidth*0.5); // add half width of box to include partially visible data points
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the box in plot coordinates (keys in x, values in y of the returned rect) that covers the
|
|
|
+ value range from the lower to the upper quartile, of the data given by \a it.
|
|
|
+
|
|
|
+ \see drawStatisticalBox, getWhiskerBackboneLines, getWhiskerBarLines
|
|
|
+*/
|
|
|
+QRectF QCPStatisticalBox::getQuartileBox(QCPStatisticalBoxDataContainer::const_iterator it) const
|
|
|
+{
|
|
|
+ QRectF result;
|
|
|
+ result.setTopLeft(coordsToPixels(it->key-mWidth*0.5, it->upperQuartile));
|
|
|
+ result.setBottomRight(coordsToPixels(it->key+mWidth*0.5, it->lowerQuartile));
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the whisker backbones (keys in x, values in y of the returned lines) that cover the value
|
|
|
+ range from the minimum to the lower quartile, and from the upper quartile to the maximum of the
|
|
|
+ data given by \a it.
|
|
|
+
|
|
|
+ \see drawStatisticalBox, getQuartileBox, getWhiskerBarLines
|
|
|
+*/
|
|
|
+QVector<QLineF> QCPStatisticalBox::getWhiskerBackboneLines(QCPStatisticalBoxDataContainer::const_iterator it) const
|
|
|
+{
|
|
|
+ QVector<QLineF> result(2);
|
|
|
+ result[0].setPoints(coordsToPixels(it->key, it->lowerQuartile), coordsToPixels(it->key, it->minimum)); // min backbone
|
|
|
+ result[1].setPoints(coordsToPixels(it->key, it->upperQuartile), coordsToPixels(it->key, it->maximum)); // max backbone
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the whisker bars (keys in x, values in y of the returned lines) that are placed at the
|
|
|
+ end of the whisker backbones, at the minimum and maximum of the data given by \a it.
|
|
|
+
|
|
|
+ \see drawStatisticalBox, getQuartileBox, getWhiskerBackboneLines
|
|
|
+*/
|
|
|
+QVector<QLineF> QCPStatisticalBox::getWhiskerBarLines(QCPStatisticalBoxDataContainer::const_iterator it) const
|
|
|
+{
|
|
|
+ QVector<QLineF> result(2);
|
|
|
+ result[0].setPoints(coordsToPixels(it->key-mWhiskerWidth*0.5, it->minimum), coordsToPixels(it->key+mWhiskerWidth*0.5, it->minimum)); // min bar
|
|
|
+ result[1].setPoints(coordsToPixels(it->key-mWhiskerWidth*0.5, it->maximum), coordsToPixels(it->key+mWhiskerWidth*0.5, it->maximum)); // max bar
|
|
|
+ return result;
|
|
|
+}
|
|
|
+/* end of 'src/plottables/plottable-statisticalbox.cpp' */
|
|
|
+
|
|
|
+
|
|
|
+/* including file 'src/plottables/plottable-colormap.cpp', size 47881 */
|
|
|
+/* commit 9868e55d3b412f2f89766bb482fcf299e93a0988 2017-09-04 01:56:22 +0200 */
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPColorMapData
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+/*! \class QCPColorMapData
|
|
|
+ \brief Holds the two-dimensional data of a QCPColorMap plottable.
|
|
|
+
|
|
|
+ This class is a data storage for \ref QCPColorMap. It holds a two-dimensional array, which \ref
|
|
|
+ QCPColorMap then displays as a 2D image in the plot, where the array values are represented by a
|
|
|
+ color, depending on the value.
|
|
|
+
|
|
|
+ The size of the array can be controlled via \ref setSize (or \ref setKeySize, \ref setValueSize).
|
|
|
+ Which plot coordinates these cells correspond to can be configured with \ref setRange (or \ref
|
|
|
+ setKeyRange, \ref setValueRange).
|
|
|
+
|
|
|
+ The data cells can be accessed in two ways: They can be directly addressed by an integer index
|
|
|
+ with \ref setCell. This is the fastest method. Alternatively, they can be addressed by their plot
|
|
|
+ coordinate with \ref setData. plot coordinate to cell index transformations and vice versa are
|
|
|
+ provided by the functions \ref coordToCell and \ref cellToCoord.
|
|
|
+
|
|
|
+ A \ref QCPColorMapData also holds an on-demand two-dimensional array of alpha values which (if
|
|
|
+ allocated) has the same size as the data map. It can be accessed via \ref setAlpha, \ref
|
|
|
+ fillAlpha and \ref clearAlpha. The memory for the alpha map is only allocated if needed, i.e. on
|
|
|
+ the first call of \ref setAlpha. \ref clearAlpha restores full opacity and frees the alpha map.
|
|
|
+
|
|
|
+ This class also buffers the minimum and maximum values that are in the data set, to provide
|
|
|
+ QCPColorMap::rescaleDataRange with the necessary information quickly. Setting a cell to a value
|
|
|
+ that is greater than the current maximum increases this maximum to the new value. However,
|
|
|
+ setting the cell that currently holds the maximum value to a smaller value doesn't decrease the
|
|
|
+ maximum again, because finding the true new maximum would require going through the entire data
|
|
|
+ array, which might be time consuming. The same holds for the data minimum. This functionality is
|
|
|
+ given by \ref recalculateDataBounds, such that you can decide when it is sensible to find the
|
|
|
+ true current minimum and maximum. The method QCPColorMap::rescaleDataRange offers a convenience
|
|
|
+ parameter \a recalculateDataBounds which may be set to true to automatically call \ref
|
|
|
+ recalculateDataBounds internally.
|
|
|
+*/
|
|
|
+
|
|
|
+/* start of documentation of inline functions */
|
|
|
+
|
|
|
+/*! \fn bool QCPColorMapData::isEmpty() const
|
|
|
+
|
|
|
+ Returns whether this instance carries no data. This is equivalent to having a size where at least
|
|
|
+ one of the dimensions is 0 (see \ref setSize).
|
|
|
+*/
|
|
|
+
|
|
|
+/* end of documentation of inline functions */
|
|
|
+
|
|
|
+/*!
|
|
|
+ Constructs a new QCPColorMapData instance. The instance has \a keySize cells in the key direction
|
|
|
+ and \a valueSize cells in the value direction. These cells will be displayed by the \ref QCPColorMap
|
|
|
+ at the coordinates \a keyRange and \a valueRange.
|
|
|
+
|
|
|
+ \see setSize, setKeySize, setValueSize, setRange, setKeyRange, setValueRange
|
|
|
+*/
|
|
|
+QCPColorMapData::QCPColorMapData(int keySize, int valueSize, const QCPRange &keyRange, const QCPRange &valueRange) :
|
|
|
+ mKeySize(0),
|
|
|
+ mValueSize(0),
|
|
|
+ mKeyRange(keyRange),
|
|
|
+ mValueRange(valueRange),
|
|
|
+ mIsEmpty(true),
|
|
|
+ mData(0),
|
|
|
+ mAlpha(0),
|
|
|
+ mDataModified(true)
|
|
|
+{
|
|
|
+ setSize(keySize, valueSize);
|
|
|
+ fill(0);
|
|
|
+}
|
|
|
+
|
|
|
+QCPColorMapData::~QCPColorMapData()
|
|
|
+{
|
|
|
+ if (mData)
|
|
|
+ delete[] mData;
|
|
|
+ if (mAlpha)
|
|
|
+ delete[] mAlpha;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Constructs a new QCPColorMapData instance copying the data and range of \a other.
|
|
|
+*/
|
|
|
+QCPColorMapData::QCPColorMapData(const QCPColorMapData &other) :
|
|
|
+ mKeySize(0),
|
|
|
+ mValueSize(0),
|
|
|
+ mIsEmpty(true),
|
|
|
+ mData(0),
|
|
|
+ mAlpha(0),
|
|
|
+ mDataModified(true)
|
|
|
+{
|
|
|
+ *this = other;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Overwrites this color map data instance with the data stored in \a other. The alpha map state is
|
|
|
+ transferred, too.
|
|
|
+*/
|
|
|
+QCPColorMapData &QCPColorMapData::operator=(const QCPColorMapData &other)
|
|
|
+{
|
|
|
+ if (&other != this)
|
|
|
+ {
|
|
|
+ const int keySize = other.keySize();
|
|
|
+ const int valueSize = other.valueSize();
|
|
|
+ if (!other.mAlpha && mAlpha)
|
|
|
+ clearAlpha();
|
|
|
+ setSize(keySize, valueSize);
|
|
|
+ if (other.mAlpha && !mAlpha)
|
|
|
+ createAlpha(false);
|
|
|
+ setRange(other.keyRange(), other.valueRange());
|
|
|
+ if (!isEmpty())
|
|
|
+ {
|
|
|
+ memcpy(mData, other.mData, sizeof(mData[0])*keySize*valueSize);
|
|
|
+ if (mAlpha)
|
|
|
+ memcpy(mAlpha, other.mAlpha, sizeof(mAlpha[0])*keySize*valueSize);
|
|
|
+ }
|
|
|
+ mDataBounds = other.mDataBounds;
|
|
|
+ mDataModified = true;
|
|
|
+ }
|
|
|
+ return *this;
|
|
|
+}
|
|
|
+
|
|
|
+/* undocumented getter */
|
|
|
+double QCPColorMapData::data(double key, double value)
|
|
|
+{
|
|
|
+ int keyCell = (key-mKeyRange.lower)/(mKeyRange.upper-mKeyRange.lower)*(mKeySize-1)+0.5;
|
|
|
+ int valueCell = (value-mValueRange.lower)/(mValueRange.upper-mValueRange.lower)*(mValueSize-1)+0.5;
|
|
|
+ if (keyCell >= 0 && keyCell < mKeySize && valueCell >= 0 && valueCell < mValueSize)
|
|
|
+ return mData[valueCell*mKeySize + keyCell];
|
|
|
+ else
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+/* undocumented getter */
|
|
|
+double QCPColorMapData::cell(int keyIndex, int valueIndex)
|
|
|
+{
|
|
|
+ if (keyIndex >= 0 && keyIndex < mKeySize && valueIndex >= 0 && valueIndex < mValueSize)
|
|
|
+ return mData[valueIndex*mKeySize + keyIndex];
|
|
|
+ else
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Returns the alpha map value of the cell with the indices \a keyIndex and \a valueIndex.
|
|
|
+
|
|
|
+ If this color map data doesn't have an alpha map (because \ref setAlpha was never called after
|
|
|
+ creation or after a call to \ref clearAlpha), returns 255, which corresponds to full opacity.
|
|
|
+
|
|
|
+ \see setAlpha
|
|
|
+*/
|
|
|
+unsigned char QCPColorMapData::alpha(int keyIndex, int valueIndex)
|
|
|
+{
|
|
|
+ if (mAlpha && keyIndex >= 0 && keyIndex < mKeySize && valueIndex >= 0 && valueIndex < mValueSize)
|
|
|
+ return mAlpha[valueIndex*mKeySize + keyIndex];
|
|
|
+ else
|
|
|
+ return 255;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Resizes the data array to have \a keySize cells in the key dimension and \a valueSize cells in
|
|
|
+ the value dimension.
|
|
|
+
|
|
|
+ The current data is discarded and the map cells are set to 0, unless the map had already the
|
|
|
+ requested size.
|
|
|
+
|
|
|
+ Setting at least one of \a keySize or \a valueSize to zero frees the internal data array and \ref
|
|
|
+ isEmpty returns true.
|
|
|
+
|
|
|
+ \see setRange, setKeySize, setValueSize
|
|
|
+*/
|
|
|
+void QCPColorMapData::setSize(int keySize, int valueSize)
|
|
|
+{
|
|
|
+ if (keySize != mKeySize || valueSize != mValueSize)
|
|
|
+ {
|
|
|
+ mKeySize = keySize;
|
|
|
+ mValueSize = valueSize;
|
|
|
+ if (mData)
|
|
|
+ delete[] mData;
|
|
|
+ mIsEmpty = mKeySize == 0 || mValueSize == 0;
|
|
|
+ if (!mIsEmpty)
|
|
|
+ {
|
|
|
+#ifdef __EXCEPTIONS
|
|
|
+ try { // 2D arrays get memory intensive fast. So if the allocation fails, at least output debug message
|
|
|
+#endif
|
|
|
+ mData = new double[mKeySize*mValueSize];
|
|
|
+#ifdef __EXCEPTIONS
|
|
|
+ } catch (...) { mData = 0; }
|
|
|
+#endif
|
|
|
+ if (mData)
|
|
|
+ fill(0);
|
|
|
+ else
|
|
|
+ qDebug() << Q_FUNC_INFO << "out of memory for data dimensions "<< mKeySize << "*" << mValueSize;
|
|
|
+ } else
|
|
|
+ mData = 0;
|
|
|
+
|
|
|
+ if (mAlpha) // if we had an alpha map, recreate it with new size
|
|
|
+ createAlpha();
|
|
|
+
|
|
|
+ mDataModified = true;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Resizes the data array to have \a keySize cells in the key dimension.
|
|
|
+
|
|
|
+ The current data is discarded and the map cells are set to 0, unless the map had already the
|
|
|
+ requested size.
|
|
|
+
|
|
|
+ Setting \a keySize to zero frees the internal data array and \ref isEmpty returns true.
|
|
|
+
|
|
|
+ \see setKeyRange, setSize, setValueSize
|
|
|
+*/
|
|
|
+void QCPColorMapData::setKeySize(int keySize)
|
|
|
+{
|
|
|
+ setSize(keySize, mValueSize);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Resizes the data array to have \a valueSize cells in the value dimension.
|
|
|
+
|
|
|
+ The current data is discarded and the map cells are set to 0, unless the map had already the
|
|
|
+ requested size.
|
|
|
+
|
|
|
+ Setting \a valueSize to zero frees the internal data array and \ref isEmpty returns true.
|
|
|
+
|
|
|
+ \see setValueRange, setSize, setKeySize
|
|
|
+*/
|
|
|
+void QCPColorMapData::setValueSize(int valueSize)
|
|
|
+{
|
|
|
+ setSize(mKeySize, valueSize);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the coordinate ranges the data shall be distributed over. This defines the rectangular area
|
|
|
+ covered by the color map in plot coordinates.
|
|
|
+
|
|
|
+ The outer cells will be centered on the range boundaries given to this function. For example, if
|
|
|
+ the key size (\ref setKeySize) is 3 and \a keyRange is set to <tt>QCPRange(2, 3)</tt> there will
|
|
|
+ be cells centered on the key coordinates 2, 2.5 and 3.
|
|
|
+
|
|
|
+ \see setSize
|
|
|
+*/
|
|
|
+void QCPColorMapData::setRange(const QCPRange &keyRange, const QCPRange &valueRange)
|
|
|
+{
|
|
|
+ setKeyRange(keyRange);
|
|
|
+ setValueRange(valueRange);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the coordinate range the data shall be distributed over in the key dimension. Together with
|
|
|
+ the value range, This defines the rectangular area covered by the color map in plot coordinates.
|
|
|
+
|
|
|
+ The outer cells will be centered on the range boundaries given to this function. For example, if
|
|
|
+ the key size (\ref setKeySize) is 3 and \a keyRange is set to <tt>QCPRange(2, 3)</tt> there will
|
|
|
+ be cells centered on the key coordinates 2, 2.5 and 3.
|
|
|
+
|
|
|
+ \see setRange, setValueRange, setSize
|
|
|
+*/
|
|
|
+void QCPColorMapData::setKeyRange(const QCPRange &keyRange)
|
|
|
+{
|
|
|
+ mKeyRange = keyRange;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the coordinate range the data shall be distributed over in the value dimension. Together with
|
|
|
+ the key range, This defines the rectangular area covered by the color map in plot coordinates.
|
|
|
+
|
|
|
+ The outer cells will be centered on the range boundaries given to this function. For example, if
|
|
|
+ the value size (\ref setValueSize) is 3 and \a valueRange is set to <tt>QCPRange(2, 3)</tt> there
|
|
|
+ will be cells centered on the value coordinates 2, 2.5 and 3.
|
|
|
+
|
|
|
+ \see setRange, setKeyRange, setSize
|
|
|
+*/
|
|
|
+void QCPColorMapData::setValueRange(const QCPRange &valueRange)
|
|
|
+{
|
|
|
+ mValueRange = valueRange;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the data of the cell, which lies at the plot coordinates given by \a key and \a value, to \a
|
|
|
+ z.
|
|
|
+
|
|
|
+ \note The QCPColorMap always displays the data at equal key/value intervals, even if the key or
|
|
|
+ value axis is set to a logarithmic scaling. If you want to use QCPColorMap with logarithmic axes,
|
|
|
+ you shouldn't use the \ref QCPColorMapData::setData method as it uses a linear transformation to
|
|
|
+ determine the cell index. Rather directly access the cell index with \ref
|
|
|
+ QCPColorMapData::setCell.
|
|
|
+
|
|
|
+ \see setCell, setRange
|
|
|
+*/
|
|
|
+void QCPColorMapData::setData(double key, double value, double z)
|
|
|
+{
|
|
|
+ int keyCell = (key-mKeyRange.lower)/(mKeyRange.upper-mKeyRange.lower)*(mKeySize-1)+0.5;
|
|
|
+ int valueCell = (value-mValueRange.lower)/(mValueRange.upper-mValueRange.lower)*(mValueSize-1)+0.5;
|
|
|
+ if (keyCell >= 0 && keyCell < mKeySize && valueCell >= 0 && valueCell < mValueSize)
|
|
|
+ {
|
|
|
+ mData[valueCell*mKeySize + keyCell] = z;
|
|
|
+ if (z < mDataBounds.lower)
|
|
|
+ mDataBounds.lower = z;
|
|
|
+ if (z > mDataBounds.upper)
|
|
|
+ mDataBounds.upper = z;
|
|
|
+ mDataModified = true;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the data of the cell with indices \a keyIndex and \a valueIndex to \a z. The indices
|
|
|
+ enumerate the cells starting from zero, up to the map's size-1 in the respective dimension (see
|
|
|
+ \ref setSize).
|
|
|
+
|
|
|
+ In the standard plot configuration (horizontal key axis and vertical value axis, both not
|
|
|
+ range-reversed), the cell with indices (0, 0) is in the bottom left corner and the cell with
|
|
|
+ indices (keySize-1, valueSize-1) is in the top right corner of the color map.
|
|
|
+
|
|
|
+ \see setData, setSize
|
|
|
+*/
|
|
|
+void QCPColorMapData::setCell(int keyIndex, int valueIndex, double z)
|
|
|
+{
|
|
|
+ if (keyIndex >= 0 && keyIndex < mKeySize && valueIndex >= 0 && valueIndex < mValueSize)
|
|
|
+ {
|
|
|
+ mData[valueIndex*mKeySize + keyIndex] = z;
|
|
|
+ if (z < mDataBounds.lower)
|
|
|
+ mDataBounds.lower = z;
|
|
|
+ if (z > mDataBounds.upper)
|
|
|
+ mDataBounds.upper = z;
|
|
|
+ mDataModified = true;
|
|
|
+ } else
|
|
|
+ qDebug() << Q_FUNC_INFO << "index out of bounds:" << keyIndex << valueIndex;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the alpha of the color map cell given by \a keyIndex and \a valueIndex to \a alpha. A value
|
|
|
+ of 0 for \a alpha results in a fully transparent cell, and a value of 255 results in a fully
|
|
|
+ opaque cell.
|
|
|
+
|
|
|
+ If an alpha map doesn't exist yet for this color map data, it will be created here. If you wish
|
|
|
+ to restore full opacity and free any allocated memory of the alpha map, call \ref clearAlpha.
|
|
|
+
|
|
|
+ Note that the cell-wise alpha which can be configured here is independent of any alpha configured
|
|
|
+ in the color map's gradient (\ref QCPColorGradient). If a cell is affected both by the cell-wise
|
|
|
+ and gradient alpha, the alpha values will be blended accordingly during rendering of the color
|
|
|
+ map.
|
|
|
+
|
|
|
+ \see fillAlpha, clearAlpha
|
|
|
+*/
|
|
|
+void QCPColorMapData::setAlpha(int keyIndex, int valueIndex, unsigned char alpha)
|
|
|
+{
|
|
|
+ if (keyIndex >= 0 && keyIndex < mKeySize && valueIndex >= 0 && valueIndex < mValueSize)
|
|
|
+ {
|
|
|
+ if (mAlpha || createAlpha())
|
|
|
+ {
|
|
|
+ mAlpha[valueIndex*mKeySize + keyIndex] = alpha;
|
|
|
+ mDataModified = true;
|
|
|
+ }
|
|
|
+ } else
|
|
|
+ qDebug() << Q_FUNC_INFO << "index out of bounds:" << keyIndex << valueIndex;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Goes through the data and updates the buffered minimum and maximum data values.
|
|
|
+
|
|
|
+ Calling this method is only advised if you are about to call \ref QCPColorMap::rescaleDataRange
|
|
|
+ and can not guarantee that the cells holding the maximum or minimum data haven't been overwritten
|
|
|
+ with a smaller or larger value respectively, since the buffered maximum/minimum values have been
|
|
|
+ updated the last time. Why this is the case is explained in the class description (\ref
|
|
|
+ QCPColorMapData).
|
|
|
+
|
|
|
+ Note that the method \ref QCPColorMap::rescaleDataRange provides a parameter \a
|
|
|
+ recalculateDataBounds for convenience. Setting this to true will call this method for you, before
|
|
|
+ doing the rescale.
|
|
|
+*/
|
|
|
+void QCPColorMapData::recalculateDataBounds()
|
|
|
+{
|
|
|
+ if (mKeySize > 0 && mValueSize > 0)
|
|
|
+ {
|
|
|
+ double minHeight = mData[0];
|
|
|
+ double maxHeight = mData[0];
|
|
|
+ const int dataCount = mValueSize*mKeySize;
|
|
|
+ for (int i=0; i<dataCount; ++i)
|
|
|
+ {
|
|
|
+ if (mData[i] > maxHeight)
|
|
|
+ maxHeight = mData[i];
|
|
|
+ if (mData[i] < minHeight)
|
|
|
+ minHeight = mData[i];
|
|
|
+ }
|
|
|
+ mDataBounds.lower = minHeight;
|
|
|
+ mDataBounds.upper = maxHeight;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Frees the internal data memory.
|
|
|
+
|
|
|
+ This is equivalent to calling \ref setSize "setSize(0, 0)".
|
|
|
+*/
|
|
|
+void QCPColorMapData::clear()
|
|
|
+{
|
|
|
+ setSize(0, 0);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Frees the internal alpha map. The color map will have full opacity again.
|
|
|
+*/
|
|
|
+void QCPColorMapData::clearAlpha()
|
|
|
+{
|
|
|
+ if (mAlpha)
|
|
|
+ {
|
|
|
+ delete[] mAlpha;
|
|
|
+ mAlpha = 0;
|
|
|
+ mDataModified = true;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets all cells to the value \a z.
|
|
|
+*/
|
|
|
+void QCPColorMapData::fill(double z)
|
|
|
+{
|
|
|
+ const int dataCount = mValueSize*mKeySize;
|
|
|
+ for (int i=0; i<dataCount; ++i)
|
|
|
+ mData[i] = z;
|
|
|
+ mDataBounds = QCPRange(z, z);
|
|
|
+ mDataModified = true;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the opacity of all color map cells to \a alpha. A value of 0 for \a alpha results in a fully
|
|
|
+ transparent color map, and a value of 255 results in a fully opaque color map.
|
|
|
+
|
|
|
+ If you wish to restore opacity to 100% and free any used memory for the alpha map, rather use
|
|
|
+ \ref clearAlpha.
|
|
|
+
|
|
|
+ \see setAlpha
|
|
|
+*/
|
|
|
+void QCPColorMapData::fillAlpha(unsigned char alpha)
|
|
|
+{
|
|
|
+ if (mAlpha || createAlpha(false))
|
|
|
+ {
|
|
|
+ const int dataCount = mValueSize*mKeySize;
|
|
|
+ for (int i=0; i<dataCount; ++i)
|
|
|
+ mAlpha[i] = alpha;
|
|
|
+ mDataModified = true;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Transforms plot coordinates given by \a key and \a value to cell indices of this QCPColorMapData
|
|
|
+ instance. The resulting cell indices are returned via the output parameters \a keyIndex and \a
|
|
|
+ valueIndex.
|
|
|
+
|
|
|
+ The retrieved key/value cell indices can then be used for example with \ref setCell.
|
|
|
+
|
|
|
+ If you are only interested in a key or value index, you may pass 0 as \a valueIndex or \a
|
|
|
+ keyIndex.
|
|
|
+
|
|
|
+ \note The QCPColorMap always displays the data at equal key/value intervals, even if the key or
|
|
|
+ value axis is set to a logarithmic scaling. If you want to use QCPColorMap with logarithmic axes,
|
|
|
+ you shouldn't use the \ref QCPColorMapData::coordToCell method as it uses a linear transformation to
|
|
|
+ determine the cell index.
|
|
|
+
|
|
|
+ \see cellToCoord, QCPAxis::coordToPixel
|
|
|
+*/
|
|
|
+void QCPColorMapData::coordToCell(double key, double value, int *keyIndex, int *valueIndex) const
|
|
|
+{
|
|
|
+ if (keyIndex)
|
|
|
+ *keyIndex = (key-mKeyRange.lower)/(mKeyRange.upper-mKeyRange.lower)*(mKeySize-1)+0.5;
|
|
|
+ if (valueIndex)
|
|
|
+ *valueIndex = (value-mValueRange.lower)/(mValueRange.upper-mValueRange.lower)*(mValueSize-1)+0.5;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Transforms cell indices given by \a keyIndex and \a valueIndex to cell indices of this QCPColorMapData
|
|
|
+ instance. The resulting coordinates are returned via the output parameters \a key and \a
|
|
|
+ value.
|
|
|
+
|
|
|
+ If you are only interested in a key or value coordinate, you may pass 0 as \a key or \a
|
|
|
+ value.
|
|
|
+
|
|
|
+ \note The QCPColorMap always displays the data at equal key/value intervals, even if the key or
|
|
|
+ value axis is set to a logarithmic scaling. If you want to use QCPColorMap with logarithmic axes,
|
|
|
+ you shouldn't use the \ref QCPColorMapData::cellToCoord method as it uses a linear transformation to
|
|
|
+ determine the cell index.
|
|
|
+
|
|
|
+ \see coordToCell, QCPAxis::pixelToCoord
|
|
|
+*/
|
|
|
+void QCPColorMapData::cellToCoord(int keyIndex, int valueIndex, double *key, double *value) const
|
|
|
+{
|
|
|
+ if (key)
|
|
|
+ *key = keyIndex/(double)(mKeySize-1)*(mKeyRange.upper-mKeyRange.lower)+mKeyRange.lower;
|
|
|
+ if (value)
|
|
|
+ *value = valueIndex/(double)(mValueSize-1)*(mValueRange.upper-mValueRange.lower)+mValueRange.lower;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Allocates the internal alpha map with the current data map key/value size and, if \a
|
|
|
+ initializeOpaque is true, initializes all values to 255. If \a initializeOpaque is false, the
|
|
|
+ values are not initialized at all. In this case, the alpha map should be initialized manually,
|
|
|
+ e.g. with \ref fillAlpha.
|
|
|
+
|
|
|
+ If an alpha map exists already, it is deleted first. If this color map is empty (has either key
|
|
|
+ or value size zero, see \ref isEmpty), the alpha map is cleared.
|
|
|
+
|
|
|
+ The return value indicates the existence of the alpha map after the call. So this method returns
|
|
|
+ true if the data map isn't empty and an alpha map was successfully allocated.
|
|
|
+*/
|
|
|
+bool QCPColorMapData::createAlpha(bool initializeOpaque)
|
|
|
+{
|
|
|
+ clearAlpha();
|
|
|
+ if (isEmpty())
|
|
|
+ return false;
|
|
|
+
|
|
|
+#ifdef __EXCEPTIONS
|
|
|
+ try { // 2D arrays get memory intensive fast. So if the allocation fails, at least output debug message
|
|
|
+#endif
|
|
|
+ mAlpha = new unsigned char[mKeySize*mValueSize];
|
|
|
+#ifdef __EXCEPTIONS
|
|
|
+ } catch (...) { mAlpha = 0; }
|
|
|
+#endif
|
|
|
+ if (mAlpha)
|
|
|
+ {
|
|
|
+ if (initializeOpaque)
|
|
|
+ fillAlpha(255);
|
|
|
+ return true;
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "out of memory for data dimensions "<< mKeySize << "*" << mValueSize;
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPColorMap
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+/*! \class QCPColorMap
|
|
|
+ \brief A plottable representing a two-dimensional color map in a plot.
|
|
|
+
|
|
|
+ \image html QCPColorMap.png
|
|
|
+
|
|
|
+ The data is stored in the class \ref QCPColorMapData, which can be accessed via the data()
|
|
|
+ method.
|
|
|
+
|
|
|
+ A color map has three dimensions to represent a data point: The \a key dimension, the \a value
|
|
|
+ dimension and the \a data dimension. As with other plottables such as graphs, \a key and \a value
|
|
|
+ correspond to two orthogonal axes on the QCustomPlot surface that you specify in the QCPColorMap
|
|
|
+ constructor. The \a data dimension however is encoded as the color of the point at (\a key, \a
|
|
|
+ value).
|
|
|
+
|
|
|
+ Set the number of points (or \a cells) in the key/value dimension via \ref
|
|
|
+ QCPColorMapData::setSize. The plot coordinate range over which these points will be displayed is
|
|
|
+ specified via \ref QCPColorMapData::setRange. The first cell will be centered on the lower range
|
|
|
+ boundary and the last cell will be centered on the upper range boundary. The data can be set by
|
|
|
+ either accessing the cells directly with QCPColorMapData::setCell or by addressing the cells via
|
|
|
+ their plot coordinates with \ref QCPColorMapData::setData. If possible, you should prefer
|
|
|
+ setCell, since it doesn't need to do any coordinate transformation and thus performs a bit
|
|
|
+ better.
|
|
|
+
|
|
|
+ The cell with index (0, 0) is at the bottom left, if the color map uses normal (i.e. not reversed)
|
|
|
+ key and value axes.
|
|
|
+
|
|
|
+ To show the user which colors correspond to which \a data values, a \ref QCPColorScale is
|
|
|
+ typically placed to the right of the axis rect. See the documentation there for details on how to
|
|
|
+ add and use a color scale.
|
|
|
+
|
|
|
+ \section qcpcolormap-appearance Changing the appearance
|
|
|
+
|
|
|
+ The central part of the appearance is the color gradient, which can be specified via \ref
|
|
|
+ setGradient. See the documentation of \ref QCPColorGradient for details on configuring a color
|
|
|
+ gradient.
|
|
|
+
|
|
|
+ The \a data range that is mapped to the colors of the gradient can be specified with \ref
|
|
|
+ setDataRange. To make the data range encompass the whole data set minimum to maximum, call \ref
|
|
|
+ rescaleDataRange.
|
|
|
+
|
|
|
+ \section qcpcolormap-transparency Transparency
|
|
|
+
|
|
|
+ Transparency in color maps can be achieved by two mechanisms. On one hand, you can specify alpha
|
|
|
+ values for color stops of the \ref QCPColorGradient, via the regular QColor interface. This will
|
|
|
+ cause the color map data which gets mapped to colors around those color stops to appear with the
|
|
|
+ accordingly interpolated transparency.
|
|
|
+
|
|
|
+ On the other hand you can also directly apply an alpha value to each cell independent of its
|
|
|
+ data, by using the alpha map feature of \ref QCPColorMapData. The relevant methods are \ref
|
|
|
+ QCPColorMapData::setAlpha, QCPColorMapData::fillAlpha and \ref QCPColorMapData::clearAlpha().
|
|
|
+
|
|
|
+ The two transparencies will be joined together in the plot and otherwise not interfere with each
|
|
|
+ other. They are mixed in a multiplicative matter, so an alpha of e.g. 50% (128/255) in both modes
|
|
|
+ simultaneously, will result in a total transparency of 25% (64/255).
|
|
|
+
|
|
|
+ \section qcpcolormap-usage Usage
|
|
|
+
|
|
|
+ Like all data representing objects in QCustomPlot, the QCPColorMap is a plottable
|
|
|
+ (QCPAbstractPlottable). So the plottable-interface of QCustomPlot applies
|
|
|
+ (QCustomPlot::plottable, QCustomPlot::removePlottable, etc.)
|
|
|
+
|
|
|
+ Usually, you first create an instance:
|
|
|
+ \snippet documentation/doc-code-snippets/mainwindow.cpp qcpcolormap-creation-1
|
|
|
+ which registers it with the QCustomPlot instance of the passed axes. Note that this QCustomPlot instance takes
|
|
|
+ ownership of the plottable, so do not delete it manually but use QCustomPlot::removePlottable() instead.
|
|
|
+ The newly created plottable can be modified, e.g.:
|
|
|
+ \snippet documentation/doc-code-snippets/mainwindow.cpp qcpcolormap-creation-2
|
|
|
+
|
|
|
+ \note The QCPColorMap always displays the data at equal key/value intervals, even if the key or
|
|
|
+ value axis is set to a logarithmic scaling. If you want to use QCPColorMap with logarithmic axes,
|
|
|
+ you shouldn't use the \ref QCPColorMapData::setData method as it uses a linear transformation to
|
|
|
+ determine the cell index. Rather directly access the cell index with \ref
|
|
|
+ QCPColorMapData::setCell.
|
|
|
+*/
|
|
|
+
|
|
|
+/* start documentation of inline functions */
|
|
|
+
|
|
|
+/*! \fn QCPColorMapData *QCPColorMap::data() const
|
|
|
+
|
|
|
+ Returns a pointer to the internal data storage of type \ref QCPColorMapData. Access this to
|
|
|
+ modify data points (cells) and the color map key/value range.
|
|
|
+
|
|
|
+ \see setData
|
|
|
+*/
|
|
|
+
|
|
|
+/* end documentation of inline functions */
|
|
|
+
|
|
|
+/* start documentation of signals */
|
|
|
+
|
|
|
+/*! \fn void QCPColorMap::dataRangeChanged(const QCPRange &newRange);
|
|
|
+
|
|
|
+ This signal is emitted when the data range changes.
|
|
|
+
|
|
|
+ \see setDataRange
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn void QCPColorMap::dataScaleTypeChanged(QCPAxis::ScaleType scaleType);
|
|
|
+
|
|
|
+ This signal is emitted when the data scale type changes.
|
|
|
+
|
|
|
+ \see setDataScaleType
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn void QCPColorMap::gradientChanged(const QCPColorGradient &newGradient);
|
|
|
+
|
|
|
+ This signal is emitted when the gradient changes.
|
|
|
+
|
|
|
+ \see setGradient
|
|
|
+*/
|
|
|
+
|
|
|
+/* end documentation of signals */
|
|
|
+
|
|
|
+/*!
|
|
|
+ Constructs a color map with the specified \a keyAxis and \a valueAxis.
|
|
|
+
|
|
|
+ The created QCPColorMap is automatically registered with the QCustomPlot instance inferred from
|
|
|
+ \a keyAxis. This QCustomPlot instance takes ownership of the QCPColorMap, so do not delete it
|
|
|
+ manually but use QCustomPlot::removePlottable() instead.
|
|
|
+*/
|
|
|
+QCPColorMap::QCPColorMap(QCPAxis *keyAxis, QCPAxis *valueAxis) :
|
|
|
+ QCPAbstractPlottable(keyAxis, valueAxis),
|
|
|
+ mDataScaleType(QCPAxis::stLinear),
|
|
|
+ mMapData(new QCPColorMapData(10, 10, QCPRange(0, 5), QCPRange(0, 5))),
|
|
|
+ mGradient(QCPColorGradient::gpCold),
|
|
|
+ mInterpolate(true),
|
|
|
+ mTightBoundary(false),
|
|
|
+ mMapImageInvalidated(true)
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+QCPColorMap::~QCPColorMap()
|
|
|
+{
|
|
|
+ delete mMapData;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Replaces the current \ref data with the provided \a data.
|
|
|
+
|
|
|
+ If \a copy is set to true, the \a data object will only be copied. if false, the color map
|
|
|
+ takes ownership of the passed data and replaces the internal data pointer with it. This is
|
|
|
+ significantly faster than copying for large datasets.
|
|
|
+*/
|
|
|
+void QCPColorMap::setData(QCPColorMapData *data, bool copy)
|
|
|
+{
|
|
|
+ if (mMapData == data)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "The data pointer is already in (and owned by) this plottable" << reinterpret_cast<quintptr>(data);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ if (copy)
|
|
|
+ {
|
|
|
+ *mMapData = *data;
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ delete mMapData;
|
|
|
+ mMapData = data;
|
|
|
+ }
|
|
|
+ mMapImageInvalidated = true;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the data range of this color map to \a dataRange. The data range defines which data values
|
|
|
+ are mapped to the color gradient.
|
|
|
+
|
|
|
+ To make the data range span the full range of the data set, use \ref rescaleDataRange.
|
|
|
+
|
|
|
+ \see QCPColorScale::setDataRange
|
|
|
+*/
|
|
|
+void QCPColorMap::setDataRange(const QCPRange &dataRange)
|
|
|
+{
|
|
|
+ if (!QCPRange::validRange(dataRange)) return;
|
|
|
+ if (mDataRange.lower != dataRange.lower || mDataRange.upper != dataRange.upper)
|
|
|
+ {
|
|
|
+ if (mDataScaleType == QCPAxis::stLogarithmic)
|
|
|
+ mDataRange = dataRange.sanitizedForLogScale();
|
|
|
+ else
|
|
|
+ mDataRange = dataRange.sanitizedForLinScale();
|
|
|
+ mMapImageInvalidated = true;
|
|
|
+ emit dataRangeChanged(mDataRange);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets whether the data is correlated with the color gradient linearly or logarithmically.
|
|
|
+
|
|
|
+ \see QCPColorScale::setDataScaleType
|
|
|
+*/
|
|
|
+void QCPColorMap::setDataScaleType(QCPAxis::ScaleType scaleType)
|
|
|
+{
|
|
|
+ if (mDataScaleType != scaleType)
|
|
|
+ {
|
|
|
+ mDataScaleType = scaleType;
|
|
|
+ mMapImageInvalidated = true;
|
|
|
+ emit dataScaleTypeChanged(mDataScaleType);
|
|
|
+ if (mDataScaleType == QCPAxis::stLogarithmic)
|
|
|
+ setDataRange(mDataRange.sanitizedForLogScale());
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the color gradient that is used to represent the data. For more details on how to create an
|
|
|
+ own gradient or use one of the preset gradients, see \ref QCPColorGradient.
|
|
|
+
|
|
|
+ The colors defined by the gradient will be used to represent data values in the currently set
|
|
|
+ data range, see \ref setDataRange. Data points that are outside this data range will either be
|
|
|
+ colored uniformly with the respective gradient boundary color, or the gradient will repeat,
|
|
|
+ depending on \ref QCPColorGradient::setPeriodic.
|
|
|
+
|
|
|
+ \see QCPColorScale::setGradient
|
|
|
+*/
|
|
|
+void QCPColorMap::setGradient(const QCPColorGradient &gradient)
|
|
|
+{
|
|
|
+ if (mGradient != gradient)
|
|
|
+ {
|
|
|
+ mGradient = gradient;
|
|
|
+ mMapImageInvalidated = true;
|
|
|
+ emit gradientChanged(mGradient);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets whether the color map image shall use bicubic interpolation when displaying the color map
|
|
|
+ shrinked or expanded, and not at a 1:1 pixel-to-data scale.
|
|
|
+
|
|
|
+ \image html QCPColorMap-interpolate.png "A 10*10 color map, with interpolation and without interpolation enabled"
|
|
|
+*/
|
|
|
+void QCPColorMap::setInterpolate(bool enabled)
|
|
|
+{
|
|
|
+ mInterpolate = enabled;
|
|
|
+ mMapImageInvalidated = true; // because oversampling factors might need to change
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets whether the outer most data rows and columns are clipped to the specified key and value
|
|
|
+ range (see \ref QCPColorMapData::setKeyRange, \ref QCPColorMapData::setValueRange).
|
|
|
+
|
|
|
+ if \a enabled is set to false, the data points at the border of the color map are drawn with the
|
|
|
+ same width and height as all other data points. Since the data points are represented by
|
|
|
+ rectangles of one color centered on the data coordinate, this means that the shown color map
|
|
|
+ extends by half a data point over the specified key/value range in each direction.
|
|
|
+
|
|
|
+ \image html QCPColorMap-tightboundary.png "A color map, with tight boundary enabled and disabled"
|
|
|
+*/
|
|
|
+void QCPColorMap::setTightBoundary(bool enabled)
|
|
|
+{
|
|
|
+ mTightBoundary = enabled;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Associates the color scale \a colorScale with this color map.
|
|
|
+
|
|
|
+ This means that both the color scale and the color map synchronize their gradient, data range and
|
|
|
+ data scale type (\ref setGradient, \ref setDataRange, \ref setDataScaleType). Multiple color maps
|
|
|
+ can be associated with one single color scale. This causes the color maps to also synchronize
|
|
|
+ those properties, via the mutual color scale.
|
|
|
+
|
|
|
+ This function causes the color map to adopt the current color gradient, data range and data scale
|
|
|
+ type of \a colorScale. After this call, you may change these properties at either the color map
|
|
|
+ or the color scale, and the setting will be applied to both.
|
|
|
+
|
|
|
+ Pass 0 as \a colorScale to disconnect the color scale from this color map again.
|
|
|
+*/
|
|
|
+void QCPColorMap::setColorScale(QCPColorScale *colorScale)
|
|
|
+{
|
|
|
+ if (mColorScale) // unconnect signals from old color scale
|
|
|
+ {
|
|
|
+ disconnect(this, SIGNAL(dataRangeChanged(QCPRange)), mColorScale.data(), SLOT(setDataRange(QCPRange)));
|
|
|
+ disconnect(this, SIGNAL(dataScaleTypeChanged(QCPAxis::ScaleType)), mColorScale.data(), SLOT(setDataScaleType(QCPAxis::ScaleType)));
|
|
|
+ disconnect(this, SIGNAL(gradientChanged(QCPColorGradient)), mColorScale.data(), SLOT(setGradient(QCPColorGradient)));
|
|
|
+ disconnect(mColorScale.data(), SIGNAL(dataRangeChanged(QCPRange)), this, SLOT(setDataRange(QCPRange)));
|
|
|
+ disconnect(mColorScale.data(), SIGNAL(gradientChanged(QCPColorGradient)), this, SLOT(setGradient(QCPColorGradient)));
|
|
|
+ disconnect(mColorScale.data(), SIGNAL(dataScaleTypeChanged(QCPAxis::ScaleType)), this, SLOT(setDataScaleType(QCPAxis::ScaleType)));
|
|
|
+ }
|
|
|
+ mColorScale = colorScale;
|
|
|
+ if (mColorScale) // connect signals to new color scale
|
|
|
+ {
|
|
|
+ setGradient(mColorScale.data()->gradient());
|
|
|
+ setDataRange(mColorScale.data()->dataRange());
|
|
|
+ setDataScaleType(mColorScale.data()->dataScaleType());
|
|
|
+ connect(this, SIGNAL(dataRangeChanged(QCPRange)), mColorScale.data(), SLOT(setDataRange(QCPRange)));
|
|
|
+ connect(this, SIGNAL(dataScaleTypeChanged(QCPAxis::ScaleType)), mColorScale.data(), SLOT(setDataScaleType(QCPAxis::ScaleType)));
|
|
|
+ connect(this, SIGNAL(gradientChanged(QCPColorGradient)), mColorScale.data(), SLOT(setGradient(QCPColorGradient)));
|
|
|
+ connect(mColorScale.data(), SIGNAL(dataRangeChanged(QCPRange)), this, SLOT(setDataRange(QCPRange)));
|
|
|
+ connect(mColorScale.data(), SIGNAL(gradientChanged(QCPColorGradient)), this, SLOT(setGradient(QCPColorGradient)));
|
|
|
+ connect(mColorScale.data(), SIGNAL(dataScaleTypeChanged(QCPAxis::ScaleType)), this, SLOT(setDataScaleType(QCPAxis::ScaleType)));
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the data range (\ref setDataRange) to span the minimum and maximum values that occur in the
|
|
|
+ current data set. This corresponds to the \ref rescaleKeyAxis or \ref rescaleValueAxis methods,
|
|
|
+ only for the third data dimension of the color map.
|
|
|
+
|
|
|
+ The minimum and maximum values of the data set are buffered in the internal QCPColorMapData
|
|
|
+ instance (\ref data). As data is updated via its \ref QCPColorMapData::setCell or \ref
|
|
|
+ QCPColorMapData::setData, the buffered minimum and maximum values are updated, too. For
|
|
|
+ performance reasons, however, they are only updated in an expanding fashion. So the buffered
|
|
|
+ maximum can only increase and the buffered minimum can only decrease. In consequence, changes to
|
|
|
+ the data that actually lower the maximum of the data set (by overwriting the cell holding the
|
|
|
+ current maximum with a smaller value), aren't recognized and the buffered maximum overestimates
|
|
|
+ the true maximum of the data set. The same happens for the buffered minimum. To recalculate the
|
|
|
+ true minimum and maximum by explicitly looking at each cell, the method
|
|
|
+ QCPColorMapData::recalculateDataBounds can be used. For convenience, setting the parameter \a
|
|
|
+ recalculateDataBounds calls this method before setting the data range to the buffered minimum and
|
|
|
+ maximum.
|
|
|
+
|
|
|
+ \see setDataRange
|
|
|
+*/
|
|
|
+void QCPColorMap::rescaleDataRange(bool recalculateDataBounds)
|
|
|
+{
|
|
|
+ if (recalculateDataBounds)
|
|
|
+ mMapData->recalculateDataBounds();
|
|
|
+ setDataRange(mMapData->dataBounds());
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Takes the current appearance of the color map and updates the legend icon, which is used to
|
|
|
+ represent this color map in the legend (see \ref QCPLegend).
|
|
|
+
|
|
|
+ The \a transformMode specifies whether the rescaling is done by a faster, low quality image
|
|
|
+ scaling algorithm (Qt::FastTransformation) or by a slower, higher quality algorithm
|
|
|
+ (Qt::SmoothTransformation).
|
|
|
+
|
|
|
+ The current color map appearance is scaled down to \a thumbSize. Ideally, this should be equal to
|
|
|
+ the size of the legend icon (see \ref QCPLegend::setIconSize). If it isn't exactly the configured
|
|
|
+ legend icon size, the thumb will be rescaled during drawing of the legend item.
|
|
|
+
|
|
|
+ \see setDataRange
|
|
|
+*/
|
|
|
+void QCPColorMap::updateLegendIcon(Qt::TransformationMode transformMode, const QSize &thumbSize)
|
|
|
+{
|
|
|
+ if (mMapImage.isNull() && !data()->isEmpty())
|
|
|
+ updateMapImage(); // try to update map image if it's null (happens if no draw has happened yet)
|
|
|
+
|
|
|
+ if (!mMapImage.isNull()) // might still be null, e.g. if data is empty, so check here again
|
|
|
+ {
|
|
|
+ bool mirrorX = (keyAxis()->orientation() == Qt::Horizontal ? keyAxis() : valueAxis())->rangeReversed();
|
|
|
+ bool mirrorY = (valueAxis()->orientation() == Qt::Vertical ? valueAxis() : keyAxis())->rangeReversed();
|
|
|
+ mLegendIcon = QPixmap::fromImage(mMapImage.mirrored(mirrorX, mirrorY)).scaled(thumbSize, Qt::KeepAspectRatio, transformMode);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+double QCPColorMap::selectTest(const QPointF &pos, bool onlySelectable, QVariant *details) const
|
|
|
+{
|
|
|
+ Q_UNUSED(details)
|
|
|
+ if ((onlySelectable && mSelectable == QCP::stNone) || mMapData->isEmpty())
|
|
|
+ return -1;
|
|
|
+ if (!mKeyAxis || !mValueAxis)
|
|
|
+ return -1;
|
|
|
+
|
|
|
+ if (mKeyAxis.data()->axisRect()->rect().contains(pos.toPoint()))
|
|
|
+ {
|
|
|
+ double posKey, posValue;
|
|
|
+ pixelsToCoords(pos, posKey, posValue);
|
|
|
+ if (mMapData->keyRange().contains(posKey) && mMapData->valueRange().contains(posValue))
|
|
|
+ {
|
|
|
+ if (details)
|
|
|
+ details->setValue(QCPDataSelection(QCPDataRange(0, 1))); // temporary solution, to facilitate whole-plottable selection. Replace in future version with segmented 2D selection.
|
|
|
+ return mParentPlot->selectionTolerance()*0.99;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return -1;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+QCPRange QCPColorMap::getKeyRange(bool &foundRange, QCP::SignDomain inSignDomain) const
|
|
|
+{
|
|
|
+ foundRange = true;
|
|
|
+ QCPRange result = mMapData->keyRange();
|
|
|
+ result.normalize();
|
|
|
+ if (inSignDomain == QCP::sdPositive)
|
|
|
+ {
|
|
|
+ if (result.lower <= 0 && result.upper > 0)
|
|
|
+ result.lower = result.upper*1e-3;
|
|
|
+ else if (result.lower <= 0 && result.upper <= 0)
|
|
|
+ foundRange = false;
|
|
|
+ } else if (inSignDomain == QCP::sdNegative)
|
|
|
+ {
|
|
|
+ if (result.upper >= 0 && result.lower < 0)
|
|
|
+ result.upper = result.lower*1e-3;
|
|
|
+ else if (result.upper >= 0 && result.lower >= 0)
|
|
|
+ foundRange = false;
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+QCPRange QCPColorMap::getValueRange(bool &foundRange, QCP::SignDomain inSignDomain, const QCPRange &inKeyRange) const
|
|
|
+{
|
|
|
+ if (inKeyRange != QCPRange())
|
|
|
+ {
|
|
|
+ if (mMapData->keyRange().upper < inKeyRange.lower || mMapData->keyRange().lower > inKeyRange.upper)
|
|
|
+ {
|
|
|
+ foundRange = false;
|
|
|
+ return QCPRange();
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ foundRange = true;
|
|
|
+ QCPRange result = mMapData->valueRange();
|
|
|
+ result.normalize();
|
|
|
+ if (inSignDomain == QCP::sdPositive)
|
|
|
+ {
|
|
|
+ if (result.lower <= 0 && result.upper > 0)
|
|
|
+ result.lower = result.upper*1e-3;
|
|
|
+ else if (result.lower <= 0 && result.upper <= 0)
|
|
|
+ foundRange = false;
|
|
|
+ } else if (inSignDomain == QCP::sdNegative)
|
|
|
+ {
|
|
|
+ if (result.upper >= 0 && result.lower < 0)
|
|
|
+ result.upper = result.lower*1e-3;
|
|
|
+ else if (result.upper >= 0 && result.lower >= 0)
|
|
|
+ foundRange = false;
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Updates the internal map image buffer by going through the internal \ref QCPColorMapData and
|
|
|
+ turning the data values into color pixels with \ref QCPColorGradient::colorize.
|
|
|
+
|
|
|
+ This method is called by \ref QCPColorMap::draw if either the data has been modified or the map image
|
|
|
+ has been invalidated for a different reason (e.g. a change of the data range with \ref
|
|
|
+ setDataRange).
|
|
|
+
|
|
|
+ If the map cell count is low, the image created will be oversampled in order to avoid a
|
|
|
+ QPainter::drawImage bug which makes inner pixel boundaries jitter when stretch-drawing images
|
|
|
+ without smooth transform enabled. Accordingly, oversampling isn't performed if \ref
|
|
|
+ setInterpolate is true.
|
|
|
+*/
|
|
|
+void QCPColorMap::updateMapImage()
|
|
|
+{
|
|
|
+ QCPAxis *keyAxis = mKeyAxis.data();
|
|
|
+ if (!keyAxis) return;
|
|
|
+ if (mMapData->isEmpty()) return;
|
|
|
+
|
|
|
+ const QImage::Format format = QImage::Format_ARGB32_Premultiplied;
|
|
|
+ const int keySize = mMapData->keySize();
|
|
|
+ const int valueSize = mMapData->valueSize();
|
|
|
+ int keyOversamplingFactor = mInterpolate ? 1 : (int)(1.0+100.0/(double)keySize); // make mMapImage have at least size 100, factor becomes 1 if size > 200 or interpolation is on
|
|
|
+ int valueOversamplingFactor = mInterpolate ? 1 : (int)(1.0+100.0/(double)valueSize); // make mMapImage have at least size 100, factor becomes 1 if size > 200 or interpolation is on
|
|
|
+
|
|
|
+ // resize mMapImage to correct dimensions including possible oversampling factors, according to key/value axes orientation:
|
|
|
+ if (keyAxis->orientation() == Qt::Horizontal && (mMapImage.width() != keySize*keyOversamplingFactor || mMapImage.height() != valueSize*valueOversamplingFactor))
|
|
|
+ mMapImage = QImage(QSize(keySize*keyOversamplingFactor, valueSize*valueOversamplingFactor), format);
|
|
|
+ else if (keyAxis->orientation() == Qt::Vertical && (mMapImage.width() != valueSize*valueOversamplingFactor || mMapImage.height() != keySize*keyOversamplingFactor))
|
|
|
+ mMapImage = QImage(QSize(valueSize*valueOversamplingFactor, keySize*keyOversamplingFactor), format);
|
|
|
+
|
|
|
+ if (mMapImage.isNull())
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "Couldn't create map image (possibly too large for memory)";
|
|
|
+ mMapImage = QImage(QSize(10, 10), format);
|
|
|
+ mMapImage.fill(Qt::black);
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ QImage *localMapImage = &mMapImage; // this is the image on which the colorization operates. Either the final mMapImage, or if we need oversampling, mUndersampledMapImage
|
|
|
+ if (keyOversamplingFactor > 1 || valueOversamplingFactor > 1)
|
|
|
+ {
|
|
|
+ // resize undersampled map image to actual key/value cell sizes:
|
|
|
+ if (keyAxis->orientation() == Qt::Horizontal && (mUndersampledMapImage.width() != keySize || mUndersampledMapImage.height() != valueSize))
|
|
|
+ mUndersampledMapImage = QImage(QSize(keySize, valueSize), format);
|
|
|
+ else if (keyAxis->orientation() == Qt::Vertical && (mUndersampledMapImage.width() != valueSize || mUndersampledMapImage.height() != keySize))
|
|
|
+ mUndersampledMapImage = QImage(QSize(valueSize, keySize), format);
|
|
|
+ localMapImage = &mUndersampledMapImage; // make the colorization run on the undersampled image
|
|
|
+ } else if (!mUndersampledMapImage.isNull())
|
|
|
+ mUndersampledMapImage = QImage(); // don't need oversampling mechanism anymore (map size has changed) but mUndersampledMapImage still has nonzero size, free it
|
|
|
+
|
|
|
+ const double *rawData = mMapData->mData;
|
|
|
+ const unsigned char *rawAlpha = mMapData->mAlpha;
|
|
|
+ if (keyAxis->orientation() == Qt::Horizontal)
|
|
|
+ {
|
|
|
+ const int lineCount = valueSize;
|
|
|
+ const int rowCount = keySize;
|
|
|
+ for (int line=0; line<lineCount; ++line)
|
|
|
+ {
|
|
|
+ QRgb* pixels = reinterpret_cast<QRgb*>(localMapImage->scanLine(lineCount-1-line)); // invert scanline index because QImage counts scanlines from top, but our vertical index counts from bottom (mathematical coordinate system)
|
|
|
+ if (rawAlpha)
|
|
|
+ mGradient.colorize(rawData+line*rowCount, rawAlpha+line*rowCount, mDataRange, pixels, rowCount, 1, mDataScaleType==QCPAxis::stLogarithmic);
|
|
|
+ else
|
|
|
+ mGradient.colorize(rawData+line*rowCount, mDataRange, pixels, rowCount, 1, mDataScaleType==QCPAxis::stLogarithmic);
|
|
|
+ }
|
|
|
+ } else // keyAxis->orientation() == Qt::Vertical
|
|
|
+ {
|
|
|
+ const int lineCount = keySize;
|
|
|
+ const int rowCount = valueSize;
|
|
|
+ for (int line=0; line<lineCount; ++line)
|
|
|
+ {
|
|
|
+ QRgb* pixels = reinterpret_cast<QRgb*>(localMapImage->scanLine(lineCount-1-line)); // invert scanline index because QImage counts scanlines from top, but our vertical index counts from bottom (mathematical coordinate system)
|
|
|
+ if (rawAlpha)
|
|
|
+ mGradient.colorize(rawData+line, rawAlpha+line, mDataRange, pixels, rowCount, lineCount, mDataScaleType==QCPAxis::stLogarithmic);
|
|
|
+ else
|
|
|
+ mGradient.colorize(rawData+line, mDataRange, pixels, rowCount, lineCount, mDataScaleType==QCPAxis::stLogarithmic);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (keyOversamplingFactor > 1 || valueOversamplingFactor > 1)
|
|
|
+ {
|
|
|
+ if (keyAxis->orientation() == Qt::Horizontal)
|
|
|
+ mMapImage = mUndersampledMapImage.scaled(keySize*keyOversamplingFactor, valueSize*valueOversamplingFactor, Qt::IgnoreAspectRatio, Qt::FastTransformation);
|
|
|
+ else
|
|
|
+ mMapImage = mUndersampledMapImage.scaled(valueSize*valueOversamplingFactor, keySize*keyOversamplingFactor, Qt::IgnoreAspectRatio, Qt::FastTransformation);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ mMapData->mDataModified = false;
|
|
|
+ mMapImageInvalidated = false;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPColorMap::draw(QCPPainter *painter)
|
|
|
+{
|
|
|
+ if (mMapData->isEmpty()) return;
|
|
|
+ if (!mKeyAxis || !mValueAxis) return;
|
|
|
+ applyDefaultAntialiasingHint(painter);
|
|
|
+
|
|
|
+ if (mMapData->mDataModified || mMapImageInvalidated)
|
|
|
+ updateMapImage();
|
|
|
+
|
|
|
+ // use buffer if painting vectorized (PDF):
|
|
|
+ const bool useBuffer = painter->modes().testFlag(QCPPainter::pmVectorized);
|
|
|
+ QCPPainter *localPainter = painter; // will be redirected to paint on mapBuffer if painting vectorized
|
|
|
+ QRectF mapBufferTarget; // the rect in absolute widget coordinates where the visible map portion/buffer will end up in
|
|
|
+ QPixmap mapBuffer;
|
|
|
+ if (useBuffer)
|
|
|
+ {
|
|
|
+ const double mapBufferPixelRatio = 3; // factor by which DPI is increased in embedded bitmaps
|
|
|
+ mapBufferTarget = painter->clipRegion().boundingRect();
|
|
|
+ mapBuffer = QPixmap((mapBufferTarget.size()*mapBufferPixelRatio).toSize());
|
|
|
+ mapBuffer.fill(Qt::transparent);
|
|
|
+ localPainter = new QCPPainter(&mapBuffer);
|
|
|
+ localPainter->scale(mapBufferPixelRatio, mapBufferPixelRatio);
|
|
|
+ localPainter->translate(-mapBufferTarget.topLeft());
|
|
|
+ }
|
|
|
+
|
|
|
+ QRectF imageRect = QRectF(coordsToPixels(mMapData->keyRange().lower, mMapData->valueRange().lower),
|
|
|
+ coordsToPixels(mMapData->keyRange().upper, mMapData->valueRange().upper)).normalized();
|
|
|
+ // extend imageRect to contain outer halves/quarters of bordering/cornering pixels (cells are centered on map range boundary):
|
|
|
+ double halfCellWidth = 0; // in pixels
|
|
|
+ double halfCellHeight = 0; // in pixels
|
|
|
+ if (keyAxis()->orientation() == Qt::Horizontal)
|
|
|
+ {
|
|
|
+ if (mMapData->keySize() > 1)
|
|
|
+ halfCellWidth = 0.5*imageRect.width()/(double)(mMapData->keySize()-1);
|
|
|
+ if (mMapData->valueSize() > 1)
|
|
|
+ halfCellHeight = 0.5*imageRect.height()/(double)(mMapData->valueSize()-1);
|
|
|
+ } else // keyAxis orientation is Qt::Vertical
|
|
|
+ {
|
|
|
+ if (mMapData->keySize() > 1)
|
|
|
+ halfCellHeight = 0.5*imageRect.height()/(double)(mMapData->keySize()-1);
|
|
|
+ if (mMapData->valueSize() > 1)
|
|
|
+ halfCellWidth = 0.5*imageRect.width()/(double)(mMapData->valueSize()-1);
|
|
|
+ }
|
|
|
+ imageRect.adjust(-halfCellWidth, -halfCellHeight, halfCellWidth, halfCellHeight);
|
|
|
+ const bool mirrorX = (keyAxis()->orientation() == Qt::Horizontal ? keyAxis() : valueAxis())->rangeReversed();
|
|
|
+ const bool mirrorY = (valueAxis()->orientation() == Qt::Vertical ? valueAxis() : keyAxis())->rangeReversed();
|
|
|
+ const bool smoothBackup = localPainter->renderHints().testFlag(QPainter::SmoothPixmapTransform);
|
|
|
+ localPainter->setRenderHint(QPainter::SmoothPixmapTransform, mInterpolate);
|
|
|
+ QRegion clipBackup;
|
|
|
+ if (mTightBoundary)
|
|
|
+ {
|
|
|
+ clipBackup = localPainter->clipRegion();
|
|
|
+ QRectF tightClipRect = QRectF(coordsToPixels(mMapData->keyRange().lower, mMapData->valueRange().lower),
|
|
|
+ coordsToPixels(mMapData->keyRange().upper, mMapData->valueRange().upper)).normalized();
|
|
|
+ localPainter->setClipRect(tightClipRect, Qt::IntersectClip);
|
|
|
+ }
|
|
|
+ localPainter->drawImage(imageRect, mMapImage.mirrored(mirrorX, mirrorY));
|
|
|
+ if (mTightBoundary)
|
|
|
+ localPainter->setClipRegion(clipBackup);
|
|
|
+ localPainter->setRenderHint(QPainter::SmoothPixmapTransform, smoothBackup);
|
|
|
+
|
|
|
+ if (useBuffer) // localPainter painted to mapBuffer, so now draw buffer with original painter
|
|
|
+ {
|
|
|
+ delete localPainter;
|
|
|
+ painter->drawPixmap(mapBufferTarget.toRect(), mapBuffer);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPColorMap::drawLegendIcon(QCPPainter *painter, const QRectF &rect) const
|
|
|
+{
|
|
|
+ applyDefaultAntialiasingHint(painter);
|
|
|
+ // draw map thumbnail:
|
|
|
+ if (!mLegendIcon.isNull())
|
|
|
+ {
|
|
|
+ QPixmap scaledIcon = mLegendIcon.scaled(rect.size().toSize(), Qt::KeepAspectRatio, Qt::FastTransformation);
|
|
|
+ QRectF iconRect = QRectF(0, 0, scaledIcon.width(), scaledIcon.height());
|
|
|
+ iconRect.moveCenter(rect.center());
|
|
|
+ painter->drawPixmap(iconRect.topLeft(), scaledIcon);
|
|
|
+ }
|
|
|
+ /*
|
|
|
+ // draw frame:
|
|
|
+ painter->setBrush(Qt::NoBrush);
|
|
|
+ painter->setPen(Qt::black);
|
|
|
+ painter->drawRect(rect.adjusted(1, 1, 0, 0));
|
|
|
+ */
|
|
|
+}
|
|
|
+/* end of 'src/plottables/plottable-colormap.cpp' */
|
|
|
+
|
|
|
+
|
|
|
+/* including file 'src/plottables/plottable-financial.cpp', size 42610 */
|
|
|
+/* commit 9868e55d3b412f2f89766bb482fcf299e93a0988 2017-09-04 01:56:22 +0200 */
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPFinancialData
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+/*! \class QCPFinancialData
|
|
|
+ \brief Holds the data of one single data point for QCPFinancial.
|
|
|
+
|
|
|
+ The stored data is:
|
|
|
+ \li \a key: coordinate on the key axis of this data point (this is the \a mainKey and the \a sortKey)
|
|
|
+ \li \a open: The opening value at the data point (this is the \a mainValue)
|
|
|
+ \li \a high: The high/maximum value at the data point
|
|
|
+ \li \a low: The low/minimum value at the data point
|
|
|
+ \li \a close: The closing value at the data point
|
|
|
+
|
|
|
+ The container for storing multiple data points is \ref QCPFinancialDataContainer. It is a typedef
|
|
|
+ for \ref QCPDataContainer with \ref QCPFinancialData as the DataType template parameter. See the
|
|
|
+ documentation there for an explanation regarding the data type's generic methods.
|
|
|
+
|
|
|
+ \see QCPFinancialDataContainer
|
|
|
+*/
|
|
|
+
|
|
|
+/* start documentation of inline functions */
|
|
|
+
|
|
|
+/*! \fn double QCPFinancialData::sortKey() const
|
|
|
+
|
|
|
+ Returns the \a key member of this data point.
|
|
|
+
|
|
|
+ For a general explanation of what this method is good for in the context of the data container,
|
|
|
+ see the documentation of \ref QCPDataContainer.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn static QCPFinancialData QCPFinancialData::fromSortKey(double sortKey)
|
|
|
+
|
|
|
+ Returns a data point with the specified \a sortKey. All other members are set to zero.
|
|
|
+
|
|
|
+ For a general explanation of what this method is good for in the context of the data container,
|
|
|
+ see the documentation of \ref QCPDataContainer.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn static static bool QCPFinancialData::sortKeyIsMainKey()
|
|
|
+
|
|
|
+ Since the member \a key is both the data point key coordinate and the data ordering parameter,
|
|
|
+ this method returns true.
|
|
|
+
|
|
|
+ For a general explanation of what this method is good for in the context of the data container,
|
|
|
+ see the documentation of \ref QCPDataContainer.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn double QCPFinancialData::mainKey() const
|
|
|
+
|
|
|
+ Returns the \a key member of this data point.
|
|
|
+
|
|
|
+ For a general explanation of what this method is good for in the context of the data container,
|
|
|
+ see the documentation of \ref QCPDataContainer.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn double QCPFinancialData::mainValue() const
|
|
|
+
|
|
|
+ Returns the \a open member of this data point.
|
|
|
+
|
|
|
+ For a general explanation of what this method is good for in the context of the data container,
|
|
|
+ see the documentation of \ref QCPDataContainer.
|
|
|
+*/
|
|
|
+
|
|
|
+/*! \fn QCPRange QCPFinancialData::valueRange() const
|
|
|
+
|
|
|
+ Returns a QCPRange spanning from the \a low to the \a high value of this data point.
|
|
|
+
|
|
|
+ For a general explanation of what this method is good for in the context of the data container,
|
|
|
+ see the documentation of \ref QCPDataContainer.
|
|
|
+*/
|
|
|
+
|
|
|
+/* end documentation of inline functions */
|
|
|
+
|
|
|
+/*!
|
|
|
+ Constructs a data point with key and all values set to zero.
|
|
|
+*/
|
|
|
+QCPFinancialData::QCPFinancialData() :
|
|
|
+ key(0),
|
|
|
+ open(0),
|
|
|
+ high(0),
|
|
|
+ low(0),
|
|
|
+ close(0)
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Constructs a data point with the specified \a key and OHLC values.
|
|
|
+*/
|
|
|
+QCPFinancialData::QCPFinancialData(double key, double open, double high, double low, double close) :
|
|
|
+ key(key),
|
|
|
+ open(open),
|
|
|
+ high(high),
|
|
|
+ low(low),
|
|
|
+ close(close)
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPFinancial
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+/*! \class QCPFinancial
|
|
|
+ \brief A plottable representing a financial stock chart
|
|
|
+
|
|
|
+ \image html QCPFinancial.png
|
|
|
+
|
|
|
+ This plottable represents time series data binned to certain intervals, mainly used for stock
|
|
|
+ charts. The two common representations OHLC (Open-High-Low-Close) bars and Candlesticks can be
|
|
|
+ set via \ref setChartStyle.
|
|
|
+
|
|
|
+ The data is passed via \ref setData as a set of open/high/low/close values at certain keys
|
|
|
+ (typically times). This means the data must be already binned appropriately. If data is only
|
|
|
+ available as a series of values (e.g. \a price against \a time), you can use the static
|
|
|
+ convenience function \ref timeSeriesToOhlc to generate binned OHLC-data which can then be passed
|
|
|
+ to \ref setData.
|
|
|
+
|
|
|
+ The width of the OHLC bars/candlesticks can be controlled with \ref setWidth and \ref
|
|
|
+ setWidthType. A typical choice is to set the width type to \ref wtPlotCoords (the default) and
|
|
|
+ the width to (or slightly less than) one time bin interval width.
|
|
|
+
|
|
|
+ \section qcpfinancial-appearance Changing the appearance
|
|
|
+
|
|
|
+ Charts can be either single- or two-colored (\ref setTwoColored). If set to be single-colored,
|
|
|
+ lines are drawn with the plottable's pen (\ref setPen) and fills with the brush (\ref setBrush).
|
|
|
+
|
|
|
+ If set to two-colored, positive changes of the value during an interval (\a close >= \a open) are
|
|
|
+ represented with a different pen and brush than negative changes (\a close < \a open). These can
|
|
|
+ be configured with \ref setPenPositive, \ref setPenNegative, \ref setBrushPositive, and \ref
|
|
|
+ setBrushNegative. In two-colored mode, the normal plottable pen/brush is ignored. Upon selection
|
|
|
+ however, the normal selected pen/brush (provided by the \ref selectionDecorator) is used,
|
|
|
+ irrespective of whether the chart is single- or two-colored.
|
|
|
+
|
|
|
+ \section qcpfinancial-usage Usage
|
|
|
+
|
|
|
+ Like all data representing objects in QCustomPlot, the QCPFinancial is a plottable
|
|
|
+ (QCPAbstractPlottable). So the plottable-interface of QCustomPlot applies
|
|
|
+ (QCustomPlot::plottable, QCustomPlot::removePlottable, etc.)
|
|
|
+
|
|
|
+ Usually, you first create an instance:
|
|
|
+
|
|
|
+ \snippet documentation/doc-code-snippets/mainwindow.cpp qcpfinancial-creation-1
|
|
|
+ which registers it with the QCustomPlot instance of the passed axes. Note that this QCustomPlot
|
|
|
+ instance takes ownership of the plottable, so do not delete it manually but use
|
|
|
+ QCustomPlot::removePlottable() instead. The newly created plottable can be modified, e.g.:
|
|
|
+
|
|
|
+ \snippet documentation/doc-code-snippets/mainwindow.cpp qcpfinancial-creation-2
|
|
|
+ Here we have used the static helper method \ref timeSeriesToOhlc, to turn a time-price data
|
|
|
+ series into a 24-hour binned open-high-low-close data series as QCPFinancial uses.
|
|
|
+*/
|
|
|
+
|
|
|
+/* start of documentation of inline functions */
|
|
|
+
|
|
|
+/*! \fn QCPFinancialDataContainer *QCPFinancial::data() const
|
|
|
+
|
|
|
+ Returns a pointer to the internal data storage of type \ref QCPFinancialDataContainer. You may
|
|
|
+ use it to directly manipulate the data, which may be more convenient and faster than using the
|
|
|
+ regular \ref setData or \ref addData methods, in certain situations.
|
|
|
+*/
|
|
|
+
|
|
|
+/* end of documentation of inline functions */
|
|
|
+
|
|
|
+/*!
|
|
|
+ Constructs a financial chart which uses \a keyAxis as its key axis ("x") and \a valueAxis as its value
|
|
|
+ axis ("y"). \a keyAxis and \a valueAxis must reside in the same QCustomPlot instance and not have
|
|
|
+ the same orientation. If either of these restrictions is violated, a corresponding message is
|
|
|
+ printed to the debug output (qDebug), the construction is not aborted, though.
|
|
|
+
|
|
|
+ The created QCPFinancial is automatically registered with the QCustomPlot instance inferred from \a
|
|
|
+ keyAxis. This QCustomPlot instance takes ownership of the QCPFinancial, so do not delete it manually
|
|
|
+ but use QCustomPlot::removePlottable() instead.
|
|
|
+*/
|
|
|
+QCPFinancial::QCPFinancial(QCPAxis *keyAxis, QCPAxis *valueAxis) :
|
|
|
+ QCPAbstractPlottable1D<QCPFinancialData>(keyAxis, valueAxis),
|
|
|
+ mChartStyle(csCandlestick),
|
|
|
+ mWidth(0.5),
|
|
|
+ mWidthType(wtPlotCoords),
|
|
|
+ mTwoColored(true),
|
|
|
+ mBrushPositive(QBrush(QColor(50, 160, 0))),
|
|
|
+ mBrushNegative(QBrush(QColor(180, 0, 15))),
|
|
|
+ mPenPositive(QPen(QColor(40, 150, 0))),
|
|
|
+ mPenNegative(QPen(QColor(170, 5, 5)))
|
|
|
+{
|
|
|
+ mSelectionDecorator->setBrush(QBrush(QColor(160, 160, 255)));
|
|
|
+}
|
|
|
+
|
|
|
+QCPFinancial::~QCPFinancial()
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Replaces the current data container with the provided \a data container.
|
|
|
+
|
|
|
+ Since a QSharedPointer is used, multiple QCPFinancials may share the same data container safely.
|
|
|
+ Modifying the data in the container will then affect all financials that share the container.
|
|
|
+ Sharing can be achieved by simply exchanging the data containers wrapped in shared pointers:
|
|
|
+ \snippet documentation/doc-code-snippets/mainwindow.cpp qcpfinancial-datasharing-1
|
|
|
+
|
|
|
+ If you do not wish to share containers, but create a copy from an existing container, rather use
|
|
|
+ the \ref QCPDataContainer<DataType>::set method on the financial's data container directly:
|
|
|
+ \snippet documentation/doc-code-snippets/mainwindow.cpp qcpfinancial-datasharing-2
|
|
|
+
|
|
|
+ \see addData, timeSeriesToOhlc
|
|
|
+*/
|
|
|
+void QCPFinancial::setData(QSharedPointer<QCPFinancialDataContainer> data)
|
|
|
+{
|
|
|
+ mDataContainer = data;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Replaces the current data with the provided points in \a keys, \a open, \a high, \a low and \a
|
|
|
+ close. The provided vectors should have equal length. Else, the number of added points will be
|
|
|
+ the size of the smallest vector.
|
|
|
+
|
|
|
+ If you can guarantee that the passed data points are sorted by \a keys in ascending order, you
|
|
|
+ can set \a alreadySorted to true, to improve performance by saving a sorting run.
|
|
|
+
|
|
|
+ \see addData, timeSeriesToOhlc
|
|
|
+*/
|
|
|
+void QCPFinancial::setData(const QVector<double> &keys, const QVector<double> &open, const QVector<double> &high, const QVector<double> &low, const QVector<double> &close, bool alreadySorted)
|
|
|
+{
|
|
|
+ mDataContainer->clear();
|
|
|
+ addData(keys, open, high, low, close, alreadySorted);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets which representation style shall be used to display the OHLC data.
|
|
|
+*/
|
|
|
+void QCPFinancial::setChartStyle(QCPFinancial::ChartStyle style)
|
|
|
+{
|
|
|
+ mChartStyle = style;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the width of the individual bars/candlesticks to \a width in plot key coordinates.
|
|
|
+
|
|
|
+ A typical choice is to set it to (or slightly less than) one bin interval width.
|
|
|
+*/
|
|
|
+void QCPFinancial::setWidth(double width)
|
|
|
+{
|
|
|
+ mWidth = width;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets how the width of the financial bars is defined. See the documentation of \ref WidthType for
|
|
|
+ an explanation of the possible values for \a widthType.
|
|
|
+
|
|
|
+ The default value is \ref wtPlotCoords.
|
|
|
+
|
|
|
+ \see setWidth
|
|
|
+*/
|
|
|
+void QCPFinancial::setWidthType(QCPFinancial::WidthType widthType)
|
|
|
+{
|
|
|
+ mWidthType = widthType;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets whether this chart shall contrast positive from negative trends per data point by using two
|
|
|
+ separate colors to draw the respective bars/candlesticks.
|
|
|
+
|
|
|
+ If \a twoColored is false, the normal plottable's pen and brush are used (\ref setPen, \ref
|
|
|
+ setBrush).
|
|
|
+
|
|
|
+ \see setPenPositive, setPenNegative, setBrushPositive, setBrushNegative
|
|
|
+*/
|
|
|
+void QCPFinancial::setTwoColored(bool twoColored)
|
|
|
+{
|
|
|
+ mTwoColored = twoColored;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ If \ref setTwoColored is set to true, this function controls the brush that is used to draw fills
|
|
|
+ of data points with a positive trend (i.e. bars/candlesticks with close >= open).
|
|
|
+
|
|
|
+ If \a twoColored is false, the normal plottable's pen and brush are used (\ref setPen, \ref
|
|
|
+ setBrush).
|
|
|
+
|
|
|
+ \see setBrushNegative, setPenPositive, setPenNegative
|
|
|
+*/
|
|
|
+void QCPFinancial::setBrushPositive(const QBrush &brush)
|
|
|
+{
|
|
|
+ mBrushPositive = brush;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ If \ref setTwoColored is set to true, this function controls the brush that is used to draw fills
|
|
|
+ of data points with a negative trend (i.e. bars/candlesticks with close < open).
|
|
|
+
|
|
|
+ If \a twoColored is false, the normal plottable's pen and brush are used (\ref setPen, \ref
|
|
|
+ setBrush).
|
|
|
+
|
|
|
+ \see setBrushPositive, setPenNegative, setPenPositive
|
|
|
+*/
|
|
|
+void QCPFinancial::setBrushNegative(const QBrush &brush)
|
|
|
+{
|
|
|
+ mBrushNegative = brush;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ If \ref setTwoColored is set to true, this function controls the pen that is used to draw
|
|
|
+ outlines of data points with a positive trend (i.e. bars/candlesticks with close >= open).
|
|
|
+
|
|
|
+ If \a twoColored is false, the normal plottable's pen and brush are used (\ref setPen, \ref
|
|
|
+ setBrush).
|
|
|
+
|
|
|
+ \see setPenNegative, setBrushPositive, setBrushNegative
|
|
|
+*/
|
|
|
+void QCPFinancial::setPenPositive(const QPen &pen)
|
|
|
+{
|
|
|
+ mPenPositive = pen;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ If \ref setTwoColored is set to true, this function controls the pen that is used to draw
|
|
|
+ outlines of data points with a negative trend (i.e. bars/candlesticks with close < open).
|
|
|
+
|
|
|
+ If \a twoColored is false, the normal plottable's pen and brush are used (\ref setPen, \ref
|
|
|
+ setBrush).
|
|
|
+
|
|
|
+ \see setPenPositive, setBrushNegative, setBrushPositive
|
|
|
+*/
|
|
|
+void QCPFinancial::setPenNegative(const QPen &pen)
|
|
|
+{
|
|
|
+ mPenNegative = pen;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Adds the provided points in \a keys, \a open, \a high, \a low and \a close to the current data.
|
|
|
+ The provided vectors should have equal length. Else, the number of added points will be the size
|
|
|
+ of the smallest vector.
|
|
|
+
|
|
|
+ If you can guarantee that the passed data points are sorted by \a keys in ascending order, you
|
|
|
+ can set \a alreadySorted to true, to improve performance by saving a sorting run.
|
|
|
+
|
|
|
+ Alternatively, you can also access and modify the data directly via the \ref data method, which
|
|
|
+ returns a pointer to the internal data container.
|
|
|
+
|
|
|
+ \see timeSeriesToOhlc
|
|
|
+*/
|
|
|
+void QCPFinancial::addData(const QVector<double> &keys, const QVector<double> &open, const QVector<double> &high, const QVector<double> &low, const QVector<double> &close, bool alreadySorted)
|
|
|
+{
|
|
|
+ if (keys.size() != open.size() || open.size() != high.size() || high.size() != low.size() || low.size() != close.size() || close.size() != keys.size())
|
|
|
+ qDebug() << Q_FUNC_INFO << "keys, open, high, low, close have different sizes:" << keys.size() << open.size() << high.size() << low.size() << close.size();
|
|
|
+ const int n = qMin(keys.size(), qMin(open.size(), qMin(high.size(), qMin(low.size(), close.size()))));
|
|
|
+ QVector<QCPFinancialData> tempData(n);
|
|
|
+ QVector<QCPFinancialData>::iterator it = tempData.begin();
|
|
|
+ const QVector<QCPFinancialData>::iterator itEnd = tempData.end();
|
|
|
+ int i = 0;
|
|
|
+ while (it != itEnd)
|
|
|
+ {
|
|
|
+ it->key = keys[i];
|
|
|
+ it->open = open[i];
|
|
|
+ it->high = high[i];
|
|
|
+ it->low = low[i];
|
|
|
+ it->close = close[i];
|
|
|
+ ++it;
|
|
|
+ ++i;
|
|
|
+ }
|
|
|
+ mDataContainer->add(tempData, alreadySorted); // don't modify tempData beyond this to prevent copy on write
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Adds the provided data point as \a key, \a open, \a high, \a low and \a close to the current
|
|
|
+ data.
|
|
|
+
|
|
|
+ Alternatively, you can also access and modify the data directly via the \ref data method, which
|
|
|
+ returns a pointer to the internal data container.
|
|
|
+
|
|
|
+ \see timeSeriesToOhlc
|
|
|
+*/
|
|
|
+void QCPFinancial::addData(double key, double open, double high, double low, double close)
|
|
|
+{
|
|
|
+ mDataContainer->add(QCPFinancialData(key, open, high, low, close));
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ \copydoc QCPPlottableInterface1D::selectTestRect
|
|
|
+*/
|
|
|
+QCPDataSelection QCPFinancial::selectTestRect(const QRectF &rect, bool onlySelectable) const
|
|
|
+{
|
|
|
+ QCPDataSelection result;
|
|
|
+ if ((onlySelectable && mSelectable == QCP::stNone) || mDataContainer->isEmpty())
|
|
|
+ return result;
|
|
|
+ if (!mKeyAxis || !mValueAxis)
|
|
|
+ return result;
|
|
|
+
|
|
|
+ QCPFinancialDataContainer::const_iterator visibleBegin, visibleEnd;
|
|
|
+ getVisibleDataBounds(visibleBegin, visibleEnd);
|
|
|
+
|
|
|
+ for (QCPFinancialDataContainer::const_iterator it=visibleBegin; it!=visibleEnd; ++it)
|
|
|
+ {
|
|
|
+ if (rect.intersects(selectionHitBox(it)))
|
|
|
+ result.addDataRange(QCPDataRange(it-mDataContainer->constBegin(), it-mDataContainer->constBegin()+1), false);
|
|
|
+ }
|
|
|
+ result.simplify();
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+double QCPFinancial::selectTest(const QPointF &pos, bool onlySelectable, QVariant *details) const
|
|
|
+{
|
|
|
+ Q_UNUSED(details)
|
|
|
+ if ((onlySelectable && mSelectable == QCP::stNone) || mDataContainer->isEmpty())
|
|
|
+ return -1;
|
|
|
+ if (!mKeyAxis || !mValueAxis)
|
|
|
+ return -1;
|
|
|
+
|
|
|
+ if (mKeyAxis.data()->axisRect()->rect().contains(pos.toPoint()))
|
|
|
+ {
|
|
|
+ // get visible data range:
|
|
|
+ QCPFinancialDataContainer::const_iterator visibleBegin, visibleEnd;
|
|
|
+ QCPFinancialDataContainer::const_iterator closestDataPoint = mDataContainer->constEnd();
|
|
|
+ getVisibleDataBounds(visibleBegin, visibleEnd);
|
|
|
+ // perform select test according to configured style:
|
|
|
+ double result = -1;
|
|
|
+ switch (mChartStyle)
|
|
|
+ {
|
|
|
+ case QCPFinancial::csOhlc:
|
|
|
+ result = ohlcSelectTest(pos, visibleBegin, visibleEnd, closestDataPoint); break;
|
|
|
+ case QCPFinancial::csCandlestick:
|
|
|
+ result = candlestickSelectTest(pos, visibleBegin, visibleEnd, closestDataPoint); break;
|
|
|
+ }
|
|
|
+ if (details)
|
|
|
+ {
|
|
|
+ int pointIndex = closestDataPoint-mDataContainer->constBegin();
|
|
|
+ details->setValue(QCPDataSelection(QCPDataRange(pointIndex, pointIndex+1)));
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+ }
|
|
|
+
|
|
|
+ return -1;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+QCPRange QCPFinancial::getKeyRange(bool &foundRange, QCP::SignDomain inSignDomain) const
|
|
|
+{
|
|
|
+ QCPRange range = mDataContainer->keyRange(foundRange, inSignDomain);
|
|
|
+ // determine exact range by including width of bars/flags:
|
|
|
+ if (foundRange)
|
|
|
+ {
|
|
|
+ if (inSignDomain != QCP::sdPositive || range.lower-mWidth*0.5 > 0)
|
|
|
+ range.lower -= mWidth*0.5;
|
|
|
+ if (inSignDomain != QCP::sdNegative || range.upper+mWidth*0.5 < 0)
|
|
|
+ range.upper += mWidth*0.5;
|
|
|
+ }
|
|
|
+ return range;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+QCPRange QCPFinancial::getValueRange(bool &foundRange, QCP::SignDomain inSignDomain, const QCPRange &inKeyRange) const
|
|
|
+{
|
|
|
+ return mDataContainer->valueRange(foundRange, inSignDomain, inKeyRange);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ A convenience function that converts time series data (\a value against \a time) to OHLC binned
|
|
|
+ data points. The return value can then be passed on to \ref QCPFinancialDataContainer::set(const
|
|
|
+ QCPFinancialDataContainer&).
|
|
|
+
|
|
|
+ The size of the bins can be controlled with \a timeBinSize in the same units as \a time is given.
|
|
|
+ For example, if the unit of \a time is seconds and single OHLC/Candlesticks should span an hour
|
|
|
+ each, set \a timeBinSize to 3600.
|
|
|
+
|
|
|
+ \a timeBinOffset allows to control precisely at what \a time coordinate a bin should start. The
|
|
|
+ value passed as \a timeBinOffset doesn't need to be in the range encompassed by the \a time keys.
|
|
|
+ It merely defines the mathematical offset/phase of the bins that will be used to process the
|
|
|
+ data.
|
|
|
+*/
|
|
|
+QCPFinancialDataContainer QCPFinancial::timeSeriesToOhlc(const QVector<double> &time, const QVector<double> &value, double timeBinSize, double timeBinOffset)
|
|
|
+{
|
|
|
+ QCPFinancialDataContainer data;
|
|
|
+ int count = qMin(time.size(), value.size());
|
|
|
+ if (count == 0)
|
|
|
+ return QCPFinancialDataContainer();
|
|
|
+
|
|
|
+ QCPFinancialData currentBinData(0, value.first(), value.first(), value.first(), value.first());
|
|
|
+ int currentBinIndex = qFloor((time.first()-timeBinOffset)/timeBinSize+0.5);
|
|
|
+ for (int i=0; i<count; ++i)
|
|
|
+ {
|
|
|
+ int index = qFloor((time.at(i)-timeBinOffset)/timeBinSize+0.5);
|
|
|
+ if (currentBinIndex == index) // data point still in current bin, extend high/low:
|
|
|
+ {
|
|
|
+ if (value.at(i) < currentBinData.low) currentBinData.low = value.at(i);
|
|
|
+ if (value.at(i) > currentBinData.high) currentBinData.high = value.at(i);
|
|
|
+ if (i == count-1) // last data point is in current bin, finalize bin:
|
|
|
+ {
|
|
|
+ currentBinData.close = value.at(i);
|
|
|
+ currentBinData.key = timeBinOffset+(index)*timeBinSize;
|
|
|
+ data.add(currentBinData);
|
|
|
+ }
|
|
|
+ } else // data point not anymore in current bin, set close of old and open of new bin, and add old to map:
|
|
|
+ {
|
|
|
+ // finalize current bin:
|
|
|
+ currentBinData.close = value.at(i-1);
|
|
|
+ currentBinData.key = timeBinOffset+(index-1)*timeBinSize;
|
|
|
+ data.add(currentBinData);
|
|
|
+ // start next bin:
|
|
|
+ currentBinIndex = index;
|
|
|
+ currentBinData.open = value.at(i);
|
|
|
+ currentBinData.high = value.at(i);
|
|
|
+ currentBinData.low = value.at(i);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return data;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPFinancial::draw(QCPPainter *painter)
|
|
|
+{
|
|
|
+ // get visible data range:
|
|
|
+ QCPFinancialDataContainer::const_iterator visibleBegin, visibleEnd;
|
|
|
+ getVisibleDataBounds(visibleBegin, visibleEnd);
|
|
|
+
|
|
|
+ // loop over and draw segments of unselected/selected data:
|
|
|
+ QList<QCPDataRange> selectedSegments, unselectedSegments, allSegments;
|
|
|
+ getDataSegments(selectedSegments, unselectedSegments);
|
|
|
+ allSegments << unselectedSegments << selectedSegments;
|
|
|
+ for (int i=0; i<allSegments.size(); ++i)
|
|
|
+ {
|
|
|
+ bool isSelectedSegment = i >= unselectedSegments.size();
|
|
|
+ QCPFinancialDataContainer::const_iterator begin = visibleBegin;
|
|
|
+ QCPFinancialDataContainer::const_iterator end = visibleEnd;
|
|
|
+ mDataContainer->limitIteratorsToDataRange(begin, end, allSegments.at(i));
|
|
|
+ if (begin == end)
|
|
|
+ continue;
|
|
|
+
|
|
|
+ // draw data segment according to configured style:
|
|
|
+ switch (mChartStyle)
|
|
|
+ {
|
|
|
+ case QCPFinancial::csOhlc:
|
|
|
+ drawOhlcPlot(painter, begin, end, isSelectedSegment); break;
|
|
|
+ case QCPFinancial::csCandlestick:
|
|
|
+ drawCandlestickPlot(painter, begin, end, isSelectedSegment); break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // draw other selection decoration that isn't just line/scatter pens and brushes:
|
|
|
+ if (mSelectionDecorator)
|
|
|
+ mSelectionDecorator->drawDecoration(painter, selection());
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPFinancial::drawLegendIcon(QCPPainter *painter, const QRectF &rect) const
|
|
|
+{
|
|
|
+ painter->setAntialiasing(false); // legend icon especially of csCandlestick looks better without antialiasing
|
|
|
+ if (mChartStyle == csOhlc)
|
|
|
+ {
|
|
|
+ if (mTwoColored)
|
|
|
+ {
|
|
|
+ // draw upper left half icon with positive color:
|
|
|
+ painter->setBrush(mBrushPositive);
|
|
|
+ painter->setPen(mPenPositive);
|
|
|
+ painter->setClipRegion(QRegion(QPolygon() << rect.bottomLeft().toPoint() << rect.topRight().toPoint() << rect.topLeft().toPoint()));
|
|
|
+ painter->drawLine(QLineF(0, rect.height()*0.5, rect.width(), rect.height()*0.5).translated(rect.topLeft()));
|
|
|
+ painter->drawLine(QLineF(rect.width()*0.2, rect.height()*0.3, rect.width()*0.2, rect.height()*0.5).translated(rect.topLeft()));
|
|
|
+ painter->drawLine(QLineF(rect.width()*0.8, rect.height()*0.5, rect.width()*0.8, rect.height()*0.7).translated(rect.topLeft()));
|
|
|
+ // draw bottom right half icon with negative color:
|
|
|
+ painter->setBrush(mBrushNegative);
|
|
|
+ painter->setPen(mPenNegative);
|
|
|
+ painter->setClipRegion(QRegion(QPolygon() << rect.bottomLeft().toPoint() << rect.topRight().toPoint() << rect.bottomRight().toPoint()));
|
|
|
+ painter->drawLine(QLineF(0, rect.height()*0.5, rect.width(), rect.height()*0.5).translated(rect.topLeft()));
|
|
|
+ painter->drawLine(QLineF(rect.width()*0.2, rect.height()*0.3, rect.width()*0.2, rect.height()*0.5).translated(rect.topLeft()));
|
|
|
+ painter->drawLine(QLineF(rect.width()*0.8, rect.height()*0.5, rect.width()*0.8, rect.height()*0.7).translated(rect.topLeft()));
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ painter->setBrush(mBrush);
|
|
|
+ painter->setPen(mPen);
|
|
|
+ painter->drawLine(QLineF(0, rect.height()*0.5, rect.width(), rect.height()*0.5).translated(rect.topLeft()));
|
|
|
+ painter->drawLine(QLineF(rect.width()*0.2, rect.height()*0.3, rect.width()*0.2, rect.height()*0.5).translated(rect.topLeft()));
|
|
|
+ painter->drawLine(QLineF(rect.width()*0.8, rect.height()*0.5, rect.width()*0.8, rect.height()*0.7).translated(rect.topLeft()));
|
|
|
+ }
|
|
|
+ } else if (mChartStyle == csCandlestick)
|
|
|
+ {
|
|
|
+ if (mTwoColored)
|
|
|
+ {
|
|
|
+ // draw upper left half icon with positive color:
|
|
|
+ painter->setBrush(mBrushPositive);
|
|
|
+ painter->setPen(mPenPositive);
|
|
|
+ painter->setClipRegion(QRegion(QPolygon() << rect.bottomLeft().toPoint() << rect.topRight().toPoint() << rect.topLeft().toPoint()));
|
|
|
+ painter->drawLine(QLineF(0, rect.height()*0.5, rect.width()*0.25, rect.height()*0.5).translated(rect.topLeft()));
|
|
|
+ painter->drawLine(QLineF(rect.width()*0.75, rect.height()*0.5, rect.width(), rect.height()*0.5).translated(rect.topLeft()));
|
|
|
+ painter->drawRect(QRectF(rect.width()*0.25, rect.height()*0.25, rect.width()*0.5, rect.height()*0.5).translated(rect.topLeft()));
|
|
|
+ // draw bottom right half icon with negative color:
|
|
|
+ painter->setBrush(mBrushNegative);
|
|
|
+ painter->setPen(mPenNegative);
|
|
|
+ painter->setClipRegion(QRegion(QPolygon() << rect.bottomLeft().toPoint() << rect.topRight().toPoint() << rect.bottomRight().toPoint()));
|
|
|
+ painter->drawLine(QLineF(0, rect.height()*0.5, rect.width()*0.25, rect.height()*0.5).translated(rect.topLeft()));
|
|
|
+ painter->drawLine(QLineF(rect.width()*0.75, rect.height()*0.5, rect.width(), rect.height()*0.5).translated(rect.topLeft()));
|
|
|
+ painter->drawRect(QRectF(rect.width()*0.25, rect.height()*0.25, rect.width()*0.5, rect.height()*0.5).translated(rect.topLeft()));
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ painter->setBrush(mBrush);
|
|
|
+ painter->setPen(mPen);
|
|
|
+ painter->drawLine(QLineF(0, rect.height()*0.5, rect.width()*0.25, rect.height()*0.5).translated(rect.topLeft()));
|
|
|
+ painter->drawLine(QLineF(rect.width()*0.75, rect.height()*0.5, rect.width(), rect.height()*0.5).translated(rect.topLeft()));
|
|
|
+ painter->drawRect(QRectF(rect.width()*0.25, rect.height()*0.25, rect.width()*0.5, rect.height()*0.5).translated(rect.topLeft()));
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Draws the data from \a begin to \a end-1 as OHLC bars with the provided \a painter.
|
|
|
+
|
|
|
+ This method is a helper function for \ref draw. It is used when the chart style is \ref csOhlc.
|
|
|
+*/
|
|
|
+void QCPFinancial::drawOhlcPlot(QCPPainter *painter, const QCPFinancialDataContainer::const_iterator &begin, const QCPFinancialDataContainer::const_iterator &end, bool isSelected)
|
|
|
+{
|
|
|
+ QCPAxis *keyAxis = mKeyAxis.data();
|
|
|
+ QCPAxis *valueAxis = mValueAxis.data();
|
|
|
+ if (!keyAxis || !valueAxis) { qDebug() << Q_FUNC_INFO << "invalid key or value axis"; return; }
|
|
|
+
|
|
|
+ if (keyAxis->orientation() == Qt::Horizontal)
|
|
|
+ {
|
|
|
+ for (QCPFinancialDataContainer::const_iterator it = begin; it != end; ++it)
|
|
|
+ {
|
|
|
+ if (isSelected && mSelectionDecorator)
|
|
|
+ mSelectionDecorator->applyPen(painter);
|
|
|
+ else if (mTwoColored)
|
|
|
+ painter->setPen(it->close >= it->open ? mPenPositive : mPenNegative);
|
|
|
+ else
|
|
|
+ painter->setPen(mPen);
|
|
|
+ double keyPixel = keyAxis->coordToPixel(it->key);
|
|
|
+ double openPixel = valueAxis->coordToPixel(it->open);
|
|
|
+ double closePixel = valueAxis->coordToPixel(it->close);
|
|
|
+ // draw backbone:
|
|
|
+ painter->drawLine(QPointF(keyPixel, valueAxis->coordToPixel(it->high)), QPointF(keyPixel, valueAxis->coordToPixel(it->low)));
|
|
|
+ // draw open:
|
|
|
+ double pixelWidth = getPixelWidth(it->key, keyPixel); // sign of this makes sure open/close are on correct sides
|
|
|
+ painter->drawLine(QPointF(keyPixel-pixelWidth, openPixel), QPointF(keyPixel, openPixel));
|
|
|
+ // draw close:
|
|
|
+ painter->drawLine(QPointF(keyPixel, closePixel), QPointF(keyPixel+pixelWidth, closePixel));
|
|
|
+ }
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ for (QCPFinancialDataContainer::const_iterator it = begin; it != end; ++it)
|
|
|
+ {
|
|
|
+ if (isSelected && mSelectionDecorator)
|
|
|
+ mSelectionDecorator->applyPen(painter);
|
|
|
+ else if (mTwoColored)
|
|
|
+ painter->setPen(it->close >= it->open ? mPenPositive : mPenNegative);
|
|
|
+ else
|
|
|
+ painter->setPen(mPen);
|
|
|
+ double keyPixel = keyAxis->coordToPixel(it->key);
|
|
|
+ double openPixel = valueAxis->coordToPixel(it->open);
|
|
|
+ double closePixel = valueAxis->coordToPixel(it->close);
|
|
|
+ // draw backbone:
|
|
|
+ painter->drawLine(QPointF(valueAxis->coordToPixel(it->high), keyPixel), QPointF(valueAxis->coordToPixel(it->low), keyPixel));
|
|
|
+ // draw open:
|
|
|
+ double pixelWidth = getPixelWidth(it->key, keyPixel); // sign of this makes sure open/close are on correct sides
|
|
|
+ painter->drawLine(QPointF(openPixel, keyPixel-pixelWidth), QPointF(openPixel, keyPixel));
|
|
|
+ // draw close:
|
|
|
+ painter->drawLine(QPointF(closePixel, keyPixel), QPointF(closePixel, keyPixel+pixelWidth));
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Draws the data from \a begin to \a end-1 as Candlesticks with the provided \a painter.
|
|
|
+
|
|
|
+ This method is a helper function for \ref draw. It is used when the chart style is \ref csCandlestick.
|
|
|
+*/
|
|
|
+void QCPFinancial::drawCandlestickPlot(QCPPainter *painter, const QCPFinancialDataContainer::const_iterator &begin, const QCPFinancialDataContainer::const_iterator &end, bool isSelected)
|
|
|
+{
|
|
|
+ QCPAxis *keyAxis = mKeyAxis.data();
|
|
|
+ QCPAxis *valueAxis = mValueAxis.data();
|
|
|
+ if (!keyAxis || !valueAxis) { qDebug() << Q_FUNC_INFO << "invalid key or value axis"; return; }
|
|
|
+
|
|
|
+ if (keyAxis->orientation() == Qt::Horizontal)
|
|
|
+ {
|
|
|
+ for (QCPFinancialDataContainer::const_iterator it = begin; it != end; ++it)
|
|
|
+ {
|
|
|
+ if (isSelected && mSelectionDecorator)
|
|
|
+ {
|
|
|
+ mSelectionDecorator->applyPen(painter);
|
|
|
+ mSelectionDecorator->applyBrush(painter);
|
|
|
+ } else if (mTwoColored)
|
|
|
+ {
|
|
|
+ painter->setPen(it->close >= it->open ? mPenPositive : mPenNegative);
|
|
|
+ painter->setBrush(it->close >= it->open ? mBrushPositive : mBrushNegative);
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ painter->setPen(mPen);
|
|
|
+ painter->setBrush(mBrush);
|
|
|
+ }
|
|
|
+ double keyPixel = keyAxis->coordToPixel(it->key);
|
|
|
+ double openPixel = valueAxis->coordToPixel(it->open);
|
|
|
+ double closePixel = valueAxis->coordToPixel(it->close);
|
|
|
+ // draw high:
|
|
|
+ painter->drawLine(QPointF(keyPixel, valueAxis->coordToPixel(it->high)), QPointF(keyPixel, valueAxis->coordToPixel(qMax(it->open, it->close))));
|
|
|
+ // draw low:
|
|
|
+ painter->drawLine(QPointF(keyPixel, valueAxis->coordToPixel(it->low)), QPointF(keyPixel, valueAxis->coordToPixel(qMin(it->open, it->close))));
|
|
|
+ // draw open-close box:
|
|
|
+ double pixelWidth = getPixelWidth(it->key, keyPixel);
|
|
|
+ painter->drawRect(QRectF(QPointF(keyPixel-pixelWidth, closePixel), QPointF(keyPixel+pixelWidth, openPixel)));
|
|
|
+ }
|
|
|
+ } else // keyAxis->orientation() == Qt::Vertical
|
|
|
+ {
|
|
|
+ for (QCPFinancialDataContainer::const_iterator it = begin; it != end; ++it)
|
|
|
+ {
|
|
|
+ if (isSelected && mSelectionDecorator)
|
|
|
+ {
|
|
|
+ mSelectionDecorator->applyPen(painter);
|
|
|
+ mSelectionDecorator->applyBrush(painter);
|
|
|
+ } else if (mTwoColored)
|
|
|
+ {
|
|
|
+ painter->setPen(it->close >= it->open ? mPenPositive : mPenNegative);
|
|
|
+ painter->setBrush(it->close >= it->open ? mBrushPositive : mBrushNegative);
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ painter->setPen(mPen);
|
|
|
+ painter->setBrush(mBrush);
|
|
|
+ }
|
|
|
+ double keyPixel = keyAxis->coordToPixel(it->key);
|
|
|
+ double openPixel = valueAxis->coordToPixel(it->open);
|
|
|
+ double closePixel = valueAxis->coordToPixel(it->close);
|
|
|
+ // draw high:
|
|
|
+ painter->drawLine(QPointF(valueAxis->coordToPixel(it->high), keyPixel), QPointF(valueAxis->coordToPixel(qMax(it->open, it->close)), keyPixel));
|
|
|
+ // draw low:
|
|
|
+ painter->drawLine(QPointF(valueAxis->coordToPixel(it->low), keyPixel), QPointF(valueAxis->coordToPixel(qMin(it->open, it->close)), keyPixel));
|
|
|
+ // draw open-close box:
|
|
|
+ double pixelWidth = getPixelWidth(it->key, keyPixel);
|
|
|
+ painter->drawRect(QRectF(QPointF(closePixel, keyPixel-pixelWidth), QPointF(openPixel, keyPixel+pixelWidth)));
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ This function is used to determine the width of the bar at coordinate \a key, according to the
|
|
|
+ specified width (\ref setWidth) and width type (\ref setWidthType). Provide the pixel position of
|
|
|
+ \a key in \a keyPixel (because usually this was already calculated via \ref QCPAxis::coordToPixel
|
|
|
+ when this function is called).
|
|
|
+
|
|
|
+ It returns the number of pixels the bar extends to higher keys, relative to the \a key
|
|
|
+ coordinate. So with a non-reversed horizontal axis, the return value is positive. With a reversed
|
|
|
+ horizontal axis, the return value is negative. This is important so the open/close flags on the
|
|
|
+ \ref csOhlc bar are drawn to the correct side.
|
|
|
+*/
|
|
|
+double QCPFinancial::getPixelWidth(double key, double keyPixel) const
|
|
|
+{
|
|
|
+ double result = 0;
|
|
|
+ switch (mWidthType)
|
|
|
+ {
|
|
|
+ case wtAbsolute:
|
|
|
+ {
|
|
|
+ if (mKeyAxis)
|
|
|
+ result = mWidth*0.5*mKeyAxis.data()->pixelOrientation();
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case wtAxisRectRatio:
|
|
|
+ {
|
|
|
+ if (mKeyAxis && mKeyAxis.data()->axisRect())
|
|
|
+ {
|
|
|
+ if (mKeyAxis.data()->orientation() == Qt::Horizontal)
|
|
|
+ result = mKeyAxis.data()->axisRect()->width()*mWidth*0.5*mKeyAxis.data()->pixelOrientation();
|
|
|
+ else
|
|
|
+ result = mKeyAxis.data()->axisRect()->height()*mWidth*0.5*mKeyAxis.data()->pixelOrientation();
|
|
|
+ } else
|
|
|
+ qDebug() << Q_FUNC_INFO << "No key axis or axis rect defined";
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case wtPlotCoords:
|
|
|
+ {
|
|
|
+ if (mKeyAxis)
|
|
|
+ result = mKeyAxis.data()->coordToPixel(key+mWidth*0.5)-keyPixel;
|
|
|
+ else
|
|
|
+ qDebug() << Q_FUNC_INFO << "No key axis defined";
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ This method is a helper function for \ref selectTest. It is used to test for selection when the
|
|
|
+ chart style is \ref csOhlc. It only tests against the data points between \a begin and \a end.
|
|
|
+
|
|
|
+ Like \ref selectTest, this method returns the shortest distance of \a pos to the graphical
|
|
|
+ representation of the plottable, and \a closestDataPoint will point to the respective data point.
|
|
|
+*/
|
|
|
+double QCPFinancial::ohlcSelectTest(const QPointF &pos, const QCPFinancialDataContainer::const_iterator &begin, const QCPFinancialDataContainer::const_iterator &end, QCPFinancialDataContainer::const_iterator &closestDataPoint) const
|
|
|
+{
|
|
|
+ closestDataPoint = mDataContainer->constEnd();
|
|
|
+ QCPAxis *keyAxis = mKeyAxis.data();
|
|
|
+ QCPAxis *valueAxis = mValueAxis.data();
|
|
|
+ if (!keyAxis || !valueAxis) { qDebug() << Q_FUNC_INFO << "invalid key or value axis"; return -1; }
|
|
|
+
|
|
|
+ double minDistSqr = std::numeric_limits<double>::max();
|
|
|
+ if (keyAxis->orientation() == Qt::Horizontal)
|
|
|
+ {
|
|
|
+ for (QCPFinancialDataContainer::const_iterator it=begin; it!=end; ++it)
|
|
|
+ {
|
|
|
+ double keyPixel = keyAxis->coordToPixel(it->key);
|
|
|
+ // calculate distance to backbone:
|
|
|
+ double currentDistSqr = QCPVector2D(pos).distanceSquaredToLine(QCPVector2D(keyPixel, valueAxis->coordToPixel(it->high)), QCPVector2D(keyPixel, valueAxis->coordToPixel(it->low)));
|
|
|
+ if (currentDistSqr < minDistSqr)
|
|
|
+ {
|
|
|
+ minDistSqr = currentDistSqr;
|
|
|
+ closestDataPoint = it;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } else // keyAxis->orientation() == Qt::Vertical
|
|
|
+ {
|
|
|
+ for (QCPFinancialDataContainer::const_iterator it=begin; it!=end; ++it)
|
|
|
+ {
|
|
|
+ double keyPixel = keyAxis->coordToPixel(it->key);
|
|
|
+ // calculate distance to backbone:
|
|
|
+ double currentDistSqr = QCPVector2D(pos).distanceSquaredToLine(QCPVector2D(valueAxis->coordToPixel(it->high), keyPixel), QCPVector2D(valueAxis->coordToPixel(it->low), keyPixel));
|
|
|
+ if (currentDistSqr < minDistSqr)
|
|
|
+ {
|
|
|
+ minDistSqr = currentDistSqr;
|
|
|
+ closestDataPoint = it;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return qSqrt(minDistSqr);
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ This method is a helper function for \ref selectTest. It is used to test for selection when the
|
|
|
+ chart style is \ref csCandlestick. It only tests against the data points between \a begin and \a
|
|
|
+ end.
|
|
|
+
|
|
|
+ Like \ref selectTest, this method returns the shortest distance of \a pos to the graphical
|
|
|
+ representation of the plottable, and \a closestDataPoint will point to the respective data point.
|
|
|
+*/
|
|
|
+double QCPFinancial::candlestickSelectTest(const QPointF &pos, const QCPFinancialDataContainer::const_iterator &begin, const QCPFinancialDataContainer::const_iterator &end, QCPFinancialDataContainer::const_iterator &closestDataPoint) const
|
|
|
+{
|
|
|
+ closestDataPoint = mDataContainer->constEnd();
|
|
|
+ QCPAxis *keyAxis = mKeyAxis.data();
|
|
|
+ QCPAxis *valueAxis = mValueAxis.data();
|
|
|
+ if (!keyAxis || !valueAxis) { qDebug() << Q_FUNC_INFO << "invalid key or value axis"; return -1; }
|
|
|
+
|
|
|
+ double minDistSqr = std::numeric_limits<double>::max();
|
|
|
+ if (keyAxis->orientation() == Qt::Horizontal)
|
|
|
+ {
|
|
|
+ for (QCPFinancialDataContainer::const_iterator it=begin; it!=end; ++it)
|
|
|
+ {
|
|
|
+ double currentDistSqr;
|
|
|
+ // determine whether pos is in open-close-box:
|
|
|
+ QCPRange boxKeyRange(it->key-mWidth*0.5, it->key+mWidth*0.5);
|
|
|
+ QCPRange boxValueRange(it->close, it->open);
|
|
|
+ double posKey, posValue;
|
|
|
+ pixelsToCoords(pos, posKey, posValue);
|
|
|
+ if (boxKeyRange.contains(posKey) && boxValueRange.contains(posValue)) // is in open-close-box
|
|
|
+ {
|
|
|
+ currentDistSqr = mParentPlot->selectionTolerance()*0.99 * mParentPlot->selectionTolerance()*0.99;
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ // calculate distance to high/low lines:
|
|
|
+ double keyPixel = keyAxis->coordToPixel(it->key);
|
|
|
+ double highLineDistSqr = QCPVector2D(pos).distanceSquaredToLine(QCPVector2D(keyPixel, valueAxis->coordToPixel(it->high)), QCPVector2D(keyPixel, valueAxis->coordToPixel(qMax(it->open, it->close))));
|
|
|
+ double lowLineDistSqr = QCPVector2D(pos).distanceSquaredToLine(QCPVector2D(keyPixel, valueAxis->coordToPixel(it->low)), QCPVector2D(keyPixel, valueAxis->coordToPixel(qMin(it->open, it->close))));
|
|
|
+ currentDistSqr = qMin(highLineDistSqr, lowLineDistSqr);
|
|
|
+ }
|
|
|
+ if (currentDistSqr < minDistSqr)
|
|
|
+ {
|
|
|
+ minDistSqr = currentDistSqr;
|
|
|
+ closestDataPoint = it;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } else // keyAxis->orientation() == Qt::Vertical
|
|
|
+ {
|
|
|
+ for (QCPFinancialDataContainer::const_iterator it=begin; it!=end; ++it)
|
|
|
+ {
|
|
|
+ double currentDistSqr;
|
|
|
+ // determine whether pos is in open-close-box:
|
|
|
+ QCPRange boxKeyRange(it->key-mWidth*0.5, it->key+mWidth*0.5);
|
|
|
+ QCPRange boxValueRange(it->close, it->open);
|
|
|
+ double posKey, posValue;
|
|
|
+ pixelsToCoords(pos, posKey, posValue);
|
|
|
+ if (boxKeyRange.contains(posKey) && boxValueRange.contains(posValue)) // is in open-close-box
|
|
|
+ {
|
|
|
+ currentDistSqr = mParentPlot->selectionTolerance()*0.99 * mParentPlot->selectionTolerance()*0.99;
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ // calculate distance to high/low lines:
|
|
|
+ double keyPixel = keyAxis->coordToPixel(it->key);
|
|
|
+ double highLineDistSqr = QCPVector2D(pos).distanceSquaredToLine(QCPVector2D(valueAxis->coordToPixel(it->high), keyPixel), QCPVector2D(valueAxis->coordToPixel(qMax(it->open, it->close)), keyPixel));
|
|
|
+ double lowLineDistSqr = QCPVector2D(pos).distanceSquaredToLine(QCPVector2D(valueAxis->coordToPixel(it->low), keyPixel), QCPVector2D(valueAxis->coordToPixel(qMin(it->open, it->close)), keyPixel));
|
|
|
+ currentDistSqr = qMin(highLineDistSqr, lowLineDistSqr);
|
|
|
+ }
|
|
|
+ if (currentDistSqr < minDistSqr)
|
|
|
+ {
|
|
|
+ minDistSqr = currentDistSqr;
|
|
|
+ closestDataPoint = it;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return qSqrt(minDistSqr);
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ called by the drawing methods to determine which data (key) range is visible at the current key
|
|
|
+ axis range setting, so only that needs to be processed.
|
|
|
+
|
|
|
+ \a begin returns an iterator to the lowest data point that needs to be taken into account when
|
|
|
+ plotting. Note that in order to get a clean plot all the way to the edge of the axis rect, \a
|
|
|
+ begin may still be just outside the visible range.
|
|
|
+
|
|
|
+ \a end returns the iterator just above the highest data point that needs to be taken into
|
|
|
+ account. Same as before, \a end may also lie just outside of the visible range
|
|
|
+
|
|
|
+ if the plottable contains no data, both \a begin and \a end point to \c constEnd.
|
|
|
+*/
|
|
|
+void QCPFinancial::getVisibleDataBounds(QCPFinancialDataContainer::const_iterator &begin, QCPFinancialDataContainer::const_iterator &end) const
|
|
|
+{
|
|
|
+ if (!mKeyAxis)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "invalid key axis";
|
|
|
+ begin = mDataContainer->constEnd();
|
|
|
+ end = mDataContainer->constEnd();
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ begin = mDataContainer->findBegin(mKeyAxis.data()->range().lower-mWidth*0.5); // subtract half width of ohlc/candlestick to include partially visible data points
|
|
|
+ end = mDataContainer->findEnd(mKeyAxis.data()->range().upper+mWidth*0.5); // add half width of ohlc/candlestick to include partially visible data points
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the hit box in pixel coordinates that will be used for data selection with the selection
|
|
|
+ rect (\ref selectTestRect), of the data point given by \a it.
|
|
|
+*/
|
|
|
+QRectF QCPFinancial::selectionHitBox(QCPFinancialDataContainer::const_iterator it) const
|
|
|
+{
|
|
|
+ QCPAxis *keyAxis = mKeyAxis.data();
|
|
|
+ QCPAxis *valueAxis = mValueAxis.data();
|
|
|
+ if (!keyAxis || !valueAxis) { qDebug() << Q_FUNC_INFO << "invalid key or value axis"; return QRectF(); }
|
|
|
+
|
|
|
+ double keyPixel = keyAxis->coordToPixel(it->key);
|
|
|
+ double highPixel = valueAxis->coordToPixel(it->high);
|
|
|
+ double lowPixel = valueAxis->coordToPixel(it->low);
|
|
|
+ double keyWidthPixels = keyPixel-keyAxis->coordToPixel(it->key-mWidth*0.5);
|
|
|
+ if (keyAxis->orientation() == Qt::Horizontal)
|
|
|
+ return QRectF(keyPixel-keyWidthPixels, highPixel, keyWidthPixels*2, lowPixel-highPixel).normalized();
|
|
|
+ else
|
|
|
+ return QRectF(highPixel, keyPixel-keyWidthPixels, lowPixel-highPixel, keyWidthPixels*2).normalized();
|
|
|
+}
|
|
|
+/* end of 'src/plottables/plottable-financial.cpp' */
|
|
|
+
|
|
|
+
|
|
|
+/* including file 'src/plottables/plottable-errorbar.cpp', size 37355 */
|
|
|
+/* commit 9868e55d3b412f2f89766bb482fcf299e93a0988 2017-09-04 01:56:22 +0200 */
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPErrorBarsData
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+/*! \class QCPErrorBarsData
|
|
|
+ \brief Holds the data of one single error bar for QCPErrorBars.
|
|
|
+
|
|
|
+ The stored data is:
|
|
|
+ \li \a errorMinus: how much the error bar extends towards negative coordinates from the data
|
|
|
+ point position
|
|
|
+ \li \a errorPlus: how much the error bar extends towards positive coordinates from the data point
|
|
|
+ position
|
|
|
+
|
|
|
+ The container for storing the error bar information is \ref QCPErrorBarsDataContainer. It is a
|
|
|
+ typedef for <tt>QVector<\ref QCPErrorBarsData></tt>.
|
|
|
+
|
|
|
+ \see QCPErrorBarsDataContainer
|
|
|
+*/
|
|
|
+
|
|
|
+/*!
|
|
|
+ Constructs an error bar with errors set to zero.
|
|
|
+*/
|
|
|
+QCPErrorBarsData::QCPErrorBarsData() :
|
|
|
+ errorMinus(0),
|
|
|
+ errorPlus(0)
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Constructs an error bar with equal \a error in both negative and positive direction.
|
|
|
+*/
|
|
|
+QCPErrorBarsData::QCPErrorBarsData(double error) :
|
|
|
+ errorMinus(error),
|
|
|
+ errorPlus(error)
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Constructs an error bar with negative and positive errors set to \a errorMinus and \a errorPlus,
|
|
|
+ respectively.
|
|
|
+*/
|
|
|
+QCPErrorBarsData::QCPErrorBarsData(double errorMinus, double errorPlus) :
|
|
|
+ errorMinus(errorMinus),
|
|
|
+ errorPlus(errorPlus)
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPErrorBars
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+/*! \class QCPErrorBars
|
|
|
+ \brief A plottable that adds a set of error bars to other plottables.
|
|
|
+
|
|
|
+ \image html QCPErrorBars.png
|
|
|
+
|
|
|
+ The \ref QCPErrorBars plottable can be attached to other one-dimensional plottables (e.g. \ref
|
|
|
+ QCPGraph, \ref QCPCurve, \ref QCPBars, etc.) and equips them with error bars.
|
|
|
+
|
|
|
+ Use \ref setDataPlottable to define for which plottable the \ref QCPErrorBars shall display the
|
|
|
+ error bars. The orientation of the error bars can be controlled with \ref setErrorType.
|
|
|
+
|
|
|
+ By using \ref setData, you can supply the actual error data, either as symmetric error or
|
|
|
+ plus/minus asymmetric errors. \ref QCPErrorBars only stores the error data. The absolute
|
|
|
+ key/value position of each error bar will be adopted from the configured data plottable. The
|
|
|
+ error data of the \ref QCPErrorBars are associated one-to-one via their index to the data points
|
|
|
+ of the data plottable. You can directly access and manipulate the error bar data via \ref data.
|
|
|
+
|
|
|
+ Set either of the plus/minus errors to NaN (<tt>qQNaN()</tt> or
|
|
|
+ <tt>std::numeric_limits<double>::quiet_NaN()</tt>) to not show the respective error bar on the data point at
|
|
|
+ that index.
|
|
|
+
|
|
|
+ \section qcperrorbars-appearance Changing the appearance
|
|
|
+
|
|
|
+ The appearance of the error bars is defined by the pen (\ref setPen), and the width of the
|
|
|
+ whiskers (\ref setWhiskerWidth). Further, the error bar backbones may leave a gap around the data
|
|
|
+ point center to prevent that error bars are drawn too close to or even through scatter points.
|
|
|
+ This gap size can be controlled via \ref setSymbolGap.
|
|
|
+*/
|
|
|
+
|
|
|
+/* start of documentation of inline functions */
|
|
|
+
|
|
|
+/*! \fn QSharedPointer<QCPErrorBarsDataContainer> QCPErrorBars::data() const
|
|
|
+
|
|
|
+ Returns a shared pointer to the internal data storage of type \ref QCPErrorBarsDataContainer. You
|
|
|
+ may use it to directly manipulate the error values, which may be more convenient and faster than
|
|
|
+ using the regular \ref setData methods.
|
|
|
+*/
|
|
|
+
|
|
|
+/* end of documentation of inline functions */
|
|
|
+
|
|
|
+/*!
|
|
|
+ Constructs an error bars plottable which uses \a keyAxis as its key axis ("x") and \a valueAxis as its value
|
|
|
+ axis ("y"). \a keyAxis and \a valueAxis must reside in the same QCustomPlot instance and not have
|
|
|
+ the same orientation. If either of these restrictions is violated, a corresponding message is
|
|
|
+ printed to the debug output (qDebug), the construction is not aborted, though.
|
|
|
+
|
|
|
+ It is also important that the \a keyAxis and \a valueAxis are the same for the error bars
|
|
|
+ plottable and the data plottable that the error bars shall be drawn on (\ref setDataPlottable).
|
|
|
+
|
|
|
+ The created \ref QCPErrorBars is automatically registered with the QCustomPlot instance inferred
|
|
|
+ from \a keyAxis. This QCustomPlot instance takes ownership of the \ref QCPErrorBars, so do not
|
|
|
+ delete it manually but use \ref QCustomPlot::removePlottable() instead.
|
|
|
+*/
|
|
|
+QCPErrorBars::QCPErrorBars(QCPAxis *keyAxis, QCPAxis *valueAxis) :
|
|
|
+ QCPAbstractPlottable(keyAxis, valueAxis),
|
|
|
+ mDataContainer(new QVector<QCPErrorBarsData>),
|
|
|
+ mErrorType(etValueError),
|
|
|
+ mWhiskerWidth(9),
|
|
|
+ mSymbolGap(10)
|
|
|
+{
|
|
|
+ setPen(QPen(Qt::black, 0));
|
|
|
+ setBrush(Qt::NoBrush);
|
|
|
+}
|
|
|
+
|
|
|
+QCPErrorBars::~QCPErrorBars()
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Replaces the current data container with the provided \a data container.
|
|
|
+
|
|
|
+ Since a QSharedPointer is used, multiple \ref QCPErrorBars instances may share the same data
|
|
|
+ container safely. Modifying the data in the container will then affect all \ref QCPErrorBars
|
|
|
+ instances that share the container. Sharing can be achieved by simply exchanging the data
|
|
|
+ containers wrapped in shared pointers:
|
|
|
+ \snippet documentation/doc-code-snippets/mainwindow.cpp qcperrorbars-datasharing-1
|
|
|
+
|
|
|
+ If you do not wish to share containers, but create a copy from an existing container, assign the
|
|
|
+ data containers directly:
|
|
|
+ \snippet documentation/doc-code-snippets/mainwindow.cpp qcperrorbars-datasharing-2
|
|
|
+ (This uses different notation compared with other plottables, because the \ref QCPErrorBars
|
|
|
+ uses a \c QVector<QCPErrorBarsData> as its data container, instead of a \ref QCPDataContainer.)
|
|
|
+
|
|
|
+ \see addData
|
|
|
+*/
|
|
|
+void QCPErrorBars::setData(QSharedPointer<QCPErrorBarsDataContainer> data)
|
|
|
+{
|
|
|
+ mDataContainer = data;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Sets symmetrical error values as specified in \a error. The errors will be associated one-to-one
|
|
|
+ by the data point index to the associated data plottable (\ref setDataPlottable).
|
|
|
+
|
|
|
+ You can directly access and manipulate the error bar data via \ref data.
|
|
|
+
|
|
|
+ \see addData
|
|
|
+*/
|
|
|
+void QCPErrorBars::setData(const QVector<double> &error)
|
|
|
+{
|
|
|
+ mDataContainer->clear();
|
|
|
+ addData(error);
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Sets asymmetrical errors as specified in \a errorMinus and \a errorPlus. The errors will be
|
|
|
+ associated one-to-one by the data point index to the associated data plottable (\ref
|
|
|
+ setDataPlottable).
|
|
|
+
|
|
|
+ You can directly access and manipulate the error bar data via \ref data.
|
|
|
+
|
|
|
+ \see addData
|
|
|
+*/
|
|
|
+void QCPErrorBars::setData(const QVector<double> &errorMinus, const QVector<double> &errorPlus)
|
|
|
+{
|
|
|
+ mDataContainer->clear();
|
|
|
+ addData(errorMinus, errorPlus);
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the data plottable to which the error bars will be applied. The error values specified e.g.
|
|
|
+ via \ref setData will be associated one-to-one by the data point index to the data points of \a
|
|
|
+ plottable. This means that the error bars will adopt the key/value coordinates of the data point
|
|
|
+ with the same index.
|
|
|
+
|
|
|
+ The passed \a plottable must be a one-dimensional plottable, i.e. it must implement the \ref
|
|
|
+ QCPPlottableInterface1D. Further, it must not be a \ref QCPErrorBars instance itself. If either
|
|
|
+ of these restrictions is violated, a corresponding qDebug output is generated, and the data
|
|
|
+ plottable of this \ref QCPErrorBars instance is set to zero.
|
|
|
+
|
|
|
+ For proper display, care must also be taken that the key and value axes of the \a plottable match
|
|
|
+ those configured for this \ref QCPErrorBars instance.
|
|
|
+*/
|
|
|
+void QCPErrorBars::setDataPlottable(QCPAbstractPlottable *plottable)
|
|
|
+{
|
|
|
+ if (plottable && qobject_cast<QCPErrorBars*>(plottable))
|
|
|
+ {
|
|
|
+ mDataPlottable = 0;
|
|
|
+ qDebug() << Q_FUNC_INFO << "can't set another QCPErrorBars instance as data plottable";
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ if (plottable && !plottable->interface1D())
|
|
|
+ {
|
|
|
+ mDataPlottable = 0;
|
|
|
+ qDebug() << Q_FUNC_INFO << "passed plottable doesn't implement 1d interface, can't associate with QCPErrorBars";
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ mDataPlottable = plottable;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets in which orientation the error bars shall appear on the data points. If your data needs both
|
|
|
+ error dimensions, create two \ref QCPErrorBars with different \a type.
|
|
|
+*/
|
|
|
+void QCPErrorBars::setErrorType(ErrorType type)
|
|
|
+{
|
|
|
+ mErrorType = type;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the width of the whiskers (the short bars at the end of the actual error bar backbones) to
|
|
|
+ \a pixels.
|
|
|
+*/
|
|
|
+void QCPErrorBars::setWhiskerWidth(double pixels)
|
|
|
+{
|
|
|
+ mWhiskerWidth = pixels;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the gap diameter around the data points that will be left out when drawing the error bar
|
|
|
+ backbones. This gap prevents that error bars are drawn too close to or even through scatter
|
|
|
+ points.
|
|
|
+*/
|
|
|
+void QCPErrorBars::setSymbolGap(double pixels)
|
|
|
+{
|
|
|
+ mSymbolGap = pixels;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Adds symmetrical error values as specified in \a error. The errors will be associated one-to-one
|
|
|
+ by the data point index to the associated data plottable (\ref setDataPlottable).
|
|
|
+
|
|
|
+ You can directly access and manipulate the error bar data via \ref data.
|
|
|
+
|
|
|
+ \see setData
|
|
|
+*/
|
|
|
+void QCPErrorBars::addData(const QVector<double> &error)
|
|
|
+{
|
|
|
+ addData(error, error);
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Adds asymmetrical errors as specified in \a errorMinus and \a errorPlus. The errors will be
|
|
|
+ associated one-to-one by the data point index to the associated data plottable (\ref
|
|
|
+ setDataPlottable).
|
|
|
+
|
|
|
+ You can directly access and manipulate the error bar data via \ref data.
|
|
|
+
|
|
|
+ \see setData
|
|
|
+*/
|
|
|
+void QCPErrorBars::addData(const QVector<double> &errorMinus, const QVector<double> &errorPlus)
|
|
|
+{
|
|
|
+ if (errorMinus.size() != errorPlus.size())
|
|
|
+ qDebug() << Q_FUNC_INFO << "minus and plus error vectors have different sizes:" << errorMinus.size() << errorPlus.size();
|
|
|
+ const int n = qMin(errorMinus.size(), errorPlus.size());
|
|
|
+ mDataContainer->reserve(n);
|
|
|
+ for (int i=0; i<n; ++i)
|
|
|
+ mDataContainer->append(QCPErrorBarsData(errorMinus.at(i), errorPlus.at(i)));
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Adds a single symmetrical error bar as specified in \a error. The errors will be associated
|
|
|
+ one-to-one by the data point index to the associated data plottable (\ref setDataPlottable).
|
|
|
+
|
|
|
+ You can directly access and manipulate the error bar data via \ref data.
|
|
|
+
|
|
|
+ \see setData
|
|
|
+*/
|
|
|
+void QCPErrorBars::addData(double error)
|
|
|
+{
|
|
|
+ mDataContainer->append(QCPErrorBarsData(error));
|
|
|
+}
|
|
|
+
|
|
|
+/*! \overload
|
|
|
+
|
|
|
+ Adds a single asymmetrical error bar as specified in \a errorMinus and \a errorPlus. The errors
|
|
|
+ will be associated one-to-one by the data point index to the associated data plottable (\ref
|
|
|
+ setDataPlottable).
|
|
|
+
|
|
|
+ You can directly access and manipulate the error bar data via \ref data.
|
|
|
+
|
|
|
+ \see setData
|
|
|
+*/
|
|
|
+void QCPErrorBars::addData(double errorMinus, double errorPlus)
|
|
|
+{
|
|
|
+ mDataContainer->append(QCPErrorBarsData(errorMinus, errorPlus));
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+int QCPErrorBars::dataCount() const
|
|
|
+{
|
|
|
+ return mDataContainer->size();
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+double QCPErrorBars::dataMainKey(int index) const
|
|
|
+{
|
|
|
+ if (mDataPlottable)
|
|
|
+ return mDataPlottable->interface1D()->dataMainKey(index);
|
|
|
+ else
|
|
|
+ qDebug() << Q_FUNC_INFO << "no data plottable set";
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+double QCPErrorBars::dataSortKey(int index) const
|
|
|
+{
|
|
|
+ if (mDataPlottable)
|
|
|
+ return mDataPlottable->interface1D()->dataSortKey(index);
|
|
|
+ else
|
|
|
+ qDebug() << Q_FUNC_INFO << "no data plottable set";
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+double QCPErrorBars::dataMainValue(int index) const
|
|
|
+{
|
|
|
+ if (mDataPlottable)
|
|
|
+ return mDataPlottable->interface1D()->dataMainValue(index);
|
|
|
+ else
|
|
|
+ qDebug() << Q_FUNC_INFO << "no data plottable set";
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+QCPRange QCPErrorBars::dataValueRange(int index) const
|
|
|
+{
|
|
|
+ if (mDataPlottable)
|
|
|
+ {
|
|
|
+ const double value = mDataPlottable->interface1D()->dataMainValue(index);
|
|
|
+ if (index >= 0 && index < mDataContainer->size() && mErrorType == etValueError)
|
|
|
+ return QCPRange(value-mDataContainer->at(index).errorMinus, value+mDataContainer->at(index).errorPlus);
|
|
|
+ else
|
|
|
+ return QCPRange(value, value);
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "no data plottable set";
|
|
|
+ return QCPRange();
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+QPointF QCPErrorBars::dataPixelPosition(int index) const
|
|
|
+{
|
|
|
+ if (mDataPlottable)
|
|
|
+ return mDataPlottable->interface1D()->dataPixelPosition(index);
|
|
|
+ else
|
|
|
+ qDebug() << Q_FUNC_INFO << "no data plottable set";
|
|
|
+ return QPointF();
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+bool QCPErrorBars::sortKeyIsMainKey() const
|
|
|
+{
|
|
|
+ if (mDataPlottable)
|
|
|
+ {
|
|
|
+ return mDataPlottable->interface1D()->sortKeyIsMainKey();
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "no data plottable set";
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ \copydoc QCPPlottableInterface1D::selectTestRect
|
|
|
+*/
|
|
|
+QCPDataSelection QCPErrorBars::selectTestRect(const QRectF &rect, bool onlySelectable) const
|
|
|
+{
|
|
|
+ QCPDataSelection result;
|
|
|
+ if (!mDataPlottable)
|
|
|
+ return result;
|
|
|
+ if ((onlySelectable && mSelectable == QCP::stNone) || mDataContainer->isEmpty())
|
|
|
+ return result;
|
|
|
+ if (!mKeyAxis || !mValueAxis)
|
|
|
+ return result;
|
|
|
+
|
|
|
+ QCPErrorBarsDataContainer::const_iterator visibleBegin, visibleEnd;
|
|
|
+ getVisibleDataBounds(visibleBegin, visibleEnd, QCPDataRange(0, dataCount()));
|
|
|
+
|
|
|
+ QVector<QLineF> backbones, whiskers;
|
|
|
+ for (QCPErrorBarsDataContainer::const_iterator it=visibleBegin; it!=visibleEnd; ++it)
|
|
|
+ {
|
|
|
+ backbones.clear();
|
|
|
+ whiskers.clear();
|
|
|
+ getErrorBarLines(it, backbones, whiskers);
|
|
|
+ for (int i=0; i<backbones.size(); ++i)
|
|
|
+ {
|
|
|
+ if (rectIntersectsLine(rect, backbones.at(i)))
|
|
|
+ {
|
|
|
+ result.addDataRange(QCPDataRange(it-mDataContainer->constBegin(), it-mDataContainer->constBegin()+1), false);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ result.simplify();
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+int QCPErrorBars::findBegin(double sortKey, bool expandedRange) const
|
|
|
+{
|
|
|
+ if (mDataPlottable)
|
|
|
+ {
|
|
|
+ if (mDataContainer->isEmpty())
|
|
|
+ return 0;
|
|
|
+ int beginIndex = mDataPlottable->interface1D()->findBegin(sortKey, expandedRange);
|
|
|
+ if (beginIndex >= mDataContainer->size())
|
|
|
+ beginIndex = mDataContainer->size()-1;
|
|
|
+ return beginIndex;
|
|
|
+ } else
|
|
|
+ qDebug() << Q_FUNC_INFO << "no data plottable set";
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+int QCPErrorBars::findEnd(double sortKey, bool expandedRange) const
|
|
|
+{
|
|
|
+ if (mDataPlottable)
|
|
|
+ {
|
|
|
+ if (mDataContainer->isEmpty())
|
|
|
+ return 0;
|
|
|
+ int endIndex = mDataPlottable->interface1D()->findEnd(sortKey, expandedRange);
|
|
|
+ if (endIndex > mDataContainer->size())
|
|
|
+ endIndex = mDataContainer->size();
|
|
|
+ return endIndex;
|
|
|
+ } else
|
|
|
+ qDebug() << Q_FUNC_INFO << "no data plottable set";
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+double QCPErrorBars::selectTest(const QPointF &pos, bool onlySelectable, QVariant *details) const
|
|
|
+{
|
|
|
+ if (!mDataPlottable) return -1;
|
|
|
+
|
|
|
+ if ((onlySelectable && mSelectable == QCP::stNone) || mDataContainer->isEmpty())
|
|
|
+ return -1;
|
|
|
+ if (!mKeyAxis || !mValueAxis)
|
|
|
+ return -1;
|
|
|
+
|
|
|
+ if (mKeyAxis.data()->axisRect()->rect().contains(pos.toPoint()))
|
|
|
+ {
|
|
|
+ QCPErrorBarsDataContainer::const_iterator closestDataPoint = mDataContainer->constEnd();
|
|
|
+ double result = pointDistance(pos, closestDataPoint);
|
|
|
+ if (details)
|
|
|
+ {
|
|
|
+ int pointIndex = closestDataPoint-mDataContainer->constBegin();
|
|
|
+ details->setValue(QCPDataSelection(QCPDataRange(pointIndex, pointIndex+1)));
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+ } else
|
|
|
+ return -1;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPErrorBars::draw(QCPPainter *painter)
|
|
|
+{
|
|
|
+ if (!mDataPlottable) return;
|
|
|
+ if (!mKeyAxis || !mValueAxis) { qDebug() << Q_FUNC_INFO << "invalid key or value axis"; return; }
|
|
|
+ if (mKeyAxis.data()->range().size() <= 0 || mDataContainer->isEmpty()) return;
|
|
|
+
|
|
|
+ // if the sort key isn't the main key, we must check the visibility for each data point/error bar individually
|
|
|
+ // (getVisibleDataBounds applies range restriction, but otherwise can only return full data range):
|
|
|
+ bool checkPointVisibility = !mDataPlottable->interface1D()->sortKeyIsMainKey();
|
|
|
+
|
|
|
+ // check data validity if flag set:
|
|
|
+#ifdef QCUSTOMPLOT_CHECK_DATA
|
|
|
+ QCPErrorBarsDataContainer::const_iterator it;
|
|
|
+ for (it = mDataContainer->constBegin(); it != mDataContainer->constEnd(); ++it)
|
|
|
+ {
|
|
|
+ if (QCP::isInvalidData(it->errorMinus, it->errorPlus))
|
|
|
+ qDebug() << Q_FUNC_INFO << "Data point at index" << it-mDataContainer->constBegin() << "invalid." << "Plottable name:" << name();
|
|
|
+ }
|
|
|
+#endif
|
|
|
+
|
|
|
+ applyDefaultAntialiasingHint(painter);
|
|
|
+ painter->setBrush(Qt::NoBrush);
|
|
|
+ // loop over and draw segments of unselected/selected data:
|
|
|
+ QList<QCPDataRange> selectedSegments, unselectedSegments, allSegments;
|
|
|
+ getDataSegments(selectedSegments, unselectedSegments);
|
|
|
+ allSegments << unselectedSegments << selectedSegments;
|
|
|
+ QVector<QLineF> backbones, whiskers;
|
|
|
+ for (int i=0; i<allSegments.size(); ++i)
|
|
|
+ {
|
|
|
+ QCPErrorBarsDataContainer::const_iterator begin, end;
|
|
|
+ getVisibleDataBounds(begin, end, allSegments.at(i));
|
|
|
+ if (begin == end)
|
|
|
+ continue;
|
|
|
+
|
|
|
+ bool isSelectedSegment = i >= unselectedSegments.size();
|
|
|
+ if (isSelectedSegment && mSelectionDecorator)
|
|
|
+ mSelectionDecorator->applyPen(painter);
|
|
|
+ else
|
|
|
+ painter->setPen(mPen);
|
|
|
+ if (painter->pen().capStyle() == Qt::SquareCap)
|
|
|
+ {
|
|
|
+ QPen capFixPen(painter->pen());
|
|
|
+ capFixPen.setCapStyle(Qt::FlatCap);
|
|
|
+ painter->setPen(capFixPen);
|
|
|
+ }
|
|
|
+ backbones.clear();
|
|
|
+ whiskers.clear();
|
|
|
+ for (QCPErrorBarsDataContainer::const_iterator it=begin; it!=end; ++it)
|
|
|
+ {
|
|
|
+ if (!checkPointVisibility || errorBarVisible(it-mDataContainer->constBegin()))
|
|
|
+ getErrorBarLines(it, backbones, whiskers);
|
|
|
+ }
|
|
|
+ painter->drawLines(backbones);
|
|
|
+ painter->drawLines(whiskers);
|
|
|
+ }
|
|
|
+
|
|
|
+ // draw other selection decoration that isn't just line/scatter pens and brushes:
|
|
|
+ if (mSelectionDecorator)
|
|
|
+ mSelectionDecorator->drawDecoration(painter, selection());
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPErrorBars::drawLegendIcon(QCPPainter *painter, const QRectF &rect) const
|
|
|
+{
|
|
|
+ applyDefaultAntialiasingHint(painter);
|
|
|
+ painter->setPen(mPen);
|
|
|
+ if (mErrorType == etValueError && mValueAxis && mValueAxis->orientation() == Qt::Vertical)
|
|
|
+ {
|
|
|
+ painter->drawLine(QLineF(rect.center().x(), rect.top()+2, rect.center().x(), rect.bottom()-1));
|
|
|
+ painter->drawLine(QLineF(rect.center().x()-4, rect.top()+2, rect.center().x()+4, rect.top()+2));
|
|
|
+ painter->drawLine(QLineF(rect.center().x()-4, rect.bottom()-1, rect.center().x()+4, rect.bottom()-1));
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ painter->drawLine(QLineF(rect.left()+2, rect.center().y(), rect.right()-2, rect.center().y()));
|
|
|
+ painter->drawLine(QLineF(rect.left()+2, rect.center().y()-4, rect.left()+2, rect.center().y()+4));
|
|
|
+ painter->drawLine(QLineF(rect.right()-2, rect.center().y()-4, rect.right()-2, rect.center().y()+4));
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+QCPRange QCPErrorBars::getKeyRange(bool &foundRange, QCP::SignDomain inSignDomain) const
|
|
|
+{
|
|
|
+ if (!mDataPlottable)
|
|
|
+ {
|
|
|
+ foundRange = false;
|
|
|
+ return QCPRange();
|
|
|
+ }
|
|
|
+
|
|
|
+ QCPRange range;
|
|
|
+ bool haveLower = false;
|
|
|
+ bool haveUpper = false;
|
|
|
+ QCPErrorBarsDataContainer::const_iterator it;
|
|
|
+ for (it = mDataContainer->constBegin(); it != mDataContainer->constEnd(); ++it)
|
|
|
+ {
|
|
|
+ if (mErrorType == etValueError)
|
|
|
+ {
|
|
|
+ // error bar doesn't extend in key dimension (except whisker but we ignore that here), so only use data point center
|
|
|
+ const double current = mDataPlottable->interface1D()->dataMainKey(it-mDataContainer->constBegin());
|
|
|
+ if (qIsNaN(current)) continue;
|
|
|
+ if (inSignDomain == QCP::sdBoth || (inSignDomain == QCP::sdNegative && current < 0) || (inSignDomain == QCP::sdPositive && current > 0))
|
|
|
+ {
|
|
|
+ if (current < range.lower || !haveLower)
|
|
|
+ {
|
|
|
+ range.lower = current;
|
|
|
+ haveLower = true;
|
|
|
+ }
|
|
|
+ if (current > range.upper || !haveUpper)
|
|
|
+ {
|
|
|
+ range.upper = current;
|
|
|
+ haveUpper = true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } else // mErrorType == etKeyError
|
|
|
+ {
|
|
|
+ const double dataKey = mDataPlottable->interface1D()->dataMainKey(it-mDataContainer->constBegin());
|
|
|
+ if (qIsNaN(dataKey)) continue;
|
|
|
+ // plus error:
|
|
|
+ double current = dataKey + (qIsNaN(it->errorPlus) ? 0 : it->errorPlus);
|
|
|
+ if (inSignDomain == QCP::sdBoth || (inSignDomain == QCP::sdNegative && current < 0) || (inSignDomain == QCP::sdPositive && current > 0))
|
|
|
+ {
|
|
|
+ if (current > range.upper || !haveUpper)
|
|
|
+ {
|
|
|
+ range.upper = current;
|
|
|
+ haveUpper = true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ // minus error:
|
|
|
+ current = dataKey - (qIsNaN(it->errorMinus) ? 0 : it->errorMinus);
|
|
|
+ if (inSignDomain == QCP::sdBoth || (inSignDomain == QCP::sdNegative && current < 0) || (inSignDomain == QCP::sdPositive && current > 0))
|
|
|
+ {
|
|
|
+ if (current < range.lower || !haveLower)
|
|
|
+ {
|
|
|
+ range.lower = current;
|
|
|
+ haveLower = true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (haveUpper && !haveLower)
|
|
|
+ {
|
|
|
+ range.lower = range.upper;
|
|
|
+ haveLower = true;
|
|
|
+ } else if (haveLower && !haveUpper)
|
|
|
+ {
|
|
|
+ range.upper = range.lower;
|
|
|
+ haveUpper = true;
|
|
|
+ }
|
|
|
+
|
|
|
+ foundRange = haveLower && haveUpper;
|
|
|
+ return range;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+QCPRange QCPErrorBars::getValueRange(bool &foundRange, QCP::SignDomain inSignDomain, const QCPRange &inKeyRange) const
|
|
|
+{
|
|
|
+ if (!mDataPlottable)
|
|
|
+ {
|
|
|
+ foundRange = false;
|
|
|
+ return QCPRange();
|
|
|
+ }
|
|
|
+
|
|
|
+ QCPRange range;
|
|
|
+ const bool restrictKeyRange = inKeyRange != QCPRange();
|
|
|
+ bool haveLower = false;
|
|
|
+ bool haveUpper = false;
|
|
|
+ QCPErrorBarsDataContainer::const_iterator itBegin = mDataContainer->constBegin();
|
|
|
+ QCPErrorBarsDataContainer::const_iterator itEnd = mDataContainer->constEnd();
|
|
|
+ if (mDataPlottable->interface1D()->sortKeyIsMainKey() && restrictKeyRange)
|
|
|
+ {
|
|
|
+ itBegin = mDataContainer->constBegin()+findBegin(inKeyRange.lower);
|
|
|
+ itEnd = mDataContainer->constBegin()+findEnd(inKeyRange.upper);
|
|
|
+ }
|
|
|
+ for (QCPErrorBarsDataContainer::const_iterator it = itBegin; it != itEnd; ++it)
|
|
|
+ {
|
|
|
+ if (restrictKeyRange)
|
|
|
+ {
|
|
|
+ const double dataKey = mDataPlottable->interface1D()->dataMainKey(it-mDataContainer->constBegin());
|
|
|
+ if (dataKey < inKeyRange.lower || dataKey > inKeyRange.upper)
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ if (mErrorType == etValueError)
|
|
|
+ {
|
|
|
+ const double dataValue = mDataPlottable->interface1D()->dataMainValue(it-mDataContainer->constBegin());
|
|
|
+ if (qIsNaN(dataValue)) continue;
|
|
|
+ // plus error:
|
|
|
+ double current = dataValue + (qIsNaN(it->errorPlus) ? 0 : it->errorPlus);
|
|
|
+ if (inSignDomain == QCP::sdBoth || (inSignDomain == QCP::sdNegative && current < 0) || (inSignDomain == QCP::sdPositive && current > 0))
|
|
|
+ {
|
|
|
+ if (current > range.upper || !haveUpper)
|
|
|
+ {
|
|
|
+ range.upper = current;
|
|
|
+ haveUpper = true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ // minus error:
|
|
|
+ current = dataValue - (qIsNaN(it->errorMinus) ? 0 : it->errorMinus);
|
|
|
+ if (inSignDomain == QCP::sdBoth || (inSignDomain == QCP::sdNegative && current < 0) || (inSignDomain == QCP::sdPositive && current > 0))
|
|
|
+ {
|
|
|
+ if (current < range.lower || !haveLower)
|
|
|
+ {
|
|
|
+ range.lower = current;
|
|
|
+ haveLower = true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } else // mErrorType == etKeyError
|
|
|
+ {
|
|
|
+ // error bar doesn't extend in value dimension (except whisker but we ignore that here), so only use data point center
|
|
|
+ const double current = mDataPlottable->interface1D()->dataMainValue(it-mDataContainer->constBegin());
|
|
|
+ if (qIsNaN(current)) continue;
|
|
|
+ if (inSignDomain == QCP::sdBoth || (inSignDomain == QCP::sdNegative && current < 0) || (inSignDomain == QCP::sdPositive && current > 0))
|
|
|
+ {
|
|
|
+ if (current < range.lower || !haveLower)
|
|
|
+ {
|
|
|
+ range.lower = current;
|
|
|
+ haveLower = true;
|
|
|
+ }
|
|
|
+ if (current > range.upper || !haveUpper)
|
|
|
+ {
|
|
|
+ range.upper = current;
|
|
|
+ haveUpper = true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (haveUpper && !haveLower)
|
|
|
+ {
|
|
|
+ range.lower = range.upper;
|
|
|
+ haveLower = true;
|
|
|
+ } else if (haveLower && !haveUpper)
|
|
|
+ {
|
|
|
+ range.upper = range.lower;
|
|
|
+ haveUpper = true;
|
|
|
+ }
|
|
|
+
|
|
|
+ foundRange = haveLower && haveUpper;
|
|
|
+ return range;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Calculates the lines that make up the error bar belonging to the data point \a it.
|
|
|
+
|
|
|
+ The resulting lines are added to \a backbones and \a whiskers. The vectors are not cleared, so
|
|
|
+ calling this method with different \a it but the same \a backbones and \a whiskers allows to
|
|
|
+ accumulate lines for multiple data points.
|
|
|
+
|
|
|
+ This method assumes that \a it is a valid iterator within the bounds of this \ref QCPErrorBars
|
|
|
+ instance and within the bounds of the associated data plottable.
|
|
|
+*/
|
|
|
+void QCPErrorBars::getErrorBarLines(QCPErrorBarsDataContainer::const_iterator it, QVector<QLineF> &backbones, QVector<QLineF> &whiskers) const
|
|
|
+{
|
|
|
+ if (!mDataPlottable) return;
|
|
|
+
|
|
|
+ int index = it-mDataContainer->constBegin();
|
|
|
+ QPointF centerPixel = mDataPlottable->interface1D()->dataPixelPosition(index);
|
|
|
+ if (qIsNaN(centerPixel.x()) || qIsNaN(centerPixel.y()))
|
|
|
+ return;
|
|
|
+ QCPAxis *errorAxis = mErrorType == etValueError ? mValueAxis.data() : mKeyAxis.data();
|
|
|
+ QCPAxis *orthoAxis = mErrorType == etValueError ? mKeyAxis.data() : mValueAxis.data();
|
|
|
+ const double centerErrorAxisPixel = errorAxis->orientation() == Qt::Horizontal ? centerPixel.x() : centerPixel.y();
|
|
|
+ const double centerOrthoAxisPixel = orthoAxis->orientation() == Qt::Horizontal ? centerPixel.x() : centerPixel.y();
|
|
|
+ const double centerErrorAxisCoord = errorAxis->pixelToCoord(centerErrorAxisPixel); // depending on plottable, this might be different from just mDataPlottable->interface1D()->dataMainKey/Value
|
|
|
+ const double symbolGap = mSymbolGap*0.5*errorAxis->pixelOrientation();
|
|
|
+ // plus error:
|
|
|
+ double errorStart, errorEnd;
|
|
|
+ if (!qIsNaN(it->errorPlus))
|
|
|
+ {
|
|
|
+ errorStart = centerErrorAxisPixel+symbolGap;
|
|
|
+ errorEnd = errorAxis->coordToPixel(centerErrorAxisCoord+it->errorPlus);
|
|
|
+ if (errorAxis->orientation() == Qt::Vertical)
|
|
|
+ {
|
|
|
+ if ((errorStart > errorEnd) != errorAxis->rangeReversed())
|
|
|
+ backbones.append(QLineF(centerOrthoAxisPixel, errorStart, centerOrthoAxisPixel, errorEnd));
|
|
|
+ whiskers.append(QLineF(centerOrthoAxisPixel-mWhiskerWidth*0.5, errorEnd, centerOrthoAxisPixel+mWhiskerWidth*0.5, errorEnd));
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ if ((errorStart < errorEnd) != errorAxis->rangeReversed())
|
|
|
+ backbones.append(QLineF(errorStart, centerOrthoAxisPixel, errorEnd, centerOrthoAxisPixel));
|
|
|
+ whiskers.append(QLineF(errorEnd, centerOrthoAxisPixel-mWhiskerWidth*0.5, errorEnd, centerOrthoAxisPixel+mWhiskerWidth*0.5));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ // minus error:
|
|
|
+ if (!qIsNaN(it->errorMinus))
|
|
|
+ {
|
|
|
+ errorStart = centerErrorAxisPixel-symbolGap;
|
|
|
+ errorEnd = errorAxis->coordToPixel(centerErrorAxisCoord-it->errorMinus);
|
|
|
+ if (errorAxis->orientation() == Qt::Vertical)
|
|
|
+ {
|
|
|
+ if ((errorStart < errorEnd) != errorAxis->rangeReversed())
|
|
|
+ backbones.append(QLineF(centerOrthoAxisPixel, errorStart, centerOrthoAxisPixel, errorEnd));
|
|
|
+ whiskers.append(QLineF(centerOrthoAxisPixel-mWhiskerWidth*0.5, errorEnd, centerOrthoAxisPixel+mWhiskerWidth*0.5, errorEnd));
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ if ((errorStart > errorEnd) != errorAxis->rangeReversed())
|
|
|
+ backbones.append(QLineF(errorStart, centerOrthoAxisPixel, errorEnd, centerOrthoAxisPixel));
|
|
|
+ whiskers.append(QLineF(errorEnd, centerOrthoAxisPixel-mWhiskerWidth*0.5, errorEnd, centerOrthoAxisPixel+mWhiskerWidth*0.5));
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ This method outputs the currently visible data range via \a begin and \a end. The returned range
|
|
|
+ will also never exceed \a rangeRestriction.
|
|
|
+
|
|
|
+ Since error bars with type \ref etKeyError may extend to arbitrarily positive and negative key
|
|
|
+ coordinates relative to their data point key, this method checks all outer error bars whether
|
|
|
+ they truly don't reach into the visible portion of the axis rect, by calling \ref
|
|
|
+ errorBarVisible. On the other hand error bars with type \ref etValueError that are associated
|
|
|
+ with data plottables whose sort key is equal to the main key (see \ref qcpdatacontainer-datatype
|
|
|
+ "QCPDataContainer DataType") can be handled very efficiently by finding the visible range of
|
|
|
+ error bars through binary search (\ref QCPPlottableInterface1D::findBegin and \ref
|
|
|
+ QCPPlottableInterface1D::findEnd).
|
|
|
+
|
|
|
+ If the plottable's sort key is not equal to the main key, this method returns the full data
|
|
|
+ range, only restricted by \a rangeRestriction. Drawing optimization then has to be done on a
|
|
|
+ point-by-point basis in the \ref draw method.
|
|
|
+*/
|
|
|
+void QCPErrorBars::getVisibleDataBounds(QCPErrorBarsDataContainer::const_iterator &begin, QCPErrorBarsDataContainer::const_iterator &end, const QCPDataRange &rangeRestriction) const
|
|
|
+{
|
|
|
+ QCPAxis *keyAxis = mKeyAxis.data();
|
|
|
+ QCPAxis *valueAxis = mValueAxis.data();
|
|
|
+ if (!keyAxis || !valueAxis)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "invalid key or value axis";
|
|
|
+ end = mDataContainer->constEnd();
|
|
|
+ begin = end;
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ if (!mDataPlottable || rangeRestriction.isEmpty())
|
|
|
+ {
|
|
|
+ end = mDataContainer->constEnd();
|
|
|
+ begin = end;
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ if (!mDataPlottable->interface1D()->sortKeyIsMainKey())
|
|
|
+ {
|
|
|
+ // if the sort key isn't the main key, it's not possible to find a contiguous range of visible
|
|
|
+ // data points, so this method then only applies the range restriction and otherwise returns
|
|
|
+ // the full data range. Visibility checks must be done on a per-datapoin-basis during drawing
|
|
|
+ QCPDataRange dataRange(0, mDataContainer->size());
|
|
|
+ dataRange = dataRange.bounded(rangeRestriction);
|
|
|
+ begin = mDataContainer->constBegin()+dataRange.begin();
|
|
|
+ end = mDataContainer->constBegin()+dataRange.end();
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ // get visible data range via interface from data plottable, and then restrict to available error data points:
|
|
|
+ const int n = qMin(mDataContainer->size(), mDataPlottable->interface1D()->dataCount());
|
|
|
+ int beginIndex = mDataPlottable->interface1D()->findBegin(keyAxis->range().lower);
|
|
|
+ int endIndex = mDataPlottable->interface1D()->findEnd(keyAxis->range().upper);
|
|
|
+ int i = beginIndex;
|
|
|
+ while (i > 0 && i < n && i > rangeRestriction.begin())
|
|
|
+ {
|
|
|
+ if (errorBarVisible(i))
|
|
|
+ beginIndex = i;
|
|
|
+ --i;
|
|
|
+ }
|
|
|
+ i = endIndex;
|
|
|
+ while (i >= 0 && i < n && i < rangeRestriction.end())
|
|
|
+ {
|
|
|
+ if (errorBarVisible(i))
|
|
|
+ endIndex = i+1;
|
|
|
+ ++i;
|
|
|
+ }
|
|
|
+ QCPDataRange dataRange(beginIndex, endIndex);
|
|
|
+ dataRange = dataRange.bounded(rangeRestriction.bounded(QCPDataRange(0, mDataContainer->size())));
|
|
|
+ begin = mDataContainer->constBegin()+dataRange.begin();
|
|
|
+ end = mDataContainer->constBegin()+dataRange.end();
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Calculates the minimum distance in pixels the error bars' representation has from the given \a
|
|
|
+ pixelPoint. This is used to determine whether the error bar was clicked or not, e.g. in \ref
|
|
|
+ selectTest. The closest data point to \a pixelPoint is returned in \a closestData.
|
|
|
+*/
|
|
|
+double QCPErrorBars::pointDistance(const QPointF &pixelPoint, QCPErrorBarsDataContainer::const_iterator &closestData) const
|
|
|
+{
|
|
|
+ closestData = mDataContainer->constEnd();
|
|
|
+ if (!mDataPlottable || mDataContainer->isEmpty())
|
|
|
+ return -1.0;
|
|
|
+ if (!mKeyAxis || !mValueAxis)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "invalid key or value axis";
|
|
|
+ return -1.0;
|
|
|
+ }
|
|
|
+
|
|
|
+ QCPErrorBarsDataContainer::const_iterator begin, end;
|
|
|
+ getVisibleDataBounds(begin, end, QCPDataRange(0, dataCount()));
|
|
|
+
|
|
|
+ // calculate minimum distances to error backbones (whiskers are ignored for speed) and find closestData iterator:
|
|
|
+ double minDistSqr = std::numeric_limits<double>::max();
|
|
|
+ QVector<QLineF> backbones, whiskers;
|
|
|
+ for (QCPErrorBarsDataContainer::const_iterator it=begin; it!=end; ++it)
|
|
|
+ {
|
|
|
+ getErrorBarLines(it, backbones, whiskers);
|
|
|
+ for (int i=0; i<backbones.size(); ++i)
|
|
|
+ {
|
|
|
+ const double currentDistSqr = QCPVector2D(pixelPoint).distanceSquaredToLine(backbones.at(i));
|
|
|
+ if (currentDistSqr < minDistSqr)
|
|
|
+ {
|
|
|
+ minDistSqr = currentDistSqr;
|
|
|
+ closestData = it;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return qSqrt(minDistSqr);
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ \note This method is identical to \ref QCPAbstractPlottable1D::getDataSegments but needs to be
|
|
|
+ reproduced here since the \ref QCPErrorBars plottable, as a special case that doesn't have its
|
|
|
+ own key/value data coordinates, doesn't derive from \ref QCPAbstractPlottable1D. See the
|
|
|
+ documentation there for details.
|
|
|
+*/
|
|
|
+void QCPErrorBars::getDataSegments(QList<QCPDataRange> &selectedSegments, QList<QCPDataRange> &unselectedSegments) const
|
|
|
+{
|
|
|
+ selectedSegments.clear();
|
|
|
+ unselectedSegments.clear();
|
|
|
+ if (mSelectable == QCP::stWhole) // stWhole selection type draws the entire plottable with selected style if mSelection isn't empty
|
|
|
+ {
|
|
|
+ if (selected())
|
|
|
+ selectedSegments << QCPDataRange(0, dataCount());
|
|
|
+ else
|
|
|
+ unselectedSegments << QCPDataRange(0, dataCount());
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ QCPDataSelection sel(selection());
|
|
|
+ sel.simplify();
|
|
|
+ selectedSegments = sel.dataRanges();
|
|
|
+ unselectedSegments = sel.inverse(QCPDataRange(0, dataCount())).dataRanges();
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns whether the error bar at the specified \a index is visible within the current key axis
|
|
|
+ range.
|
|
|
+
|
|
|
+ This method assumes for performance reasons without checking that the key axis, the value axis,
|
|
|
+ and the data plottable (\ref setDataPlottable) are not zero and that \a index is within valid
|
|
|
+ bounds of this \ref QCPErrorBars instance and the bounds of the data plottable.
|
|
|
+*/
|
|
|
+bool QCPErrorBars::errorBarVisible(int index) const
|
|
|
+{
|
|
|
+ QPointF centerPixel = mDataPlottable->interface1D()->dataPixelPosition(index);
|
|
|
+ const double centerKeyPixel = mKeyAxis->orientation() == Qt::Horizontal ? centerPixel.x() : centerPixel.y();
|
|
|
+ if (qIsNaN(centerKeyPixel))
|
|
|
+ return false;
|
|
|
+
|
|
|
+ double keyMin, keyMax;
|
|
|
+ if (mErrorType == etKeyError)
|
|
|
+ {
|
|
|
+ const double centerKey = mKeyAxis->pixelToCoord(centerKeyPixel);
|
|
|
+ const double errorPlus = mDataContainer->at(index).errorPlus;
|
|
|
+ const double errorMinus = mDataContainer->at(index).errorMinus;
|
|
|
+ keyMax = centerKey+(qIsNaN(errorPlus) ? 0 : errorPlus);
|
|
|
+ keyMin = centerKey-(qIsNaN(errorMinus) ? 0 : errorMinus);
|
|
|
+ } else // mErrorType == etValueError
|
|
|
+ {
|
|
|
+ keyMax = mKeyAxis->pixelToCoord(centerKeyPixel+mWhiskerWidth*0.5*mKeyAxis->pixelOrientation());
|
|
|
+ keyMin = mKeyAxis->pixelToCoord(centerKeyPixel-mWhiskerWidth*0.5*mKeyAxis->pixelOrientation());
|
|
|
+ }
|
|
|
+ return ((keyMax > mKeyAxis->range().lower) && (keyMin < mKeyAxis->range().upper));
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns whether \a line intersects (or is contained in) \a pixelRect.
|
|
|
+
|
|
|
+ \a line is assumed to be either perfectly horizontal or perfectly vertical, as is the case for
|
|
|
+ error bar lines.
|
|
|
+*/
|
|
|
+bool QCPErrorBars::rectIntersectsLine(const QRectF &pixelRect, const QLineF &line) const
|
|
|
+{
|
|
|
+ if (pixelRect.left() > line.x1() && pixelRect.left() > line.x2())
|
|
|
+ return false;
|
|
|
+ else if (pixelRect.right() < line.x1() && pixelRect.right() < line.x2())
|
|
|
+ return false;
|
|
|
+ else if (pixelRect.top() > line.y1() && pixelRect.top() > line.y2())
|
|
|
+ return false;
|
|
|
+ else if (pixelRect.bottom() < line.y1() && pixelRect.bottom() < line.y2())
|
|
|
+ return false;
|
|
|
+ else
|
|
|
+ return true;
|
|
|
+}
|
|
|
+/* end of 'src/plottables/plottable-errorbar.cpp' */
|
|
|
+
|
|
|
+
|
|
|
+/* including file 'src/items/item-straightline.cpp', size 7592 */
|
|
|
+/* commit 9868e55d3b412f2f89766bb482fcf299e93a0988 2017-09-04 01:56:22 +0200 */
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPItemStraightLine
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+/*! \class QCPItemStraightLine
|
|
|
+ \brief A straight line that spans infinitely in both directions
|
|
|
+
|
|
|
+ \image html QCPItemStraightLine.png "Straight line example. Blue dotted circles are anchors, solid blue discs are positions."
|
|
|
+
|
|
|
+ It has two positions, \a point1 and \a point2, which define the straight line.
|
|
|
+*/
|
|
|
+
|
|
|
+/*!
|
|
|
+ Creates a straight line item and sets default values.
|
|
|
+
|
|
|
+ The created item is automatically registered with \a parentPlot. This QCustomPlot instance takes
|
|
|
+ ownership of the item, so do not delete it manually but use QCustomPlot::removeItem() instead.
|
|
|
+*/
|
|
|
+QCPItemStraightLine::QCPItemStraightLine(QCustomPlot *parentPlot) :
|
|
|
+ QCPAbstractItem(parentPlot),
|
|
|
+ point1(createPosition(QLatin1String("point1"))),
|
|
|
+ point2(createPosition(QLatin1String("point2")))
|
|
|
+{
|
|
|
+ point1->setCoords(0, 0);
|
|
|
+ point2->setCoords(1, 1);
|
|
|
+
|
|
|
+ setPen(QPen(Qt::black));
|
|
|
+ setSelectedPen(QPen(Qt::blue,2));
|
|
|
+}
|
|
|
+
|
|
|
+QCPItemStraightLine::~QCPItemStraightLine()
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the pen that will be used to draw the line
|
|
|
+
|
|
|
+ \see setSelectedPen
|
|
|
+*/
|
|
|
+void QCPItemStraightLine::setPen(const QPen &pen)
|
|
|
+{
|
|
|
+ mPen = pen;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the pen that will be used to draw the line when selected
|
|
|
+
|
|
|
+ \see setPen, setSelected
|
|
|
+*/
|
|
|
+void QCPItemStraightLine::setSelectedPen(const QPen &pen)
|
|
|
+{
|
|
|
+ mSelectedPen = pen;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+double QCPItemStraightLine::selectTest(const QPointF &pos, bool onlySelectable, QVariant *details) const
|
|
|
+{
|
|
|
+ Q_UNUSED(details)
|
|
|
+ if (onlySelectable && !mSelectable)
|
|
|
+ return -1;
|
|
|
+
|
|
|
+ return QCPVector2D(pos).distanceToStraightLine(point1->pixelPosition(), point2->pixelPosition()-point1->pixelPosition());
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPItemStraightLine::draw(QCPPainter *painter)
|
|
|
+{
|
|
|
+ QCPVector2D start(point1->pixelPosition());
|
|
|
+ QCPVector2D end(point2->pixelPosition());
|
|
|
+ // get visible segment of straight line inside clipRect:
|
|
|
+ double clipPad = mainPen().widthF();
|
|
|
+ QLineF line = getRectClippedStraightLine(start, end-start, clipRect().adjusted(-clipPad, -clipPad, clipPad, clipPad));
|
|
|
+ // paint visible segment, if existent:
|
|
|
+ if (!line.isNull())
|
|
|
+ {
|
|
|
+ painter->setPen(mainPen());
|
|
|
+ painter->drawLine(line);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the section of the straight line defined by \a base and direction vector \a
|
|
|
+ vec, that is visible in the specified \a rect.
|
|
|
+
|
|
|
+ This is a helper function for \ref draw.
|
|
|
+*/
|
|
|
+QLineF QCPItemStraightLine::getRectClippedStraightLine(const QCPVector2D &base, const QCPVector2D &vec, const QRect &rect) const
|
|
|
+{
|
|
|
+ double bx, by;
|
|
|
+ double gamma;
|
|
|
+ QLineF result;
|
|
|
+ if (vec.x() == 0 && vec.y() == 0)
|
|
|
+ return result;
|
|
|
+ if (qFuzzyIsNull(vec.x())) // line is vertical
|
|
|
+ {
|
|
|
+ // check top of rect:
|
|
|
+ bx = rect.left();
|
|
|
+ by = rect.top();
|
|
|
+ gamma = base.x()-bx + (by-base.y())*vec.x()/vec.y();
|
|
|
+ if (gamma >= 0 && gamma <= rect.width())
|
|
|
+ result.setLine(bx+gamma, rect.top(), bx+gamma, rect.bottom()); // no need to check bottom because we know line is vertical
|
|
|
+ } else if (qFuzzyIsNull(vec.y())) // line is horizontal
|
|
|
+ {
|
|
|
+ // check left of rect:
|
|
|
+ bx = rect.left();
|
|
|
+ by = rect.top();
|
|
|
+ gamma = base.y()-by + (bx-base.x())*vec.y()/vec.x();
|
|
|
+ if (gamma >= 0 && gamma <= rect.height())
|
|
|
+ result.setLine(rect.left(), by+gamma, rect.right(), by+gamma); // no need to check right because we know line is horizontal
|
|
|
+ } else // line is skewed
|
|
|
+ {
|
|
|
+ QList<QCPVector2D> pointVectors;
|
|
|
+ // check top of rect:
|
|
|
+ bx = rect.left();
|
|
|
+ by = rect.top();
|
|
|
+ gamma = base.x()-bx + (by-base.y())*vec.x()/vec.y();
|
|
|
+ if (gamma >= 0 && gamma <= rect.width())
|
|
|
+ pointVectors.append(QCPVector2D(bx+gamma, by));
|
|
|
+ // check bottom of rect:
|
|
|
+ bx = rect.left();
|
|
|
+ by = rect.bottom();
|
|
|
+ gamma = base.x()-bx + (by-base.y())*vec.x()/vec.y();
|
|
|
+ if (gamma >= 0 && gamma <= rect.width())
|
|
|
+ pointVectors.append(QCPVector2D(bx+gamma, by));
|
|
|
+ // check left of rect:
|
|
|
+ bx = rect.left();
|
|
|
+ by = rect.top();
|
|
|
+ gamma = base.y()-by + (bx-base.x())*vec.y()/vec.x();
|
|
|
+ if (gamma >= 0 && gamma <= rect.height())
|
|
|
+ pointVectors.append(QCPVector2D(bx, by+gamma));
|
|
|
+ // check right of rect:
|
|
|
+ bx = rect.right();
|
|
|
+ by = rect.top();
|
|
|
+ gamma = base.y()-by + (bx-base.x())*vec.y()/vec.x();
|
|
|
+ if (gamma >= 0 && gamma <= rect.height())
|
|
|
+ pointVectors.append(QCPVector2D(bx, by+gamma));
|
|
|
+
|
|
|
+ // evaluate points:
|
|
|
+ if (pointVectors.size() == 2)
|
|
|
+ {
|
|
|
+ result.setPoints(pointVectors.at(0).toPointF(), pointVectors.at(1).toPointF());
|
|
|
+ } else if (pointVectors.size() > 2)
|
|
|
+ {
|
|
|
+ // line probably goes through corner of rect, and we got two points there. single out the point pair with greatest distance:
|
|
|
+ double distSqrMax = 0;
|
|
|
+ QCPVector2D pv1, pv2;
|
|
|
+ for (int i=0; i<pointVectors.size()-1; ++i)
|
|
|
+ {
|
|
|
+ for (int k=i+1; k<pointVectors.size(); ++k)
|
|
|
+ {
|
|
|
+ double distSqr = (pointVectors.at(i)-pointVectors.at(k)).lengthSquared();
|
|
|
+ if (distSqr > distSqrMax)
|
|
|
+ {
|
|
|
+ pv1 = pointVectors.at(i);
|
|
|
+ pv2 = pointVectors.at(k);
|
|
|
+ distSqrMax = distSqr;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ result.setPoints(pv1.toPointF(), pv2.toPointF());
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the pen that should be used for drawing lines. Returns mPen when the
|
|
|
+ item is not selected and mSelectedPen when it is.
|
|
|
+*/
|
|
|
+QPen QCPItemStraightLine::mainPen() const
|
|
|
+{
|
|
|
+ return mSelected ? mSelectedPen : mPen;
|
|
|
+}
|
|
|
+/* end of 'src/items/item-straightline.cpp' */
|
|
|
+
|
|
|
+
|
|
|
+/* including file 'src/items/item-line.cpp', size 8498 */
|
|
|
+/* commit 9868e55d3b412f2f89766bb482fcf299e93a0988 2017-09-04 01:56:22 +0200 */
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPItemLine
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+/*! \class QCPItemLine
|
|
|
+ \brief A line from one point to another
|
|
|
+
|
|
|
+ \image html QCPItemLine.png "Line example. Blue dotted circles are anchors, solid blue discs are positions."
|
|
|
+
|
|
|
+ It has two positions, \a start and \a end, which define the end points of the line.
|
|
|
+
|
|
|
+ With \ref setHead and \ref setTail you may set different line ending styles, e.g. to create an arrow.
|
|
|
+*/
|
|
|
+
|
|
|
+/*!
|
|
|
+ Creates a line item and sets default values.
|
|
|
+
|
|
|
+ The created item is automatically registered with \a parentPlot. This QCustomPlot instance takes
|
|
|
+ ownership of the item, so do not delete it manually but use QCustomPlot::removeItem() instead.
|
|
|
+*/
|
|
|
+QCPItemLine::QCPItemLine(QCustomPlot *parentPlot) :
|
|
|
+ QCPAbstractItem(parentPlot),
|
|
|
+ start(createPosition(QLatin1String("start"))),
|
|
|
+ end(createPosition(QLatin1String("end")))
|
|
|
+{
|
|
|
+ start->setCoords(0, 0);
|
|
|
+ end->setCoords(1, 1);
|
|
|
+
|
|
|
+ setPen(QPen(Qt::black));
|
|
|
+ setSelectedPen(QPen(Qt::blue,2));
|
|
|
+}
|
|
|
+
|
|
|
+QCPItemLine::~QCPItemLine()
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the pen that will be used to draw the line
|
|
|
+
|
|
|
+ \see setSelectedPen
|
|
|
+*/
|
|
|
+void QCPItemLine::setPen(const QPen &pen)
|
|
|
+{
|
|
|
+ mPen = pen;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the pen that will be used to draw the line when selected
|
|
|
+
|
|
|
+ \see setPen, setSelected
|
|
|
+*/
|
|
|
+void QCPItemLine::setSelectedPen(const QPen &pen)
|
|
|
+{
|
|
|
+ mSelectedPen = pen;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the line ending style of the head. The head corresponds to the \a end position.
|
|
|
+
|
|
|
+ Note that due to the overloaded QCPLineEnding constructor, you may directly specify
|
|
|
+ a QCPLineEnding::EndingStyle here, e.g. \code setHead(QCPLineEnding::esSpikeArrow) \endcode
|
|
|
+
|
|
|
+ \see setTail
|
|
|
+*/
|
|
|
+void QCPItemLine::setHead(const QCPLineEnding &head)
|
|
|
+{
|
|
|
+ mHead = head;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the line ending style of the tail. The tail corresponds to the \a start position.
|
|
|
+
|
|
|
+ Note that due to the overloaded QCPLineEnding constructor, you may directly specify
|
|
|
+ a QCPLineEnding::EndingStyle here, e.g. \code setTail(QCPLineEnding::esSpikeArrow) \endcode
|
|
|
+
|
|
|
+ \see setHead
|
|
|
+*/
|
|
|
+void QCPItemLine::setTail(const QCPLineEnding &tail)
|
|
|
+{
|
|
|
+ mTail = tail;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+double QCPItemLine::selectTest(const QPointF &pos, bool onlySelectable, QVariant *details) const
|
|
|
+{
|
|
|
+ Q_UNUSED(details)
|
|
|
+ if (onlySelectable && !mSelectable)
|
|
|
+ return -1;
|
|
|
+
|
|
|
+ return qSqrt(QCPVector2D(pos).distanceSquaredToLine(start->pixelPosition(), end->pixelPosition()));
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPItemLine::draw(QCPPainter *painter)
|
|
|
+{
|
|
|
+ QCPVector2D startVec(start->pixelPosition());
|
|
|
+ QCPVector2D endVec(end->pixelPosition());
|
|
|
+ if (qFuzzyIsNull((startVec-endVec).lengthSquared()))
|
|
|
+ return;
|
|
|
+ // get visible segment of straight line inside clipRect:
|
|
|
+ double clipPad = qMax(mHead.boundingDistance(), mTail.boundingDistance());
|
|
|
+ clipPad = qMax(clipPad, (double)mainPen().widthF());
|
|
|
+ QLineF line = getRectClippedLine(startVec, endVec, clipRect().adjusted(-clipPad, -clipPad, clipPad, clipPad));
|
|
|
+ // paint visible segment, if existent:
|
|
|
+ if (!line.isNull())
|
|
|
+ {
|
|
|
+ painter->setPen(mainPen());
|
|
|
+ painter->drawLine(line);
|
|
|
+ painter->setBrush(Qt::SolidPattern);
|
|
|
+ if (mTail.style() != QCPLineEnding::esNone)
|
|
|
+ mTail.draw(painter, startVec, startVec-endVec);
|
|
|
+ if (mHead.style() != QCPLineEnding::esNone)
|
|
|
+ mHead.draw(painter, endVec, endVec-startVec);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the section of the line defined by \a start and \a end, that is visible in the specified
|
|
|
+ \a rect.
|
|
|
+
|
|
|
+ This is a helper function for \ref draw.
|
|
|
+*/
|
|
|
+QLineF QCPItemLine::getRectClippedLine(const QCPVector2D &start, const QCPVector2D &end, const QRect &rect) const
|
|
|
+{
|
|
|
+ bool containsStart = rect.contains(start.x(), start.y());
|
|
|
+ bool containsEnd = rect.contains(end.x(), end.y());
|
|
|
+ if (containsStart && containsEnd)
|
|
|
+ return QLineF(start.toPointF(), end.toPointF());
|
|
|
+
|
|
|
+ QCPVector2D base = start;
|
|
|
+ QCPVector2D vec = end-start;
|
|
|
+ double bx, by;
|
|
|
+ double gamma, mu;
|
|
|
+ QLineF result;
|
|
|
+ QList<QCPVector2D> pointVectors;
|
|
|
+
|
|
|
+ if (!qFuzzyIsNull(vec.y())) // line is not horizontal
|
|
|
+ {
|
|
|
+ // check top of rect:
|
|
|
+ bx = rect.left();
|
|
|
+ by = rect.top();
|
|
|
+ mu = (by-base.y())/vec.y();
|
|
|
+ if (mu >= 0 && mu <= 1)
|
|
|
+ {
|
|
|
+ gamma = base.x()-bx + mu*vec.x();
|
|
|
+ if (gamma >= 0 && gamma <= rect.width())
|
|
|
+ pointVectors.append(QCPVector2D(bx+gamma, by));
|
|
|
+ }
|
|
|
+ // check bottom of rect:
|
|
|
+ bx = rect.left();
|
|
|
+ by = rect.bottom();
|
|
|
+ mu = (by-base.y())/vec.y();
|
|
|
+ if (mu >= 0 && mu <= 1)
|
|
|
+ {
|
|
|
+ gamma = base.x()-bx + mu*vec.x();
|
|
|
+ if (gamma >= 0 && gamma <= rect.width())
|
|
|
+ pointVectors.append(QCPVector2D(bx+gamma, by));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (!qFuzzyIsNull(vec.x())) // line is not vertical
|
|
|
+ {
|
|
|
+ // check left of rect:
|
|
|
+ bx = rect.left();
|
|
|
+ by = rect.top();
|
|
|
+ mu = (bx-base.x())/vec.x();
|
|
|
+ if (mu >= 0 && mu <= 1)
|
|
|
+ {
|
|
|
+ gamma = base.y()-by + mu*vec.y();
|
|
|
+ if (gamma >= 0 && gamma <= rect.height())
|
|
|
+ pointVectors.append(QCPVector2D(bx, by+gamma));
|
|
|
+ }
|
|
|
+ // check right of rect:
|
|
|
+ bx = rect.right();
|
|
|
+ by = rect.top();
|
|
|
+ mu = (bx-base.x())/vec.x();
|
|
|
+ if (mu >= 0 && mu <= 1)
|
|
|
+ {
|
|
|
+ gamma = base.y()-by + mu*vec.y();
|
|
|
+ if (gamma >= 0 && gamma <= rect.height())
|
|
|
+ pointVectors.append(QCPVector2D(bx, by+gamma));
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (containsStart)
|
|
|
+ pointVectors.append(start);
|
|
|
+ if (containsEnd)
|
|
|
+ pointVectors.append(end);
|
|
|
+
|
|
|
+ // evaluate points:
|
|
|
+ if (pointVectors.size() == 2)
|
|
|
+ {
|
|
|
+ result.setPoints(pointVectors.at(0).toPointF(), pointVectors.at(1).toPointF());
|
|
|
+ } else if (pointVectors.size() > 2)
|
|
|
+ {
|
|
|
+ // line probably goes through corner of rect, and we got two points there. single out the point pair with greatest distance:
|
|
|
+ double distSqrMax = 0;
|
|
|
+ QCPVector2D pv1, pv2;
|
|
|
+ for (int i=0; i<pointVectors.size()-1; ++i)
|
|
|
+ {
|
|
|
+ for (int k=i+1; k<pointVectors.size(); ++k)
|
|
|
+ {
|
|
|
+ double distSqr = (pointVectors.at(i)-pointVectors.at(k)).lengthSquared();
|
|
|
+ if (distSqr > distSqrMax)
|
|
|
+ {
|
|
|
+ pv1 = pointVectors.at(i);
|
|
|
+ pv2 = pointVectors.at(k);
|
|
|
+ distSqrMax = distSqr;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ result.setPoints(pv1.toPointF(), pv2.toPointF());
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the pen that should be used for drawing lines. Returns mPen when the
|
|
|
+ item is not selected and mSelectedPen when it is.
|
|
|
+*/
|
|
|
+QPen QCPItemLine::mainPen() const
|
|
|
+{
|
|
|
+ return mSelected ? mSelectedPen : mPen;
|
|
|
+}
|
|
|
+/* end of 'src/items/item-line.cpp' */
|
|
|
+
|
|
|
+
|
|
|
+/* including file 'src/items/item-curve.cpp', size 7159 */
|
|
|
+/* commit 9868e55d3b412f2f89766bb482fcf299e93a0988 2017-09-04 01:56:22 +0200 */
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPItemCurve
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+/*! \class QCPItemCurve
|
|
|
+ \brief A curved line from one point to another
|
|
|
+
|
|
|
+ \image html QCPItemCurve.png "Curve example. Blue dotted circles are anchors, solid blue discs are positions."
|
|
|
+
|
|
|
+ It has four positions, \a start and \a end, which define the end points of the line, and two
|
|
|
+ control points which define the direction the line exits from the start and the direction from
|
|
|
+ which it approaches the end: \a startDir and \a endDir.
|
|
|
+
|
|
|
+ With \ref setHead and \ref setTail you may set different line ending styles, e.g. to create an
|
|
|
+ arrow.
|
|
|
+
|
|
|
+ Often it is desirable for the control points to stay at fixed relative positions to the start/end
|
|
|
+ point. This can be achieved by setting the parent anchor e.g. of \a startDir simply to \a start,
|
|
|
+ and then specify the desired pixel offset with QCPItemPosition::setCoords on \a startDir.
|
|
|
+*/
|
|
|
+
|
|
|
+/*!
|
|
|
+ Creates a curve item and sets default values.
|
|
|
+
|
|
|
+ The created item is automatically registered with \a parentPlot. This QCustomPlot instance takes
|
|
|
+ ownership of the item, so do not delete it manually but use QCustomPlot::removeItem() instead.
|
|
|
+*/
|
|
|
+QCPItemCurve::QCPItemCurve(QCustomPlot *parentPlot) :
|
|
|
+ QCPAbstractItem(parentPlot),
|
|
|
+ start(createPosition(QLatin1String("start"))),
|
|
|
+ startDir(createPosition(QLatin1String("startDir"))),
|
|
|
+ endDir(createPosition(QLatin1String("endDir"))),
|
|
|
+ end(createPosition(QLatin1String("end")))
|
|
|
+{
|
|
|
+ start->setCoords(0, 0);
|
|
|
+ startDir->setCoords(0.5, 0);
|
|
|
+ endDir->setCoords(0, 0.5);
|
|
|
+ end->setCoords(1, 1);
|
|
|
+
|
|
|
+ setPen(QPen(Qt::black));
|
|
|
+ setSelectedPen(QPen(Qt::blue,2));
|
|
|
+}
|
|
|
+
|
|
|
+QCPItemCurve::~QCPItemCurve()
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the pen that will be used to draw the line
|
|
|
+
|
|
|
+ \see setSelectedPen
|
|
|
+*/
|
|
|
+void QCPItemCurve::setPen(const QPen &pen)
|
|
|
+{
|
|
|
+ mPen = pen;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the pen that will be used to draw the line when selected
|
|
|
+
|
|
|
+ \see setPen, setSelected
|
|
|
+*/
|
|
|
+void QCPItemCurve::setSelectedPen(const QPen &pen)
|
|
|
+{
|
|
|
+ mSelectedPen = pen;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the line ending style of the head. The head corresponds to the \a end position.
|
|
|
+
|
|
|
+ Note that due to the overloaded QCPLineEnding constructor, you may directly specify
|
|
|
+ a QCPLineEnding::EndingStyle here, e.g. \code setHead(QCPLineEnding::esSpikeArrow) \endcode
|
|
|
+
|
|
|
+ \see setTail
|
|
|
+*/
|
|
|
+void QCPItemCurve::setHead(const QCPLineEnding &head)
|
|
|
+{
|
|
|
+ mHead = head;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the line ending style of the tail. The tail corresponds to the \a start position.
|
|
|
+
|
|
|
+ Note that due to the overloaded QCPLineEnding constructor, you may directly specify
|
|
|
+ a QCPLineEnding::EndingStyle here, e.g. \code setTail(QCPLineEnding::esSpikeArrow) \endcode
|
|
|
+
|
|
|
+ \see setHead
|
|
|
+*/
|
|
|
+void QCPItemCurve::setTail(const QCPLineEnding &tail)
|
|
|
+{
|
|
|
+ mTail = tail;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+double QCPItemCurve::selectTest(const QPointF &pos, bool onlySelectable, QVariant *details) const
|
|
|
+{
|
|
|
+ Q_UNUSED(details)
|
|
|
+ if (onlySelectable && !mSelectable)
|
|
|
+ return -1;
|
|
|
+
|
|
|
+ QPointF startVec(start->pixelPosition());
|
|
|
+ QPointF startDirVec(startDir->pixelPosition());
|
|
|
+ QPointF endDirVec(endDir->pixelPosition());
|
|
|
+ QPointF endVec(end->pixelPosition());
|
|
|
+
|
|
|
+ QPainterPath cubicPath(startVec);
|
|
|
+ cubicPath.cubicTo(startDirVec, endDirVec, endVec);
|
|
|
+
|
|
|
+ QPolygonF polygon = cubicPath.toSubpathPolygons().first();
|
|
|
+ QCPVector2D p(pos);
|
|
|
+ double minDistSqr = std::numeric_limits<double>::max();
|
|
|
+ for (int i=1; i<polygon.size(); ++i)
|
|
|
+ {
|
|
|
+ double distSqr = p.distanceSquaredToLine(polygon.at(i-1), polygon.at(i));
|
|
|
+ if (distSqr < minDistSqr)
|
|
|
+ minDistSqr = distSqr;
|
|
|
+ }
|
|
|
+ return qSqrt(minDistSqr);
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPItemCurve::draw(QCPPainter *painter)
|
|
|
+{
|
|
|
+ QCPVector2D startVec(start->pixelPosition());
|
|
|
+ QCPVector2D startDirVec(startDir->pixelPosition());
|
|
|
+ QCPVector2D endDirVec(endDir->pixelPosition());
|
|
|
+ QCPVector2D endVec(end->pixelPosition());
|
|
|
+ if ((endVec-startVec).length() > 1e10) // too large curves cause crash
|
|
|
+ return;
|
|
|
+
|
|
|
+ QPainterPath cubicPath(startVec.toPointF());
|
|
|
+ cubicPath.cubicTo(startDirVec.toPointF(), endDirVec.toPointF(), endVec.toPointF());
|
|
|
+
|
|
|
+ // paint visible segment, if existent:
|
|
|
+ QRect clip = clipRect().adjusted(-mainPen().widthF(), -mainPen().widthF(), mainPen().widthF(), mainPen().widthF());
|
|
|
+ QRect cubicRect = cubicPath.controlPointRect().toRect();
|
|
|
+ if (cubicRect.isEmpty()) // may happen when start and end exactly on same x or y position
|
|
|
+ cubicRect.adjust(0, 0, 1, 1);
|
|
|
+ if (clip.intersects(cubicRect))
|
|
|
+ {
|
|
|
+ painter->setPen(mainPen());
|
|
|
+ painter->drawPath(cubicPath);
|
|
|
+ painter->setBrush(Qt::SolidPattern);
|
|
|
+ if (mTail.style() != QCPLineEnding::esNone)
|
|
|
+ mTail.draw(painter, startVec, M_PI-cubicPath.angleAtPercent(0)/180.0*M_PI);
|
|
|
+ if (mHead.style() != QCPLineEnding::esNone)
|
|
|
+ mHead.draw(painter, endVec, -cubicPath.angleAtPercent(1)/180.0*M_PI);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the pen that should be used for drawing lines. Returns mPen when the
|
|
|
+ item is not selected and mSelectedPen when it is.
|
|
|
+*/
|
|
|
+QPen QCPItemCurve::mainPen() const
|
|
|
+{
|
|
|
+ return mSelected ? mSelectedPen : mPen;
|
|
|
+}
|
|
|
+/* end of 'src/items/item-curve.cpp' */
|
|
|
+
|
|
|
+
|
|
|
+/* including file 'src/items/item-rect.cpp', size 6479 */
|
|
|
+/* commit 9868e55d3b412f2f89766bb482fcf299e93a0988 2017-09-04 01:56:22 +0200 */
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPItemRect
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+/*! \class QCPItemRect
|
|
|
+ \brief A rectangle
|
|
|
+
|
|
|
+ \image html QCPItemRect.png "Rectangle example. Blue dotted circles are anchors, solid blue discs are positions."
|
|
|
+
|
|
|
+ It has two positions, \a topLeft and \a bottomRight, which define the rectangle.
|
|
|
+*/
|
|
|
+
|
|
|
+/*!
|
|
|
+ Creates a rectangle item and sets default values.
|
|
|
+
|
|
|
+ The created item is automatically registered with \a parentPlot. This QCustomPlot instance takes
|
|
|
+ ownership of the item, so do not delete it manually but use QCustomPlot::removeItem() instead.
|
|
|
+*/
|
|
|
+QCPItemRect::QCPItemRect(QCustomPlot *parentPlot) :
|
|
|
+ QCPAbstractItem(parentPlot),
|
|
|
+ topLeft(createPosition(QLatin1String("topLeft"))),
|
|
|
+ bottomRight(createPosition(QLatin1String("bottomRight"))),
|
|
|
+ top(createAnchor(QLatin1String("top"), aiTop)),
|
|
|
+ topRight(createAnchor(QLatin1String("topRight"), aiTopRight)),
|
|
|
+ right(createAnchor(QLatin1String("right"), aiRight)),
|
|
|
+ bottom(createAnchor(QLatin1String("bottom"), aiBottom)),
|
|
|
+ bottomLeft(createAnchor(QLatin1String("bottomLeft"), aiBottomLeft)),
|
|
|
+ left(createAnchor(QLatin1String("left"), aiLeft))
|
|
|
+{
|
|
|
+ topLeft->setCoords(0, 1);
|
|
|
+ bottomRight->setCoords(1, 0);
|
|
|
+
|
|
|
+ setPen(QPen(Qt::black));
|
|
|
+ setSelectedPen(QPen(Qt::blue,2));
|
|
|
+ setBrush(Qt::NoBrush);
|
|
|
+ setSelectedBrush(Qt::NoBrush);
|
|
|
+}
|
|
|
+
|
|
|
+QCPItemRect::~QCPItemRect()
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the pen that will be used to draw the line of the rectangle
|
|
|
+
|
|
|
+ \see setSelectedPen, setBrush
|
|
|
+*/
|
|
|
+void QCPItemRect::setPen(const QPen &pen)
|
|
|
+{
|
|
|
+ mPen = pen;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the pen that will be used to draw the line of the rectangle when selected
|
|
|
+
|
|
|
+ \see setPen, setSelected
|
|
|
+*/
|
|
|
+void QCPItemRect::setSelectedPen(const QPen &pen)
|
|
|
+{
|
|
|
+ mSelectedPen = pen;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the brush that will be used to fill the rectangle. To disable filling, set \a brush to
|
|
|
+ Qt::NoBrush.
|
|
|
+
|
|
|
+ \see setSelectedBrush, setPen
|
|
|
+*/
|
|
|
+void QCPItemRect::setBrush(const QBrush &brush)
|
|
|
+{
|
|
|
+ mBrush = brush;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the brush that will be used to fill the rectangle when selected. To disable filling, set \a
|
|
|
+ brush to Qt::NoBrush.
|
|
|
+
|
|
|
+ \see setBrush
|
|
|
+*/
|
|
|
+void QCPItemRect::setSelectedBrush(const QBrush &brush)
|
|
|
+{
|
|
|
+ mSelectedBrush = brush;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+double QCPItemRect::selectTest(const QPointF &pos, bool onlySelectable, QVariant *details) const
|
|
|
+{
|
|
|
+ Q_UNUSED(details)
|
|
|
+ if (onlySelectable && !mSelectable)
|
|
|
+ return -1;
|
|
|
+
|
|
|
+ QRectF rect = QRectF(topLeft->pixelPosition(), bottomRight->pixelPosition()).normalized();
|
|
|
+ bool filledRect = mBrush.style() != Qt::NoBrush && mBrush.color().alpha() != 0;
|
|
|
+ return rectDistance(rect, pos, filledRect);
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPItemRect::draw(QCPPainter *painter)
|
|
|
+{
|
|
|
+ QPointF p1 = topLeft->pixelPosition();
|
|
|
+ QPointF p2 = bottomRight->pixelPosition();
|
|
|
+ if (p1.toPoint() == p2.toPoint())
|
|
|
+ return;
|
|
|
+ QRectF rect = QRectF(p1, p2).normalized();
|
|
|
+ double clipPad = mainPen().widthF();
|
|
|
+ QRectF boundingRect = rect.adjusted(-clipPad, -clipPad, clipPad, clipPad);
|
|
|
+ if (boundingRect.intersects(clipRect())) // only draw if bounding rect of rect item is visible in cliprect
|
|
|
+ {
|
|
|
+ painter->setPen(mainPen());
|
|
|
+ painter->setBrush(mainBrush());
|
|
|
+ painter->drawRect(rect);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+QPointF QCPItemRect::anchorPixelPosition(int anchorId) const
|
|
|
+{
|
|
|
+ QRectF rect = QRectF(topLeft->pixelPosition(), bottomRight->pixelPosition());
|
|
|
+ switch (anchorId)
|
|
|
+ {
|
|
|
+ case aiTop: return (rect.topLeft()+rect.topRight())*0.5;
|
|
|
+ case aiTopRight: return rect.topRight();
|
|
|
+ case aiRight: return (rect.topRight()+rect.bottomRight())*0.5;
|
|
|
+ case aiBottom: return (rect.bottomLeft()+rect.bottomRight())*0.5;
|
|
|
+ case aiBottomLeft: return rect.bottomLeft();
|
|
|
+ case aiLeft: return (rect.topLeft()+rect.bottomLeft())*0.5;
|
|
|
+ }
|
|
|
+
|
|
|
+ qDebug() << Q_FUNC_INFO << "invalid anchorId" << anchorId;
|
|
|
+ return QPointF();
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the pen that should be used for drawing lines. Returns mPen when the item is not selected
|
|
|
+ and mSelectedPen when it is.
|
|
|
+*/
|
|
|
+QPen QCPItemRect::mainPen() const
|
|
|
+{
|
|
|
+ return mSelected ? mSelectedPen : mPen;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the brush that should be used for drawing fills of the item. Returns mBrush when the item
|
|
|
+ is not selected and mSelectedBrush when it is.
|
|
|
+*/
|
|
|
+QBrush QCPItemRect::mainBrush() const
|
|
|
+{
|
|
|
+ return mSelected ? mSelectedBrush : mBrush;
|
|
|
+}
|
|
|
+/* end of 'src/items/item-rect.cpp' */
|
|
|
+
|
|
|
+
|
|
|
+/* including file 'src/items/item-text.cpp', size 13338 */
|
|
|
+/* commit 9868e55d3b412f2f89766bb482fcf299e93a0988 2017-09-04 01:56:22 +0200 */
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPItemText
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+/*! \class QCPItemText
|
|
|
+ \brief A text label
|
|
|
+
|
|
|
+ \image html QCPItemText.png "Text example. Blue dotted circles are anchors, solid blue discs are positions."
|
|
|
+
|
|
|
+ Its position is defined by the member \a position and the setting of \ref setPositionAlignment.
|
|
|
+ The latter controls which part of the text rect shall be aligned with \a position.
|
|
|
+
|
|
|
+ The text alignment itself (i.e. left, center, right) can be controlled with \ref
|
|
|
+ setTextAlignment.
|
|
|
+
|
|
|
+ The text may be rotated around the \a position point with \ref setRotation.
|
|
|
+*/
|
|
|
+
|
|
|
+/*!
|
|
|
+ Creates a text item and sets default values.
|
|
|
+
|
|
|
+ The created item is automatically registered with \a parentPlot. This QCustomPlot instance takes
|
|
|
+ ownership of the item, so do not delete it manually but use QCustomPlot::removeItem() instead.
|
|
|
+*/
|
|
|
+QCPItemText::QCPItemText(QCustomPlot *parentPlot) :
|
|
|
+ QCPAbstractItem(parentPlot),
|
|
|
+ position(createPosition(QLatin1String("position"))),
|
|
|
+ topLeft(createAnchor(QLatin1String("topLeft"), aiTopLeft)),
|
|
|
+ top(createAnchor(QLatin1String("top"), aiTop)),
|
|
|
+ topRight(createAnchor(QLatin1String("topRight"), aiTopRight)),
|
|
|
+ right(createAnchor(QLatin1String("right"), aiRight)),
|
|
|
+ bottomRight(createAnchor(QLatin1String("bottomRight"), aiBottomRight)),
|
|
|
+ bottom(createAnchor(QLatin1String("bottom"), aiBottom)),
|
|
|
+ bottomLeft(createAnchor(QLatin1String("bottomLeft"), aiBottomLeft)),
|
|
|
+ left(createAnchor(QLatin1String("left"), aiLeft)),
|
|
|
+ mText(QLatin1String("text")),
|
|
|
+ mPositionAlignment(Qt::AlignCenter),
|
|
|
+ mTextAlignment(Qt::AlignTop|Qt::AlignHCenter),
|
|
|
+ mRotation(0)
|
|
|
+{
|
|
|
+ position->setCoords(0, 0);
|
|
|
+
|
|
|
+ setPen(Qt::NoPen);
|
|
|
+ setSelectedPen(Qt::NoPen);
|
|
|
+ setBrush(Qt::NoBrush);
|
|
|
+ setSelectedBrush(Qt::NoBrush);
|
|
|
+ setColor(Qt::black);
|
|
|
+ setSelectedColor(Qt::blue);
|
|
|
+}
|
|
|
+
|
|
|
+QCPItemText::~QCPItemText()
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the color of the text.
|
|
|
+*/
|
|
|
+void QCPItemText::setColor(const QColor &color)
|
|
|
+{
|
|
|
+ mColor = color;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the color of the text that will be used when the item is selected.
|
|
|
+*/
|
|
|
+void QCPItemText::setSelectedColor(const QColor &color)
|
|
|
+{
|
|
|
+ mSelectedColor = color;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the pen that will be used do draw a rectangular border around the text. To disable the
|
|
|
+ border, set \a pen to Qt::NoPen.
|
|
|
+
|
|
|
+ \see setSelectedPen, setBrush, setPadding
|
|
|
+*/
|
|
|
+void QCPItemText::setPen(const QPen &pen)
|
|
|
+{
|
|
|
+ mPen = pen;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the pen that will be used do draw a rectangular border around the text, when the item is
|
|
|
+ selected. To disable the border, set \a pen to Qt::NoPen.
|
|
|
+
|
|
|
+ \see setPen
|
|
|
+*/
|
|
|
+void QCPItemText::setSelectedPen(const QPen &pen)
|
|
|
+{
|
|
|
+ mSelectedPen = pen;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the brush that will be used do fill the background of the text. To disable the
|
|
|
+ background, set \a brush to Qt::NoBrush.
|
|
|
+
|
|
|
+ \see setSelectedBrush, setPen, setPadding
|
|
|
+*/
|
|
|
+void QCPItemText::setBrush(const QBrush &brush)
|
|
|
+{
|
|
|
+ mBrush = brush;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the brush that will be used do fill the background of the text, when the item is selected. To disable the
|
|
|
+ background, set \a brush to Qt::NoBrush.
|
|
|
+
|
|
|
+ \see setBrush
|
|
|
+*/
|
|
|
+void QCPItemText::setSelectedBrush(const QBrush &brush)
|
|
|
+{
|
|
|
+ mSelectedBrush = brush;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the font of the text.
|
|
|
+
|
|
|
+ \see setSelectedFont, setColor
|
|
|
+*/
|
|
|
+void QCPItemText::setFont(const QFont &font)
|
|
|
+{
|
|
|
+ mFont = font;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the font of the text that will be used when the item is selected.
|
|
|
+
|
|
|
+ \see setFont
|
|
|
+*/
|
|
|
+void QCPItemText::setSelectedFont(const QFont &font)
|
|
|
+{
|
|
|
+ mSelectedFont = font;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the text that will be displayed. Multi-line texts are supported by inserting a line break
|
|
|
+ character, e.g. '\n'.
|
|
|
+
|
|
|
+ \see setFont, setColor, setTextAlignment
|
|
|
+*/
|
|
|
+void QCPItemText::setText(const QString &text)
|
|
|
+{
|
|
|
+ mText = text;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets which point of the text rect shall be aligned with \a position.
|
|
|
+
|
|
|
+ Examples:
|
|
|
+ \li If \a alignment is <tt>Qt::AlignHCenter | Qt::AlignTop</tt>, the text will be positioned such
|
|
|
+ that the top of the text rect will be horizontally centered on \a position.
|
|
|
+ \li If \a alignment is <tt>Qt::AlignLeft | Qt::AlignBottom</tt>, \a position will indicate the
|
|
|
+ bottom left corner of the text rect.
|
|
|
+
|
|
|
+ If you want to control the alignment of (multi-lined) text within the text rect, use \ref
|
|
|
+ setTextAlignment.
|
|
|
+*/
|
|
|
+void QCPItemText::setPositionAlignment(Qt::Alignment alignment)
|
|
|
+{
|
|
|
+ mPositionAlignment = alignment;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Controls how (multi-lined) text is aligned inside the text rect (typically Qt::AlignLeft, Qt::AlignCenter or Qt::AlignRight).
|
|
|
+*/
|
|
|
+void QCPItemText::setTextAlignment(Qt::Alignment alignment)
|
|
|
+{
|
|
|
+ mTextAlignment = alignment;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the angle in degrees by which the text (and the text rectangle, if visible) will be rotated
|
|
|
+ around \a position.
|
|
|
+*/
|
|
|
+void QCPItemText::setRotation(double degrees)
|
|
|
+{
|
|
|
+ mRotation = degrees;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the distance between the border of the text rectangle and the text. The appearance (and
|
|
|
+ visibility) of the text rectangle can be controlled with \ref setPen and \ref setBrush.
|
|
|
+*/
|
|
|
+void QCPItemText::setPadding(const QMargins &padding)
|
|
|
+{
|
|
|
+ mPadding = padding;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+double QCPItemText::selectTest(const QPointF &pos, bool onlySelectable, QVariant *details) const
|
|
|
+{
|
|
|
+ Q_UNUSED(details)
|
|
|
+ if (onlySelectable && !mSelectable)
|
|
|
+ return -1;
|
|
|
+
|
|
|
+ // The rect may be rotated, so we transform the actual clicked pos to the rotated
|
|
|
+ // coordinate system, so we can use the normal rectDistance function for non-rotated rects:
|
|
|
+ QPointF positionPixels(position->pixelPosition());
|
|
|
+ QTransform inputTransform;
|
|
|
+ inputTransform.translate(positionPixels.x(), positionPixels.y());
|
|
|
+ inputTransform.rotate(-mRotation);
|
|
|
+ inputTransform.translate(-positionPixels.x(), -positionPixels.y());
|
|
|
+ QPointF rotatedPos = inputTransform.map(pos);
|
|
|
+ QFontMetrics fontMetrics(mFont);
|
|
|
+ QRect textRect = fontMetrics.boundingRect(0, 0, 0, 0, Qt::TextDontClip|mTextAlignment, mText);
|
|
|
+ QRect textBoxRect = textRect.adjusted(-mPadding.left(), -mPadding.top(), mPadding.right(), mPadding.bottom());
|
|
|
+ QPointF textPos = getTextDrawPoint(positionPixels, textBoxRect, mPositionAlignment);
|
|
|
+ textBoxRect.moveTopLeft(textPos.toPoint());
|
|
|
+
|
|
|
+ return rectDistance(textBoxRect, rotatedPos, true);
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPItemText::draw(QCPPainter *painter)
|
|
|
+{
|
|
|
+ QPointF pos(position->pixelPosition());
|
|
|
+ QTransform transform = painter->transform();
|
|
|
+ transform.translate(pos.x(), pos.y());
|
|
|
+ if (!qFuzzyIsNull(mRotation))
|
|
|
+ transform.rotate(mRotation);
|
|
|
+ painter->setFont(mainFont());
|
|
|
+ QRect textRect = painter->fontMetrics().boundingRect(0, 0, 0, 0, Qt::TextDontClip|mTextAlignment, mText);
|
|
|
+ QRect textBoxRect = textRect.adjusted(-mPadding.left(), -mPadding.top(), mPadding.right(), mPadding.bottom());
|
|
|
+ QPointF textPos = getTextDrawPoint(QPointF(0, 0), textBoxRect, mPositionAlignment); // 0, 0 because the transform does the translation
|
|
|
+ textRect.moveTopLeft(textPos.toPoint()+QPoint(mPadding.left(), mPadding.top()));
|
|
|
+ textBoxRect.moveTopLeft(textPos.toPoint());
|
|
|
+ double clipPad = mainPen().widthF();
|
|
|
+ QRect boundingRect = textBoxRect.adjusted(-clipPad, -clipPad, clipPad, clipPad);
|
|
|
+ if (transform.mapRect(boundingRect).intersects(painter->transform().mapRect(clipRect())))
|
|
|
+ {
|
|
|
+ painter->setTransform(transform);
|
|
|
+ if ((mainBrush().style() != Qt::NoBrush && mainBrush().color().alpha() != 0) ||
|
|
|
+ (mainPen().style() != Qt::NoPen && mainPen().color().alpha() != 0))
|
|
|
+ {
|
|
|
+ painter->setPen(mainPen());
|
|
|
+ painter->setBrush(mainBrush());
|
|
|
+ painter->drawRect(textBoxRect);
|
|
|
+ }
|
|
|
+ painter->setBrush(Qt::NoBrush);
|
|
|
+ painter->setPen(QPen(mainColor()));
|
|
|
+ painter->drawText(textRect, Qt::TextDontClip|mTextAlignment, mText);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+QPointF QCPItemText::anchorPixelPosition(int anchorId) const
|
|
|
+{
|
|
|
+ // get actual rect points (pretty much copied from draw function):
|
|
|
+ QPointF pos(position->pixelPosition());
|
|
|
+ QTransform transform;
|
|
|
+ transform.translate(pos.x(), pos.y());
|
|
|
+ if (!qFuzzyIsNull(mRotation))
|
|
|
+ transform.rotate(mRotation);
|
|
|
+ QFontMetrics fontMetrics(mainFont());
|
|
|
+ QRect textRect = fontMetrics.boundingRect(0, 0, 0, 0, Qt::TextDontClip|mTextAlignment, mText);
|
|
|
+ QRectF textBoxRect = textRect.adjusted(-mPadding.left(), -mPadding.top(), mPadding.right(), mPadding.bottom());
|
|
|
+ QPointF textPos = getTextDrawPoint(QPointF(0, 0), textBoxRect, mPositionAlignment); // 0, 0 because the transform does the translation
|
|
|
+ textBoxRect.moveTopLeft(textPos.toPoint());
|
|
|
+ QPolygonF rectPoly = transform.map(QPolygonF(textBoxRect));
|
|
|
+
|
|
|
+ switch (anchorId)
|
|
|
+ {
|
|
|
+ case aiTopLeft: return rectPoly.at(0);
|
|
|
+ case aiTop: return (rectPoly.at(0)+rectPoly.at(1))*0.5;
|
|
|
+ case aiTopRight: return rectPoly.at(1);
|
|
|
+ case aiRight: return (rectPoly.at(1)+rectPoly.at(2))*0.5;
|
|
|
+ case aiBottomRight: return rectPoly.at(2);
|
|
|
+ case aiBottom: return (rectPoly.at(2)+rectPoly.at(3))*0.5;
|
|
|
+ case aiBottomLeft: return rectPoly.at(3);
|
|
|
+ case aiLeft: return (rectPoly.at(3)+rectPoly.at(0))*0.5;
|
|
|
+ }
|
|
|
+
|
|
|
+ qDebug() << Q_FUNC_INFO << "invalid anchorId" << anchorId;
|
|
|
+ return QPointF();
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the point that must be given to the QPainter::drawText function (which expects the top
|
|
|
+ left point of the text rect), according to the position \a pos, the text bounding box \a rect and
|
|
|
+ the requested \a positionAlignment.
|
|
|
+
|
|
|
+ For example, if \a positionAlignment is <tt>Qt::AlignLeft | Qt::AlignBottom</tt> the returned point
|
|
|
+ will be shifted upward by the height of \a rect, starting from \a pos. So if the text is finally
|
|
|
+ drawn at that point, the lower left corner of the resulting text rect is at \a pos.
|
|
|
+*/
|
|
|
+QPointF QCPItemText::getTextDrawPoint(const QPointF &pos, const QRectF &rect, Qt::Alignment positionAlignment) const
|
|
|
+{
|
|
|
+ if (positionAlignment == 0 || positionAlignment == (Qt::AlignLeft|Qt::AlignTop))
|
|
|
+ return pos;
|
|
|
+
|
|
|
+ QPointF result = pos; // start at top left
|
|
|
+ if (positionAlignment.testFlag(Qt::AlignHCenter))
|
|
|
+ result.rx() -= rect.width()/2.0;
|
|
|
+ else if (positionAlignment.testFlag(Qt::AlignRight))
|
|
|
+ result.rx() -= rect.width();
|
|
|
+ if (positionAlignment.testFlag(Qt::AlignVCenter))
|
|
|
+ result.ry() -= rect.height()/2.0;
|
|
|
+ else if (positionAlignment.testFlag(Qt::AlignBottom))
|
|
|
+ result.ry() -= rect.height();
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the font that should be used for drawing text. Returns mFont when the item is not selected
|
|
|
+ and mSelectedFont when it is.
|
|
|
+*/
|
|
|
+QFont QCPItemText::mainFont() const
|
|
|
+{
|
|
|
+ return mSelected ? mSelectedFont : mFont;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the color that should be used for drawing text. Returns mColor when the item is not
|
|
|
+ selected and mSelectedColor when it is.
|
|
|
+*/
|
|
|
+QColor QCPItemText::mainColor() const
|
|
|
+{
|
|
|
+ return mSelected ? mSelectedColor : mColor;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the pen that should be used for drawing lines. Returns mPen when the item is not selected
|
|
|
+ and mSelectedPen when it is.
|
|
|
+*/
|
|
|
+QPen QCPItemText::mainPen() const
|
|
|
+{
|
|
|
+ return mSelected ? mSelectedPen : mPen;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the brush that should be used for drawing fills of the item. Returns mBrush when the item
|
|
|
+ is not selected and mSelectedBrush when it is.
|
|
|
+*/
|
|
|
+QBrush QCPItemText::mainBrush() const
|
|
|
+{
|
|
|
+ return mSelected ? mSelectedBrush : mBrush;
|
|
|
+}
|
|
|
+/* end of 'src/items/item-text.cpp' */
|
|
|
+
|
|
|
+
|
|
|
+/* including file 'src/items/item-ellipse.cpp', size 7863 */
|
|
|
+/* commit 9868e55d3b412f2f89766bb482fcf299e93a0988 2017-09-04 01:56:22 +0200 */
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPItemEllipse
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+/*! \class QCPItemEllipse
|
|
|
+ \brief An ellipse
|
|
|
+
|
|
|
+ \image html QCPItemEllipse.png "Ellipse example. Blue dotted circles are anchors, solid blue discs are positions."
|
|
|
+
|
|
|
+ It has two positions, \a topLeft and \a bottomRight, which define the rect the ellipse will be drawn in.
|
|
|
+*/
|
|
|
+
|
|
|
+/*!
|
|
|
+ Creates an ellipse item and sets default values.
|
|
|
+
|
|
|
+ The created item is automatically registered with \a parentPlot. This QCustomPlot instance takes
|
|
|
+ ownership of the item, so do not delete it manually but use QCustomPlot::removeItem() instead.
|
|
|
+*/
|
|
|
+QCPItemEllipse::QCPItemEllipse(QCustomPlot *parentPlot) :
|
|
|
+ QCPAbstractItem(parentPlot),
|
|
|
+ topLeft(createPosition(QLatin1String("topLeft"))),
|
|
|
+ bottomRight(createPosition(QLatin1String("bottomRight"))),
|
|
|
+ topLeftRim(createAnchor(QLatin1String("topLeftRim"), aiTopLeftRim)),
|
|
|
+ top(createAnchor(QLatin1String("top"), aiTop)),
|
|
|
+ topRightRim(createAnchor(QLatin1String("topRightRim"), aiTopRightRim)),
|
|
|
+ right(createAnchor(QLatin1String("right"), aiRight)),
|
|
|
+ bottomRightRim(createAnchor(QLatin1String("bottomRightRim"), aiBottomRightRim)),
|
|
|
+ bottom(createAnchor(QLatin1String("bottom"), aiBottom)),
|
|
|
+ bottomLeftRim(createAnchor(QLatin1String("bottomLeftRim"), aiBottomLeftRim)),
|
|
|
+ left(createAnchor(QLatin1String("left"), aiLeft)),
|
|
|
+ center(createAnchor(QLatin1String("center"), aiCenter))
|
|
|
+{
|
|
|
+ topLeft->setCoords(0, 1);
|
|
|
+ bottomRight->setCoords(1, 0);
|
|
|
+
|
|
|
+ setPen(QPen(Qt::black));
|
|
|
+ setSelectedPen(QPen(Qt::blue, 2));
|
|
|
+ setBrush(Qt::NoBrush);
|
|
|
+ setSelectedBrush(Qt::NoBrush);
|
|
|
+}
|
|
|
+
|
|
|
+QCPItemEllipse::~QCPItemEllipse()
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the pen that will be used to draw the line of the ellipse
|
|
|
+
|
|
|
+ \see setSelectedPen, setBrush
|
|
|
+*/
|
|
|
+void QCPItemEllipse::setPen(const QPen &pen)
|
|
|
+{
|
|
|
+ mPen = pen;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the pen that will be used to draw the line of the ellipse when selected
|
|
|
+
|
|
|
+ \see setPen, setSelected
|
|
|
+*/
|
|
|
+void QCPItemEllipse::setSelectedPen(const QPen &pen)
|
|
|
+{
|
|
|
+ mSelectedPen = pen;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the brush that will be used to fill the ellipse. To disable filling, set \a brush to
|
|
|
+ Qt::NoBrush.
|
|
|
+
|
|
|
+ \see setSelectedBrush, setPen
|
|
|
+*/
|
|
|
+void QCPItemEllipse::setBrush(const QBrush &brush)
|
|
|
+{
|
|
|
+ mBrush = brush;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the brush that will be used to fill the ellipse when selected. To disable filling, set \a
|
|
|
+ brush to Qt::NoBrush.
|
|
|
+
|
|
|
+ \see setBrush
|
|
|
+*/
|
|
|
+void QCPItemEllipse::setSelectedBrush(const QBrush &brush)
|
|
|
+{
|
|
|
+ mSelectedBrush = brush;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+double QCPItemEllipse::selectTest(const QPointF &pos, bool onlySelectable, QVariant *details) const
|
|
|
+{
|
|
|
+ Q_UNUSED(details)
|
|
|
+ if (onlySelectable && !mSelectable)
|
|
|
+ return -1;
|
|
|
+
|
|
|
+ QPointF p1 = topLeft->pixelPosition();
|
|
|
+ QPointF p2 = bottomRight->pixelPosition();
|
|
|
+ QPointF center((p1+p2)/2.0);
|
|
|
+ double a = qAbs(p1.x()-p2.x())/2.0;
|
|
|
+ double b = qAbs(p1.y()-p2.y())/2.0;
|
|
|
+ double x = pos.x()-center.x();
|
|
|
+ double y = pos.y()-center.y();
|
|
|
+
|
|
|
+ // distance to border:
|
|
|
+ double c = 1.0/qSqrt(x*x/(a*a)+y*y/(b*b));
|
|
|
+ double result = qAbs(c-1)*qSqrt(x*x+y*y);
|
|
|
+ // filled ellipse, allow click inside to count as hit:
|
|
|
+ if (result > mParentPlot->selectionTolerance()*0.99 && mBrush.style() != Qt::NoBrush && mBrush.color().alpha() != 0)
|
|
|
+ {
|
|
|
+ if (x*x/(a*a) + y*y/(b*b) <= 1)
|
|
|
+ result = mParentPlot->selectionTolerance()*0.99;
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPItemEllipse::draw(QCPPainter *painter)
|
|
|
+{
|
|
|
+ QPointF p1 = topLeft->pixelPosition();
|
|
|
+ QPointF p2 = bottomRight->pixelPosition();
|
|
|
+ if (p1.toPoint() == p2.toPoint())
|
|
|
+ return;
|
|
|
+ QRectF ellipseRect = QRectF(p1, p2).normalized();
|
|
|
+ QRect clip = clipRect().adjusted(-mainPen().widthF(), -mainPen().widthF(), mainPen().widthF(), mainPen().widthF());
|
|
|
+ if (ellipseRect.intersects(clip)) // only draw if bounding rect of ellipse is visible in cliprect
|
|
|
+ {
|
|
|
+ painter->setPen(mainPen());
|
|
|
+ painter->setBrush(mainBrush());
|
|
|
+#ifdef __EXCEPTIONS
|
|
|
+ try // drawEllipse sometimes throws exceptions if ellipse is too big
|
|
|
+ {
|
|
|
+#endif
|
|
|
+ painter->drawEllipse(ellipseRect);
|
|
|
+#ifdef __EXCEPTIONS
|
|
|
+ } catch (...)
|
|
|
+ {
|
|
|
+ qDebug() << Q_FUNC_INFO << "Item too large for memory, setting invisible";
|
|
|
+ setVisible(false);
|
|
|
+ }
|
|
|
+#endif
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+QPointF QCPItemEllipse::anchorPixelPosition(int anchorId) const
|
|
|
+{
|
|
|
+ QRectF rect = QRectF(topLeft->pixelPosition(), bottomRight->pixelPosition());
|
|
|
+ switch (anchorId)
|
|
|
+ {
|
|
|
+ case aiTopLeftRim: return rect.center()+(rect.topLeft()-rect.center())*1/qSqrt(2);
|
|
|
+ case aiTop: return (rect.topLeft()+rect.topRight())*0.5;
|
|
|
+ case aiTopRightRim: return rect.center()+(rect.topRight()-rect.center())*1/qSqrt(2);
|
|
|
+ case aiRight: return (rect.topRight()+rect.bottomRight())*0.5;
|
|
|
+ case aiBottomRightRim: return rect.center()+(rect.bottomRight()-rect.center())*1/qSqrt(2);
|
|
|
+ case aiBottom: return (rect.bottomLeft()+rect.bottomRight())*0.5;
|
|
|
+ case aiBottomLeftRim: return rect.center()+(rect.bottomLeft()-rect.center())*1/qSqrt(2);
|
|
|
+ case aiLeft: return (rect.topLeft()+rect.bottomLeft())*0.5;
|
|
|
+ case aiCenter: return (rect.topLeft()+rect.bottomRight())*0.5;
|
|
|
+ }
|
|
|
+
|
|
|
+ qDebug() << Q_FUNC_INFO << "invalid anchorId" << anchorId;
|
|
|
+ return QPointF();
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the pen that should be used for drawing lines. Returns mPen when the item is not selected
|
|
|
+ and mSelectedPen when it is.
|
|
|
+*/
|
|
|
+QPen QCPItemEllipse::mainPen() const
|
|
|
+{
|
|
|
+ return mSelected ? mSelectedPen : mPen;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the brush that should be used for drawing fills of the item. Returns mBrush when the item
|
|
|
+ is not selected and mSelectedBrush when it is.
|
|
|
+*/
|
|
|
+QBrush QCPItemEllipse::mainBrush() const
|
|
|
+{
|
|
|
+ return mSelected ? mSelectedBrush : mBrush;
|
|
|
+}
|
|
|
+/* end of 'src/items/item-ellipse.cpp' */
|
|
|
+
|
|
|
+
|
|
|
+/* including file 'src/items/item-pixmap.cpp', size 10615 */
|
|
|
+/* commit 9868e55d3b412f2f89766bb482fcf299e93a0988 2017-09-04 01:56:22 +0200 */
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPItemPixmap
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+/*! \class QCPItemPixmap
|
|
|
+ \brief An arbitrary pixmap
|
|
|
+
|
|
|
+ \image html QCPItemPixmap.png "Pixmap example. Blue dotted circles are anchors, solid blue discs are positions."
|
|
|
+
|
|
|
+ It has two positions, \a topLeft and \a bottomRight, which define the rectangle the pixmap will
|
|
|
+ be drawn in. Depending on the scale setting (\ref setScaled), the pixmap will be either scaled to
|
|
|
+ fit the rectangle or be drawn aligned to the topLeft position.
|
|
|
+
|
|
|
+ If scaling is enabled and \a topLeft is further to the bottom/right than \a bottomRight (as shown
|
|
|
+ on the right side of the example image), the pixmap will be flipped in the respective
|
|
|
+ orientations.
|
|
|
+*/
|
|
|
+
|
|
|
+/*!
|
|
|
+ Creates a rectangle item and sets default values.
|
|
|
+
|
|
|
+ The created item is automatically registered with \a parentPlot. This QCustomPlot instance takes
|
|
|
+ ownership of the item, so do not delete it manually but use QCustomPlot::removeItem() instead.
|
|
|
+*/
|
|
|
+QCPItemPixmap::QCPItemPixmap(QCustomPlot *parentPlot) :
|
|
|
+ QCPAbstractItem(parentPlot),
|
|
|
+ topLeft(createPosition(QLatin1String("topLeft"))),
|
|
|
+ bottomRight(createPosition(QLatin1String("bottomRight"))),
|
|
|
+ top(createAnchor(QLatin1String("top"), aiTop)),
|
|
|
+ topRight(createAnchor(QLatin1String("topRight"), aiTopRight)),
|
|
|
+ right(createAnchor(QLatin1String("right"), aiRight)),
|
|
|
+ bottom(createAnchor(QLatin1String("bottom"), aiBottom)),
|
|
|
+ bottomLeft(createAnchor(QLatin1String("bottomLeft"), aiBottomLeft)),
|
|
|
+ left(createAnchor(QLatin1String("left"), aiLeft)),
|
|
|
+ mScaled(false),
|
|
|
+ mScaledPixmapInvalidated(true),
|
|
|
+ mAspectRatioMode(Qt::KeepAspectRatio),
|
|
|
+ mTransformationMode(Qt::SmoothTransformation)
|
|
|
+{
|
|
|
+ topLeft->setCoords(0, 1);
|
|
|
+ bottomRight->setCoords(1, 0);
|
|
|
+
|
|
|
+ setPen(Qt::NoPen);
|
|
|
+ setSelectedPen(QPen(Qt::blue));
|
|
|
+}
|
|
|
+
|
|
|
+QCPItemPixmap::~QCPItemPixmap()
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the pixmap that will be displayed.
|
|
|
+*/
|
|
|
+void QCPItemPixmap::setPixmap(const QPixmap &pixmap)
|
|
|
+{
|
|
|
+ mPixmap = pixmap;
|
|
|
+ mScaledPixmapInvalidated = true;
|
|
|
+ if (mPixmap.isNull())
|
|
|
+ qDebug() << Q_FUNC_INFO << "pixmap is null";
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets whether the pixmap will be scaled to fit the rectangle defined by the \a topLeft and \a
|
|
|
+ bottomRight positions.
|
|
|
+*/
|
|
|
+void QCPItemPixmap::setScaled(bool scaled, Qt::AspectRatioMode aspectRatioMode, Qt::TransformationMode transformationMode)
|
|
|
+{
|
|
|
+ mScaled = scaled;
|
|
|
+ mAspectRatioMode = aspectRatioMode;
|
|
|
+ mTransformationMode = transformationMode;
|
|
|
+ mScaledPixmapInvalidated = true;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the pen that will be used to draw a border around the pixmap.
|
|
|
+
|
|
|
+ \see setSelectedPen, setBrush
|
|
|
+*/
|
|
|
+void QCPItemPixmap::setPen(const QPen &pen)
|
|
|
+{
|
|
|
+ mPen = pen;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the pen that will be used to draw a border around the pixmap when selected
|
|
|
+
|
|
|
+ \see setPen, setSelected
|
|
|
+*/
|
|
|
+void QCPItemPixmap::setSelectedPen(const QPen &pen)
|
|
|
+{
|
|
|
+ mSelectedPen = pen;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+double QCPItemPixmap::selectTest(const QPointF &pos, bool onlySelectable, QVariant *details) const
|
|
|
+{
|
|
|
+ Q_UNUSED(details)
|
|
|
+ if (onlySelectable && !mSelectable)
|
|
|
+ return -1;
|
|
|
+
|
|
|
+ return rectDistance(getFinalRect(), pos, true);
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPItemPixmap::draw(QCPPainter *painter)
|
|
|
+{
|
|
|
+ bool flipHorz = false;
|
|
|
+ bool flipVert = false;
|
|
|
+ QRect rect = getFinalRect(&flipHorz, &flipVert);
|
|
|
+ double clipPad = mainPen().style() == Qt::NoPen ? 0 : mainPen().widthF();
|
|
|
+ QRect boundingRect = rect.adjusted(-clipPad, -clipPad, clipPad, clipPad);
|
|
|
+ if (boundingRect.intersects(clipRect()))
|
|
|
+ {
|
|
|
+ updateScaledPixmap(rect, flipHorz, flipVert);
|
|
|
+ painter->drawPixmap(rect.topLeft(), mScaled ? mScaledPixmap : mPixmap);
|
|
|
+ QPen pen = mainPen();
|
|
|
+ if (pen.style() != Qt::NoPen)
|
|
|
+ {
|
|
|
+ painter->setPen(pen);
|
|
|
+ painter->setBrush(Qt::NoBrush);
|
|
|
+ painter->drawRect(rect);
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+QPointF QCPItemPixmap::anchorPixelPosition(int anchorId) const
|
|
|
+{
|
|
|
+ bool flipHorz;
|
|
|
+ bool flipVert;
|
|
|
+ QRect rect = getFinalRect(&flipHorz, &flipVert);
|
|
|
+ // we actually want denormal rects (negative width/height) here, so restore
|
|
|
+ // the flipped state:
|
|
|
+ if (flipHorz)
|
|
|
+ rect.adjust(rect.width(), 0, -rect.width(), 0);
|
|
|
+ if (flipVert)
|
|
|
+ rect.adjust(0, rect.height(), 0, -rect.height());
|
|
|
+
|
|
|
+ switch (anchorId)
|
|
|
+ {
|
|
|
+ case aiTop: return (rect.topLeft()+rect.topRight())*0.5;
|
|
|
+ case aiTopRight: return rect.topRight();
|
|
|
+ case aiRight: return (rect.topRight()+rect.bottomRight())*0.5;
|
|
|
+ case aiBottom: return (rect.bottomLeft()+rect.bottomRight())*0.5;
|
|
|
+ case aiBottomLeft: return rect.bottomLeft();
|
|
|
+ case aiLeft: return (rect.topLeft()+rect.bottomLeft())*0.5;;
|
|
|
+ }
|
|
|
+
|
|
|
+ qDebug() << Q_FUNC_INFO << "invalid anchorId" << anchorId;
|
|
|
+ return QPointF();
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Creates the buffered scaled image (\a mScaledPixmap) to fit the specified \a finalRect. The
|
|
|
+ parameters \a flipHorz and \a flipVert control whether the resulting image shall be flipped
|
|
|
+ horizontally or vertically. (This is used when \a topLeft is further to the bottom/right than \a
|
|
|
+ bottomRight.)
|
|
|
+
|
|
|
+ This function only creates the scaled pixmap when the buffered pixmap has a different size than
|
|
|
+ the expected result, so calling this function repeatedly, e.g. in the \ref draw function, does
|
|
|
+ not cause expensive rescaling every time.
|
|
|
+
|
|
|
+ If scaling is disabled, sets mScaledPixmap to a null QPixmap.
|
|
|
+*/
|
|
|
+void QCPItemPixmap::updateScaledPixmap(QRect finalRect, bool flipHorz, bool flipVert)
|
|
|
+{
|
|
|
+ if (mPixmap.isNull())
|
|
|
+ return;
|
|
|
+
|
|
|
+ if (mScaled)
|
|
|
+ {
|
|
|
+#ifdef QCP_DEVICEPIXELRATIO_SUPPORTED
|
|
|
+ double devicePixelRatio = mPixmap.devicePixelRatio();
|
|
|
+#else
|
|
|
+ double devicePixelRatio = 1.0;
|
|
|
+#endif
|
|
|
+ if (finalRect.isNull())
|
|
|
+ finalRect = getFinalRect(&flipHorz, &flipVert);
|
|
|
+ if (mScaledPixmapInvalidated || finalRect.size() != mScaledPixmap.size()/devicePixelRatio)
|
|
|
+ {
|
|
|
+ mScaledPixmap = mPixmap.scaled(finalRect.size()*devicePixelRatio, mAspectRatioMode, mTransformationMode);
|
|
|
+ if (flipHorz || flipVert)
|
|
|
+ mScaledPixmap = QPixmap::fromImage(mScaledPixmap.toImage().mirrored(flipHorz, flipVert));
|
|
|
+#ifdef QCP_DEVICEPIXELRATIO_SUPPORTED
|
|
|
+ mScaledPixmap.setDevicePixelRatio(devicePixelRatio);
|
|
|
+#endif
|
|
|
+ }
|
|
|
+ } else if (!mScaledPixmap.isNull())
|
|
|
+ mScaledPixmap = QPixmap();
|
|
|
+ mScaledPixmapInvalidated = false;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the final (tight) rect the pixmap is drawn in, depending on the current item positions
|
|
|
+ and scaling settings.
|
|
|
+
|
|
|
+ The output parameters \a flippedHorz and \a flippedVert return whether the pixmap should be drawn
|
|
|
+ flipped horizontally or vertically in the returned rect. (The returned rect itself is always
|
|
|
+ normalized, i.e. the top left corner of the rect is actually further to the top/left than the
|
|
|
+ bottom right corner). This is the case when the item position \a topLeft is further to the
|
|
|
+ bottom/right than \a bottomRight.
|
|
|
+
|
|
|
+ If scaling is disabled, returns a rect with size of the original pixmap and the top left corner
|
|
|
+ aligned with the item position \a topLeft. The position \a bottomRight is ignored.
|
|
|
+*/
|
|
|
+QRect QCPItemPixmap::getFinalRect(bool *flippedHorz, bool *flippedVert) const
|
|
|
+{
|
|
|
+ QRect result;
|
|
|
+ bool flipHorz = false;
|
|
|
+ bool flipVert = false;
|
|
|
+ QPoint p1 = topLeft->pixelPosition().toPoint();
|
|
|
+ QPoint p2 = bottomRight->pixelPosition().toPoint();
|
|
|
+ if (p1 == p2)
|
|
|
+ return QRect(p1, QSize(0, 0));
|
|
|
+ if (mScaled)
|
|
|
+ {
|
|
|
+ QSize newSize = QSize(p2.x()-p1.x(), p2.y()-p1.y());
|
|
|
+ QPoint topLeft = p1;
|
|
|
+ if (newSize.width() < 0)
|
|
|
+ {
|
|
|
+ flipHorz = true;
|
|
|
+ newSize.rwidth() *= -1;
|
|
|
+ topLeft.setX(p2.x());
|
|
|
+ }
|
|
|
+ if (newSize.height() < 0)
|
|
|
+ {
|
|
|
+ flipVert = true;
|
|
|
+ newSize.rheight() *= -1;
|
|
|
+ topLeft.setY(p2.y());
|
|
|
+ }
|
|
|
+ QSize scaledSize = mPixmap.size();
|
|
|
+#ifdef QCP_DEVICEPIXELRATIO_SUPPORTED
|
|
|
+ scaledSize /= mPixmap.devicePixelRatio();
|
|
|
+ scaledSize.scale(newSize*mPixmap.devicePixelRatio(), mAspectRatioMode);
|
|
|
+#else
|
|
|
+ scaledSize.scale(newSize, mAspectRatioMode);
|
|
|
+#endif
|
|
|
+ result = QRect(topLeft, scaledSize);
|
|
|
+ } else
|
|
|
+ {
|
|
|
+#ifdef QCP_DEVICEPIXELRATIO_SUPPORTED
|
|
|
+ result = QRect(p1, mPixmap.size()/mPixmap.devicePixelRatio());
|
|
|
+#else
|
|
|
+ result = QRect(p1, mPixmap.size());
|
|
|
+#endif
|
|
|
+ }
|
|
|
+ if (flippedHorz)
|
|
|
+ *flippedHorz = flipHorz;
|
|
|
+ if (flippedVert)
|
|
|
+ *flippedVert = flipVert;
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the pen that should be used for drawing lines. Returns mPen when the item is not selected
|
|
|
+ and mSelectedPen when it is.
|
|
|
+*/
|
|
|
+QPen QCPItemPixmap::mainPen() const
|
|
|
+{
|
|
|
+ return mSelected ? mSelectedPen : mPen;
|
|
|
+}
|
|
|
+/* end of 'src/items/item-pixmap.cpp' */
|
|
|
+
|
|
|
+
|
|
|
+/* including file 'src/items/item-tracer.cpp', size 14624 */
|
|
|
+/* commit 9868e55d3b412f2f89766bb482fcf299e93a0988 2017-09-04 01:56:22 +0200 */
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPItemTracer
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+/*! \class QCPItemTracer
|
|
|
+ \brief Item that sticks to QCPGraph data points
|
|
|
+
|
|
|
+ \image html QCPItemTracer.png "Tracer example. Blue dotted circles are anchors, solid blue discs are positions."
|
|
|
+
|
|
|
+ The tracer can be connected with a QCPGraph via \ref setGraph. Then it will automatically adopt
|
|
|
+ the coordinate axes of the graph and update its \a position to be on the graph's data. This means
|
|
|
+ the key stays controllable via \ref setGraphKey, but the value will follow the graph data. If a
|
|
|
+ QCPGraph is connected, note that setting the coordinates of the tracer item directly via \a
|
|
|
+ position will have no effect because they will be overriden in the next redraw (this is when the
|
|
|
+ coordinate update happens).
|
|
|
+
|
|
|
+ If the specified key in \ref setGraphKey is outside the key bounds of the graph, the tracer will
|
|
|
+ stay at the corresponding end of the graph.
|
|
|
+
|
|
|
+ With \ref setInterpolating you may specify whether the tracer may only stay exactly on data
|
|
|
+ points or whether it interpolates data points linearly, if given a key that lies between two data
|
|
|
+ points of the graph.
|
|
|
+
|
|
|
+ The tracer has different visual styles, see \ref setStyle. It is also possible to make the tracer
|
|
|
+ have no own visual appearance (set the style to \ref tsNone), and just connect other item
|
|
|
+ positions to the tracer \a position (used as an anchor) via \ref
|
|
|
+ QCPItemPosition::setParentAnchor.
|
|
|
+
|
|
|
+ \note The tracer position is only automatically updated upon redraws. So when the data of the
|
|
|
+ graph changes and immediately afterwards (without a redraw) the position coordinates of the
|
|
|
+ tracer are retrieved, they will not reflect the updated data of the graph. In this case \ref
|
|
|
+ updatePosition must be called manually, prior to reading the tracer coordinates.
|
|
|
+*/
|
|
|
+
|
|
|
+/*!
|
|
|
+ Creates a tracer item and sets default values.
|
|
|
+
|
|
|
+ The created item is automatically registered with \a parentPlot. This QCustomPlot instance takes
|
|
|
+ ownership of the item, so do not delete it manually but use QCustomPlot::removeItem() instead.
|
|
|
+*/
|
|
|
+QCPItemTracer::QCPItemTracer(QCustomPlot *parentPlot) :
|
|
|
+ QCPAbstractItem(parentPlot),
|
|
|
+ position(createPosition(QLatin1String("position"))),
|
|
|
+ mSize(6),
|
|
|
+ mStyle(tsCrosshair),
|
|
|
+ mGraph(0),
|
|
|
+ mGraphKey(0),
|
|
|
+ mInterpolating(false)
|
|
|
+{
|
|
|
+ position->setCoords(0, 0);
|
|
|
+
|
|
|
+ setBrush(Qt::NoBrush);
|
|
|
+ setSelectedBrush(Qt::NoBrush);
|
|
|
+ setPen(QPen(Qt::black));
|
|
|
+ setSelectedPen(QPen(Qt::blue, 2));
|
|
|
+}
|
|
|
+
|
|
|
+QCPItemTracer::~QCPItemTracer()
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the pen that will be used to draw the line of the tracer
|
|
|
+
|
|
|
+ \see setSelectedPen, setBrush
|
|
|
+*/
|
|
|
+void QCPItemTracer::setPen(const QPen &pen)
|
|
|
+{
|
|
|
+ mPen = pen;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the pen that will be used to draw the line of the tracer when selected
|
|
|
+
|
|
|
+ \see setPen, setSelected
|
|
|
+*/
|
|
|
+void QCPItemTracer::setSelectedPen(const QPen &pen)
|
|
|
+{
|
|
|
+ mSelectedPen = pen;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the brush that will be used to draw any fills of the tracer
|
|
|
+
|
|
|
+ \see setSelectedBrush, setPen
|
|
|
+*/
|
|
|
+void QCPItemTracer::setBrush(const QBrush &brush)
|
|
|
+{
|
|
|
+ mBrush = brush;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the brush that will be used to draw any fills of the tracer, when selected.
|
|
|
+
|
|
|
+ \see setBrush, setSelected
|
|
|
+*/
|
|
|
+void QCPItemTracer::setSelectedBrush(const QBrush &brush)
|
|
|
+{
|
|
|
+ mSelectedBrush = brush;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the size of the tracer in pixels, if the style supports setting a size (e.g. \ref tsSquare
|
|
|
+ does, \ref tsCrosshair does not).
|
|
|
+*/
|
|
|
+void QCPItemTracer::setSize(double size)
|
|
|
+{
|
|
|
+ mSize = size;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the style/visual appearance of the tracer.
|
|
|
+
|
|
|
+ If you only want to use the tracer \a position as an anchor for other items, set \a style to
|
|
|
+ \ref tsNone.
|
|
|
+*/
|
|
|
+void QCPItemTracer::setStyle(QCPItemTracer::TracerStyle style)
|
|
|
+{
|
|
|
+ mStyle = style;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the QCPGraph this tracer sticks to. The tracer \a position will be set to type
|
|
|
+ QCPItemPosition::ptPlotCoords and the axes will be set to the axes of \a graph.
|
|
|
+
|
|
|
+ To free the tracer from any graph, set \a graph to 0. The tracer \a position can then be placed
|
|
|
+ freely like any other item position. This is the state the tracer will assume when its graph gets
|
|
|
+ deleted while still attached to it.
|
|
|
+
|
|
|
+ \see setGraphKey
|
|
|
+*/
|
|
|
+void QCPItemTracer::setGraph(QCPGraph *graph)
|
|
|
+{
|
|
|
+ if (graph)
|
|
|
+ {
|
|
|
+ if (graph->parentPlot() == mParentPlot)
|
|
|
+ {
|
|
|
+ position->setType(QCPItemPosition::ptPlotCoords);
|
|
|
+ position->setAxes(graph->keyAxis(), graph->valueAxis());
|
|
|
+ mGraph = graph;
|
|
|
+ updatePosition();
|
|
|
+ } else
|
|
|
+ qDebug() << Q_FUNC_INFO << "graph isn't in same QCustomPlot instance as this item";
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ mGraph = 0;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the key of the graph's data point the tracer will be positioned at. This is the only free
|
|
|
+ coordinate of a tracer when attached to a graph.
|
|
|
+
|
|
|
+ Depending on \ref setInterpolating, the tracer will be either positioned on the data point
|
|
|
+ closest to \a key, or will stay exactly at \a key and interpolate the value linearly.
|
|
|
+
|
|
|
+ \see setGraph, setInterpolating
|
|
|
+*/
|
|
|
+void QCPItemTracer::setGraphKey(double key)
|
|
|
+{
|
|
|
+ mGraphKey = key;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets whether the value of the graph's data points shall be interpolated, when positioning the
|
|
|
+ tracer.
|
|
|
+
|
|
|
+ If \a enabled is set to false and a key is given with \ref setGraphKey, the tracer is placed on
|
|
|
+ the data point of the graph which is closest to the key, but which is not necessarily exactly
|
|
|
+ there. If \a enabled is true, the tracer will be positioned exactly at the specified key, and
|
|
|
+ the appropriate value will be interpolated from the graph's data points linearly.
|
|
|
+
|
|
|
+ \see setGraph, setGraphKey
|
|
|
+*/
|
|
|
+void QCPItemTracer::setInterpolating(bool enabled)
|
|
|
+{
|
|
|
+ mInterpolating = enabled;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+double QCPItemTracer::selectTest(const QPointF &pos, bool onlySelectable, QVariant *details) const
|
|
|
+{
|
|
|
+ Q_UNUSED(details)
|
|
|
+ if (onlySelectable && !mSelectable)
|
|
|
+ return -1;
|
|
|
+
|
|
|
+ QPointF center(position->pixelPosition());
|
|
|
+ double w = mSize/2.0;
|
|
|
+ QRect clip = clipRect();
|
|
|
+ switch (mStyle)
|
|
|
+ {
|
|
|
+ case tsNone: return -1;
|
|
|
+ case tsPlus:
|
|
|
+ {
|
|
|
+ if (clipRect().intersects(QRectF(center-QPointF(w, w), center+QPointF(w, w)).toRect()))
|
|
|
+ return qSqrt(qMin(QCPVector2D(pos).distanceSquaredToLine(center+QPointF(-w, 0), center+QPointF(w, 0)),
|
|
|
+ QCPVector2D(pos).distanceSquaredToLine(center+QPointF(0, -w), center+QPointF(0, w))));
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case tsCrosshair:
|
|
|
+ {
|
|
|
+ return qSqrt(qMin(QCPVector2D(pos).distanceSquaredToLine(QCPVector2D(clip.left(), center.y()), QCPVector2D(clip.right(), center.y())),
|
|
|
+ QCPVector2D(pos).distanceSquaredToLine(QCPVector2D(center.x(), clip.top()), QCPVector2D(center.x(), clip.bottom()))));
|
|
|
+ }
|
|
|
+ case tsCircle:
|
|
|
+ {
|
|
|
+ if (clip.intersects(QRectF(center-QPointF(w, w), center+QPointF(w, w)).toRect()))
|
|
|
+ {
|
|
|
+ // distance to border:
|
|
|
+ double centerDist = QCPVector2D(center-pos).length();
|
|
|
+ double circleLine = w;
|
|
|
+ double result = qAbs(centerDist-circleLine);
|
|
|
+ // filled ellipse, allow click inside to count as hit:
|
|
|
+ if (result > mParentPlot->selectionTolerance()*0.99 && mBrush.style() != Qt::NoBrush && mBrush.color().alpha() != 0)
|
|
|
+ {
|
|
|
+ if (centerDist <= circleLine)
|
|
|
+ result = mParentPlot->selectionTolerance()*0.99;
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case tsSquare:
|
|
|
+ {
|
|
|
+ if (clip.intersects(QRectF(center-QPointF(w, w), center+QPointF(w, w)).toRect()))
|
|
|
+ {
|
|
|
+ QRectF rect = QRectF(center-QPointF(w, w), center+QPointF(w, w));
|
|
|
+ bool filledRect = mBrush.style() != Qt::NoBrush && mBrush.color().alpha() != 0;
|
|
|
+ return rectDistance(rect, pos, filledRect);
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return -1;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPItemTracer::draw(QCPPainter *painter)
|
|
|
+{
|
|
|
+ updatePosition();
|
|
|
+ if (mStyle == tsNone)
|
|
|
+ return;
|
|
|
+
|
|
|
+ painter->setPen(mainPen());
|
|
|
+ painter->setBrush(mainBrush());
|
|
|
+ QPointF center(position->pixelPosition());
|
|
|
+ double w = mSize/2.0;
|
|
|
+ QRect clip = clipRect();
|
|
|
+ switch (mStyle)
|
|
|
+ {
|
|
|
+ case tsNone: return;
|
|
|
+ case tsPlus:
|
|
|
+ {
|
|
|
+ if (clip.intersects(QRectF(center-QPointF(w, w), center+QPointF(w, w)).toRect()))
|
|
|
+ {
|
|
|
+ painter->drawLine(QLineF(center+QPointF(-w, 0), center+QPointF(w, 0)));
|
|
|
+ painter->drawLine(QLineF(center+QPointF(0, -w), center+QPointF(0, w)));
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case tsCrosshair:
|
|
|
+ {
|
|
|
+ if (center.y() > clip.top() && center.y() < clip.bottom())
|
|
|
+ painter->drawLine(QLineF(clip.left(), center.y(), clip.right(), center.y()));
|
|
|
+ if (center.x() > clip.left() && center.x() < clip.right())
|
|
|
+ painter->drawLine(QLineF(center.x(), clip.top(), center.x(), clip.bottom()));
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case tsCircle:
|
|
|
+ {
|
|
|
+ if (clip.intersects(QRectF(center-QPointF(w, w), center+QPointF(w, w)).toRect()))
|
|
|
+ painter->drawEllipse(center, w, w);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case tsSquare:
|
|
|
+ {
|
|
|
+ if (clip.intersects(QRectF(center-QPointF(w, w), center+QPointF(w, w)).toRect()))
|
|
|
+ painter->drawRect(QRectF(center-QPointF(w, w), center+QPointF(w, w)));
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ If the tracer is connected with a graph (\ref setGraph), this function updates the tracer's \a
|
|
|
+ position to reside on the graph data, depending on the configured key (\ref setGraphKey).
|
|
|
+
|
|
|
+ It is called automatically on every redraw and normally doesn't need to be called manually. One
|
|
|
+ exception is when you want to read the tracer coordinates via \a position and are not sure that
|
|
|
+ the graph's data (or the tracer key with \ref setGraphKey) hasn't changed since the last redraw.
|
|
|
+ In that situation, call this function before accessing \a position, to make sure you don't get
|
|
|
+ out-of-date coordinates.
|
|
|
+
|
|
|
+ If there is no graph set on this tracer, this function does nothing.
|
|
|
+*/
|
|
|
+void QCPItemTracer::updatePosition()
|
|
|
+{
|
|
|
+ if (mGraph)
|
|
|
+ {
|
|
|
+ if (mParentPlot->hasPlottable(mGraph))
|
|
|
+ {
|
|
|
+ if (mGraph->data()->size() > 1)
|
|
|
+ {
|
|
|
+ QCPGraphDataContainer::const_iterator first = mGraph->data()->constBegin();
|
|
|
+ QCPGraphDataContainer::const_iterator last = mGraph->data()->constEnd()-1;
|
|
|
+ if (mGraphKey <= first->key)
|
|
|
+ position->setCoords(first->key, first->value);
|
|
|
+ else if (mGraphKey >= last->key)
|
|
|
+ position->setCoords(last->key, last->value);
|
|
|
+ else
|
|
|
+ {
|
|
|
+ QCPGraphDataContainer::const_iterator it = mGraph->data()->findBegin(mGraphKey);
|
|
|
+ if (it != mGraph->data()->constEnd()) // mGraphKey is not exactly on last iterator, but somewhere between iterators
|
|
|
+ {
|
|
|
+ QCPGraphDataContainer::const_iterator prevIt = it;
|
|
|
+ ++it; // won't advance to constEnd because we handled that case (mGraphKey >= last->key) before
|
|
|
+ if (mInterpolating)
|
|
|
+ {
|
|
|
+ // interpolate between iterators around mGraphKey:
|
|
|
+ double slope = 0;
|
|
|
+ if (!qFuzzyCompare((double)it->key, (double)prevIt->key))
|
|
|
+ slope = (it->value-prevIt->value)/(it->key-prevIt->key);
|
|
|
+ position->setCoords(mGraphKey, (mGraphKey-prevIt->key)*slope+prevIt->value);
|
|
|
+ } else
|
|
|
+ {
|
|
|
+ // find iterator with key closest to mGraphKey:
|
|
|
+ if (mGraphKey < (prevIt->key+it->key)*0.5)
|
|
|
+ position->setCoords(prevIt->key, prevIt->value);
|
|
|
+ else
|
|
|
+ position->setCoords(it->key, it->value);
|
|
|
+ }
|
|
|
+ } else // mGraphKey is exactly on last iterator (should actually be caught when comparing first/last keys, but this is a failsafe for fp uncertainty)
|
|
|
+ position->setCoords(it->key, it->value);
|
|
|
+ }
|
|
|
+ } else if (mGraph->data()->size() == 1)
|
|
|
+ {
|
|
|
+ QCPGraphDataContainer::const_iterator it = mGraph->data()->constBegin();
|
|
|
+ position->setCoords(it->key, it->value);
|
|
|
+ } else
|
|
|
+ qDebug() << Q_FUNC_INFO << "graph has no data";
|
|
|
+ } else
|
|
|
+ qDebug() << Q_FUNC_INFO << "graph not contained in QCustomPlot instance (anymore)";
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the pen that should be used for drawing lines. Returns mPen when the item is not selected
|
|
|
+ and mSelectedPen when it is.
|
|
|
+*/
|
|
|
+QPen QCPItemTracer::mainPen() const
|
|
|
+{
|
|
|
+ return mSelected ? mSelectedPen : mPen;
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the brush that should be used for drawing fills of the item. Returns mBrush when the item
|
|
|
+ is not selected and mSelectedBrush when it is.
|
|
|
+*/
|
|
|
+QBrush QCPItemTracer::mainBrush() const
|
|
|
+{
|
|
|
+ return mSelected ? mSelectedBrush : mBrush;
|
|
|
+}
|
|
|
+/* end of 'src/items/item-tracer.cpp' */
|
|
|
+
|
|
|
+
|
|
|
+/* including file 'src/items/item-bracket.cpp', size 10687 */
|
|
|
+/* commit 9868e55d3b412f2f89766bb482fcf299e93a0988 2017-09-04 01:56:22 +0200 */
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//////////////////// QCPItemBracket
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+/*! \class QCPItemBracket
|
|
|
+ \brief A bracket for referencing/highlighting certain parts in the plot.
|
|
|
+
|
|
|
+ \image html QCPItemBracket.png "Bracket example. Blue dotted circles are anchors, solid blue discs are positions."
|
|
|
+
|
|
|
+ It has two positions, \a left and \a right, which define the span of the bracket. If \a left is
|
|
|
+ actually farther to the left than \a right, the bracket is opened to the bottom, as shown in the
|
|
|
+ example image.
|
|
|
+
|
|
|
+ The bracket supports multiple styles via \ref setStyle. The length, i.e. how far the bracket
|
|
|
+ stretches away from the embraced span, can be controlled with \ref setLength.
|
|
|
+
|
|
|
+ \image html QCPItemBracket-length.png
|
|
|
+ <center>Demonstrating the effect of different values for \ref setLength, for styles \ref
|
|
|
+ bsCalligraphic and \ref bsSquare. Anchors and positions are displayed for reference.</center>
|
|
|
+
|
|
|
+ It provides an anchor \a center, to allow connection of other items, e.g. an arrow (QCPItemLine
|
|
|
+ or QCPItemCurve) or a text label (QCPItemText), to the bracket.
|
|
|
+*/
|
|
|
+
|
|
|
+/*!
|
|
|
+ Creates a bracket item and sets default values.
|
|
|
+
|
|
|
+ The created item is automatically registered with \a parentPlot. This QCustomPlot instance takes
|
|
|
+ ownership of the item, so do not delete it manually but use QCustomPlot::removeItem() instead.
|
|
|
+*/
|
|
|
+QCPItemBracket::QCPItemBracket(QCustomPlot *parentPlot) :
|
|
|
+ QCPAbstractItem(parentPlot),
|
|
|
+ left(createPosition(QLatin1String("left"))),
|
|
|
+ right(createPosition(QLatin1String("right"))),
|
|
|
+ center(createAnchor(QLatin1String("center"), aiCenter)),
|
|
|
+ mLength(8),
|
|
|
+ mStyle(bsCalligraphic)
|
|
|
+{
|
|
|
+ left->setCoords(0, 0);
|
|
|
+ right->setCoords(1, 1);
|
|
|
+
|
|
|
+ setPen(QPen(Qt::black));
|
|
|
+ setSelectedPen(QPen(Qt::blue, 2));
|
|
|
+}
|
|
|
+
|
|
|
+QCPItemBracket::~QCPItemBracket()
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the pen that will be used to draw the bracket.
|
|
|
+
|
|
|
+ Note that when the style is \ref bsCalligraphic, only the color will be taken from the pen, the
|
|
|
+ stroke and width are ignored. To change the apparent stroke width of a calligraphic bracket, use
|
|
|
+ \ref setLength, which has a similar effect.
|
|
|
+
|
|
|
+ \see setSelectedPen
|
|
|
+*/
|
|
|
+void QCPItemBracket::setPen(const QPen &pen)
|
|
|
+{
|
|
|
+ mPen = pen;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the pen that will be used to draw the bracket when selected
|
|
|
+
|
|
|
+ \see setPen, setSelected
|
|
|
+*/
|
|
|
+void QCPItemBracket::setSelectedPen(const QPen &pen)
|
|
|
+{
|
|
|
+ mSelectedPen = pen;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the \a length in pixels how far the bracket extends in the direction towards the embraced
|
|
|
+ span of the bracket (i.e. perpendicular to the <i>left</i>-<i>right</i>-direction)
|
|
|
+
|
|
|
+ \image html QCPItemBracket-length.png
|
|
|
+ <center>Demonstrating the effect of different values for \ref setLength, for styles \ref
|
|
|
+ bsCalligraphic and \ref bsSquare. Anchors and positions are displayed for reference.</center>
|
|
|
+*/
|
|
|
+void QCPItemBracket::setLength(double length)
|
|
|
+{
|
|
|
+ mLength = length;
|
|
|
+}
|
|
|
+
|
|
|
+/*!
|
|
|
+ Sets the style of the bracket, i.e. the shape/visual appearance.
|
|
|
+
|
|
|
+ \see setPen
|
|
|
+*/
|
|
|
+void QCPItemBracket::setStyle(QCPItemBracket::BracketStyle style)
|
|
|
+{
|
|
|
+ mStyle = style;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+double QCPItemBracket::selectTest(const QPointF &pos, bool onlySelectable, QVariant *details) const
|
|
|
+{
|
|
|
+ Q_UNUSED(details)
|
|
|
+ if (onlySelectable && !mSelectable)
|
|
|
+ return -1;
|
|
|
+
|
|
|
+ QCPVector2D p(pos);
|
|
|
+ QCPVector2D leftVec(left->pixelPosition());
|
|
|
+ QCPVector2D rightVec(right->pixelPosition());
|
|
|
+ if (leftVec.toPoint() == rightVec.toPoint())
|
|
|
+ return -1;
|
|
|
+
|
|
|
+ QCPVector2D widthVec = (rightVec-leftVec)*0.5;
|
|
|
+ QCPVector2D lengthVec = widthVec.perpendicular().normalized()*mLength;
|
|
|
+ QCPVector2D centerVec = (rightVec+leftVec)*0.5-lengthVec;
|
|
|
+
|
|
|
+ switch (mStyle)
|
|
|
+ {
|
|
|
+ case QCPItemBracket::bsSquare:
|
|
|
+ case QCPItemBracket::bsRound:
|
|
|
+ {
|
|
|
+ double a = p.distanceSquaredToLine(centerVec-widthVec, centerVec+widthVec);
|
|
|
+ double b = p.distanceSquaredToLine(centerVec-widthVec+lengthVec, centerVec-widthVec);
|
|
|
+ double c = p.distanceSquaredToLine(centerVec+widthVec+lengthVec, centerVec+widthVec);
|
|
|
+ return qSqrt(qMin(qMin(a, b), c));
|
|
|
+ }
|
|
|
+ case QCPItemBracket::bsCurly:
|
|
|
+ case QCPItemBracket::bsCalligraphic:
|
|
|
+ {
|
|
|
+ double a = p.distanceSquaredToLine(centerVec-widthVec*0.75+lengthVec*0.15, centerVec+lengthVec*0.3);
|
|
|
+ double b = p.distanceSquaredToLine(centerVec-widthVec+lengthVec*0.7, centerVec-widthVec*0.75+lengthVec*0.15);
|
|
|
+ double c = p.distanceSquaredToLine(centerVec+widthVec*0.75+lengthVec*0.15, centerVec+lengthVec*0.3);
|
|
|
+ double d = p.distanceSquaredToLine(centerVec+widthVec+lengthVec*0.7, centerVec+widthVec*0.75+lengthVec*0.15);
|
|
|
+ return qSqrt(qMin(qMin(a, b), qMin(c, d)));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return -1;
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+void QCPItemBracket::draw(QCPPainter *painter)
|
|
|
+{
|
|
|
+ QCPVector2D leftVec(left->pixelPosition());
|
|
|
+ QCPVector2D rightVec(right->pixelPosition());
|
|
|
+ if (leftVec.toPoint() == rightVec.toPoint())
|
|
|
+ return;
|
|
|
+
|
|
|
+ QCPVector2D widthVec = (rightVec-leftVec)*0.5;
|
|
|
+ QCPVector2D lengthVec = widthVec.perpendicular().normalized()*mLength;
|
|
|
+ QCPVector2D centerVec = (rightVec+leftVec)*0.5-lengthVec;
|
|
|
+
|
|
|
+ QPolygon boundingPoly;
|
|
|
+ boundingPoly << leftVec.toPoint() << rightVec.toPoint()
|
|
|
+ << (rightVec-lengthVec).toPoint() << (leftVec-lengthVec).toPoint();
|
|
|
+ QRect clip = clipRect().adjusted(-mainPen().widthF(), -mainPen().widthF(), mainPen().widthF(), mainPen().widthF());
|
|
|
+ if (clip.intersects(boundingPoly.boundingRect()))
|
|
|
+ {
|
|
|
+ painter->setPen(mainPen());
|
|
|
+ switch (mStyle)
|
|
|
+ {
|
|
|
+ case bsSquare:
|
|
|
+ {
|
|
|
+ painter->drawLine((centerVec+widthVec).toPointF(), (centerVec-widthVec).toPointF());
|
|
|
+ painter->drawLine((centerVec+widthVec).toPointF(), (centerVec+widthVec+lengthVec).toPointF());
|
|
|
+ painter->drawLine((centerVec-widthVec).toPointF(), (centerVec-widthVec+lengthVec).toPointF());
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case bsRound:
|
|
|
+ {
|
|
|
+ painter->setBrush(Qt::NoBrush);
|
|
|
+ QPainterPath path;
|
|
|
+ path.moveTo((centerVec+widthVec+lengthVec).toPointF());
|
|
|
+ path.cubicTo((centerVec+widthVec).toPointF(), (centerVec+widthVec).toPointF(), centerVec.toPointF());
|
|
|
+ path.cubicTo((centerVec-widthVec).toPointF(), (centerVec-widthVec).toPointF(), (centerVec-widthVec+lengthVec).toPointF());
|
|
|
+ painter->drawPath(path);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case bsCurly:
|
|
|
+ {
|
|
|
+ painter->setBrush(Qt::NoBrush);
|
|
|
+ QPainterPath path;
|
|
|
+ path.moveTo((centerVec+widthVec+lengthVec).toPointF());
|
|
|
+ path.cubicTo((centerVec+widthVec-lengthVec*0.8).toPointF(), (centerVec+0.4*widthVec+lengthVec).toPointF(), centerVec.toPointF());
|
|
|
+ path.cubicTo((centerVec-0.4*widthVec+lengthVec).toPointF(), (centerVec-widthVec-lengthVec*0.8).toPointF(), (centerVec-widthVec+lengthVec).toPointF());
|
|
|
+ painter->drawPath(path);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ case bsCalligraphic:
|
|
|
+ {
|
|
|
+ painter->setPen(Qt::NoPen);
|
|
|
+ painter->setBrush(QBrush(mainPen().color()));
|
|
|
+ QPainterPath path;
|
|
|
+ path.moveTo((centerVec+widthVec+lengthVec).toPointF());
|
|
|
+
|
|
|
+ path.cubicTo((centerVec+widthVec-lengthVec*0.8).toPointF(), (centerVec+0.4*widthVec+0.8*lengthVec).toPointF(), centerVec.toPointF());
|
|
|
+ path.cubicTo((centerVec-0.4*widthVec+0.8*lengthVec).toPointF(), (centerVec-widthVec-lengthVec*0.8).toPointF(), (centerVec-widthVec+lengthVec).toPointF());
|
|
|
+
|
|
|
+ path.cubicTo((centerVec-widthVec-lengthVec*0.5).toPointF(), (centerVec-0.2*widthVec+1.2*lengthVec).toPointF(), (centerVec+lengthVec*0.2).toPointF());
|
|
|
+ path.cubicTo((centerVec+0.2*widthVec+1.2*lengthVec).toPointF(), (centerVec+widthVec-lengthVec*0.5).toPointF(), (centerVec+widthVec+lengthVec).toPointF());
|
|
|
+
|
|
|
+ painter->drawPath(path);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/* inherits documentation from base class */
|
|
|
+QPointF QCPItemBracket::anchorPixelPosition(int anchorId) const
|
|
|
+{
|
|
|
+ QCPVector2D leftVec(left->pixelPosition());
|
|
|
+ QCPVector2D rightVec(right->pixelPosition());
|
|
|
+ if (leftVec.toPoint() == rightVec.toPoint())
|
|
|
+ return leftVec.toPointF();
|
|
|
+
|
|
|
+ QCPVector2D widthVec = (rightVec-leftVec)*0.5;
|
|
|
+ QCPVector2D lengthVec = widthVec.perpendicular().normalized()*mLength;
|
|
|
+ QCPVector2D centerVec = (rightVec+leftVec)*0.5-lengthVec;
|
|
|
+
|
|
|
+ switch (anchorId)
|
|
|
+ {
|
|
|
+ case aiCenter:
|
|
|
+ return centerVec.toPointF();
|
|
|
+ }
|
|
|
+ qDebug() << Q_FUNC_INFO << "invalid anchorId" << anchorId;
|
|
|
+ return QPointF();
|
|
|
+}
|
|
|
+
|
|
|
+/*! \internal
|
|
|
+
|
|
|
+ Returns the pen that should be used for drawing lines. Returns mPen when the
|
|
|
+ item is not selected and mSelectedPen when it is.
|
|
|
+*/
|
|
|
+QPen QCPItemBracket::mainPen() const
|
|
|
+{
|
|
|
+ return mSelected ? mSelectedPen : mPen;
|
|
|
+}
|
|
|
+/* end of 'src/items/item-bracket.cpp' */
|
|
|
+
|
|
|
+
|
