GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r653:ec050eaa9816

QCustomPlot update to the latest version on upstream repo....

jeandet -

r653:ec050eaa9816

parent child

Context file:

r653:ec050eaa9816

gui/include/Visualization/qcustomplot.h +104 -64

             #if QT_VERSION >= QT_VERSION_CHECK(5, 4, 0)
             #define QCP_DEVICEPIXELRATIO_SUPPORTED
+            #if QT_VERSION >= QT_VERSION_CHECK(5, 6, 0)
+            #define QCP_DEVICEPIXELRATIO_FLOAT
+            #endif
             #endif
             #include <QtCore/QCache>
             class QCPColorScale;
             class QCPBars;
-            /* including file 'src/global.h', size 16131                                 */
+            /* including file 'src/global.h', size 16225                                 */
-            /* commit 633339dadc92cb10c58ef3556b55570685fafb99 2016-09-13 23:54:56 +0200 */
+            /* commit e7c6a5540d344a96d107dce53f9d4414a09a7320 2017-07-25 00:52:29 +0200 */
             // decl definitions for shared library compilation/usage:
             #if defined(QCUSTOMPLOT_COMPILE_LIBRARY)
             /* end of 'src/axis/axistickerdatetime.h' */
-            /* including file 'src/axis/axistickertime.h', size 3288                     */
+            /* including file 'src/axis/axistickertime.h', size 3542                     */
-            /* commit 633339dadc92cb10c58ef3556b55570685fafb99 2016-09-13 23:54:56 +0200 */
+            /* commit c38adb94d83c6a752597a5d43d45c0561fbe1d4d 2017-08-13 17:37:53 +0200 */
             class QCP_LIB_DECL QCPAxisTickerTime : public QCPAxisTicker {
                 Q_GADGET
                   \see setFieldWidth, setTimeFormat
                 */
-                enum TimeUnit { tuMilliseconds, tuSeconds, tuMinutes, tuHours, tuDays };
+                enum TimeUnit {
+                    tuMilliseconds ///< Milliseconds, one thousandth of a second (%%z in \ref setTimeFormat)
+                    ,
+                    tuSeconds ///< Seconds (%%s in \ref setTimeFormat)
+                    ,
+                    tuMinutes ///< Minutes (%%m in \ref setTimeFormat)
+                    ,
+                    tuHours ///< Hours (%%h in \ref setTimeFormat)
+                    ,
+                    tuDays ///< Days (%%d in \ref setTimeFormat)
+                };
                 Q_ENUMS(TimeUnit)
                 QCPAxisTickerTime();
             /* end of 'src/axis/axistickerlog.h' */
-            /* including file 'src/axis/axis.h', size 20230                              */
+            /* including file 'src/axis/axis.h', size 20634                              */
-            /* commit 633339dadc92cb10c58ef3556b55570685fafb99 2016-09-13 23:54:56 +0200 */
+            /* commit 0cc4d9f61f7bf45321a88fec89d909b020ffa26f 2017-08-14 00:43:29 +0200 */
             class QCP_LIB_DECL QCPGrid : public QCPLayerable {
                 Q_OBJECT
                 QVector<double> mSubTickVector;
                 bool mCachedMarginValid;
                 int mCachedMargin;
+                bool mDragging;
+                QCPRange mDragStartRange;
+                QCP::AntialiasedElements mAADragBackup, mNotAADragBackup;
                 // introduced virtual methods:
                 virtual int calculateMargin();
                 virtual void selectEvent(QMouseEvent *event, bool additive, const QVariant &details,
                                          bool *selectionStateChanged) Q_DECL_OVERRIDE;
                 virtual void deselectEvent(bool *selectionStateChanged) Q_DECL_OVERRIDE;
+                // mouse events:
+                virtual void mousePressEvent(QMouseEvent *event, const QVariant &details);
+                virtual void mouseMoveEvent(QMouseEvent *event, const QPointF &startPos);
+                virtual void mouseReleaseEvent(QMouseEvent *event, const QPointF &startPos);
+                virtual void wheelEvent(QWheelEvent *event);
                 // non-virtual methods:
                 void setupTickVectors();
             /* end of 'src/scatterstyle.h' */
-            /* including file 'src/datacontainer.h', size 4535                           */
+            /* including file 'src/datacontainer.h', size 4596                           */
-            /* commit 633339dadc92cb10c58ef3556b55570685fafb99 2016-09-13 23:54:56 +0200 */
+            /* commit bee82298bd87b91a50093fb0b81cd7c734724a6f 2017-08-13 16:10:24 +0200 */
             /*! \relates QCPDataContainer
               Returns whether the sort key of \a a is less than the sort key of \a b.
             }
             template <class DataType>
-            class QCP_LIB_DECL QCPDataContainer {
+            class QCPDataContainer // no QCP_LIB_DECL, template class ends up in header (cpp included below)
+            {
             public:
                 typedef typename QVector<DataType>::const_iterator const_iterator;
                 typedef typename QVector<DataType>::iterator iterator;
             // include implementation in header since it is a class template:
-            /* including file 'src/datacontainer.cpp', size 31224                        */
+            /* including file 'src/datacontainer.cpp', size 31349                        */
-            /* commit 633339dadc92cb10c58ef3556b55570685fafb99 2016-09-13 23:54:56 +0200 */
+            /* commit 820d2282db70144c358c13433cd74b4175f9252b 2017-07-24 00:24:17 +0200 */
             ////////////////////////////////////////////////////////////////////////////////////////////////////
             //////////////////// QCPDataContainer
             /*!
               Makes sure \a begin and \a end mark a data range that is both within the bounds of this data
-              container's data, as well as within the specified \a dataRange.
+              container's data, as well as within the specified \a dataRange. The initial range described by
+              the passed iterators \a begin and \a end is never expanded, only contracted if necessary.
               This function doesn't require for \a dataRange to be within the bounds of this data container's
               valid range.
             /* end of 'src/plottable.h' */
-            /* including file 'src/item.h', size 9368                                    */
+            /* including file 'src/item.h', size 9384                                    */
-            /* commit 633339dadc92cb10c58ef3556b55570685fafb99 2016-09-13 23:54:56 +0200 */
+            /* commit 681a87c5e5365a5c7187d20b4077031003c48449 2017-07-23 23:46:48 +0200 */
             class QCP_LIB_DECL QCPItemAnchor {
                 Q_GADGET
                 QCPAxis *keyAxis() const { return mKeyAxis.data(); }
                 QCPAxis *valueAxis() const { return mValueAxis.data(); }
                 QCPAxisRect *axisRect() const;
-                virtual QPointF pixelPosition() const;
+                virtual QPointF pixelPosition() const Q_DECL_OVERRIDE;
                 // setters:
                 void setType(PositionType type);
             /* end of 'src/item.h' */
-            /* including file 'src/core.h', size 14797                                   */
+            /* including file 'src/core.h', size 14886                                   */
-            /* commit 633339dadc92cb10c58ef3556b55570685fafb99 2016-09-13 23:54:56 +0200 */
+            /* commit 29aafbce469a36d175d4fb32cbfd1f50a6072890 2016-10-12 19:21:24 +0200 */
             class QCP_LIB_DECL QCustomPlot : public QWidget {
                 Q_OBJECT
                 QPoint mMousePressPos;
                 bool mMouseHasMoved;
                 QPointer<QCPLayerable> mMouseEventLayerable;
+                QPointer<QCPLayerable> mMouseSignalLayerable;
                 QVariant mMouseEventLayerableDetails;
+                QVariant mMouseSignalLayerableDetails;
                 bool mReplotting;
                 bool mReplotQueued;
                 int mOpenGlMultisamples;
             /* end of 'src/core.h' */
-            /* including file 'src/plottable1d.h', size 4250                             */
+            /* including file 'src/plottable1d.h', size 4544                             */
-            /* commit 633339dadc92cb10c58ef3556b55570685fafb99 2016-09-13 23:54:56 +0200 */
+            /* commit bee82298bd87b91a50093fb0b81cd7c734724a6f 2017-08-13 16:10:24 +0200 */
-            class QCP_LIB_DECL QCPPlottableInterface1D {
+            class QCPPlottableInterface1D {
             public:
+                virtual ~QCPPlottableInterface1D() {}
                 // introduced pure virtual methods:
                 virtual int dataCount() const = 0;
                 virtual double dataMainKey(int index) const = 0;
             };
             template <class DataType>
-            class QCP_LIB_DECL QCPAbstractPlottable1D : public QCPAbstractPlottable,
+            class QCPAbstractPlottable1D : public QCPAbstractPlottable,
-                                                        public QCPPlottableInterface1D {
+                                           public QCPPlottableInterface1D // no QCP_LIB_DECL, template class
+                                                                          // ends up in header (cpp included
+                                                                          // below)
+            {
                 // No Q_OBJECT macro due to template class
             public:
                 virtual ~QCPAbstractPlottable1D();
                 // virtual methods of 1d plottable interface:
-                virtual int dataCount() const;
+                virtual int dataCount() const Q_DECL_OVERRIDE;
-                virtual double dataMainKey(int index) const;
+                virtual double dataMainKey(int index) const Q_DECL_OVERRIDE;
-                virtual double dataSortKey(int index) const;
+                virtual double dataSortKey(int index) const Q_DECL_OVERRIDE;
-                virtual double dataMainValue(int index) const;
+                virtual double dataMainValue(int index) const Q_DECL_OVERRIDE;
-                virtual QCPRange dataValueRange(int index) const;
+                virtual QCPRange dataValueRange(int index) const Q_DECL_OVERRIDE;
-                virtual QPointF dataPixelPosition(int index) const;
+                virtual QPointF dataPixelPosition(int index) const Q_DECL_OVERRIDE;
-                virtual bool sortKeyIsMainKey() const;
+                virtual bool sortKeyIsMainKey() const Q_DECL_OVERRIDE;
-                virtual QCPDataSelection selectTestRect(const QRectF &rect, bool onlySelectable) const;
+                virtual QCPDataSelection selectTestRect(const QRectF &rect,
-                virtual int findBegin(double sortKey, bool expandedRange = true) const;
+                                                        bool onlySelectable) const Q_DECL_OVERRIDE;
-                virtual int findEnd(double sortKey, bool expandedRange = true) const;
+                virtual int findBegin(double sortKey, bool expandedRange = true) const Q_DECL_OVERRIDE;
+                virtual int findEnd(double sortKey, bool expandedRange = true) const Q_DECL_OVERRIDE;
-                // virtual methods:
+                // reimplemented virtual methods:
-                virtual double selectTest(const QPointF &pos, bool onlySelectable, QVariant *details = 0) const;
+                virtual double selectTest(const QPointF &pos, bool onlySelectable,
-                virtual QCPPlottableInterface1D *interface1D() { return this; }
+                                          QVariant *details = 0) const Q_DECL_OVERRIDE;
+                virtual QCPPlottableInterface1D *interface1D() Q_DECL_OVERRIDE { return this; }
             protected:
                 // property members:
             /* end of 'src/colorgradient.h' */
-            /* including file 'src/selectiondecorator-bracket.h', size 4426              */
+            /* including file 'src/selectiondecorator-bracket.h', size 4442              */
-            /* commit 633339dadc92cb10c58ef3556b55570685fafb99 2016-09-13 23:54:56 +0200 */
+            /* commit 681a87c5e5365a5c7187d20b4077031003c48449 2017-07-23 23:46:48 +0200 */
             class QCP_LIB_DECL QCPSelectionDecoratorBracket : public QCPSelectionDecorator {
                 Q_GADGET
                 virtual void drawBracket(QCPPainter *painter, int direction) const;
                 // virtual methods:
-                virtual void drawDecoration(QCPPainter *painter, QCPDataSelection selection);
+                virtual void drawDecoration(QCPPainter *painter, QCPDataSelection selection) Q_DECL_OVERRIDE;
             protected:
                 // property members:
             /* end of 'src/selectiondecorator-bracket.h' */
-            /* including file 'src/layoutelements/layoutelement-axisrect.h', size 7528   */
+            /* including file 'src/layoutelements/layoutelement-axisrect.h', size 7507   */
-            /* commit 633339dadc92cb10c58ef3556b55570685fafb99 2016-09-13 23:54:56 +0200 */
+            /* commit 77ba168312f935543fc31d1ae9b4cdcf34aae4f9 2017-08-13 18:29:48 +0200 */
             class QCP_LIB_DECL QCPAxisRect : public QCPLayoutElement {
                 Q_OBJECT
                 // non-property members:
                 QList<QCPRange> mDragStartHorzRange, mDragStartVertRange;
                 QCP::AntialiasedElements mAADragBackup, mNotAADragBackup;
-                QPoint mDragStart;
                 bool mDragging;
                 QHash<QCPAxis::AxisType, QList<QCPAxis *> > mAxes;
             /* end of 'src/layoutelements/layoutelement-textelement.h' */
-            /* including file 'src/layoutelements/layoutelement-colorscale.h', size 5907 */
+            /* including file 'src/layoutelements/layoutelement-colorscale.h', size 5923 */
-            /* commit 633339dadc92cb10c58ef3556b55570685fafb99 2016-09-13 23:54:56 +0200 */
+            /* commit 681a87c5e5365a5c7187d20b4077031003c48449 2017-07-23 23:46:48 +0200 */
             class QCPColorScaleAxisRectPrivate : public QCPAxisRect {
                 using QCPAxisRect::mouseReleaseEvent;
                 using QCPAxisRect::wheelEvent;
                 using QCPAxisRect::update;
-                virtual void draw(QCPPainter *painter);
+                virtual void draw(QCPPainter *painter) Q_DECL_OVERRIDE;
                 void updateGradientImage();
                 Q_SLOT void axisSelectionChanged(QCPAxis::SelectableParts selectedParts);
                 Q_SLOT void axisSelectableChanged(QCPAxis::SelectableParts selectableParts);
             /* end of 'src/layoutelements/layoutelement-colorscale.h' */
-            /* including file 'src/plottables/plottable-graph.h', size 8826              */
+            /* including file 'src/plottables/plottable-graph.h', size 9294              */
-            /* commit 633339dadc92cb10c58ef3556b55570685fafb99 2016-09-13 23:54:56 +0200 */
+            /* commit f3881770eaf7366171012ad01cad2aaf5f61dd27 2017-06-23 02:48:21 +0200 */
             class QCP_LIB_DECL QCPGraphData {
             public:
                 QVector<QPointF> dataToStepRightLines(const QVector<QCPGraphData> &data) const;
                 QVector<QPointF> dataToStepCenterLines(const QVector<QCPGraphData> &data) const;
                 QVector<QPointF> dataToImpulseLines(const QVector<QCPGraphData> &data) const;
-                void addFillBasePoints(QVector<QPointF> *lines) const;
+                QVector<QCPDataRange> getNonNanSegments(const QVector<QPointF> *lineData,
-                void removeFillBasePoints(QVector<QPointF> *lines) const;
+                                                        Qt::Orientation keyOrientation) const;
-                QPointF lowerFillBasePoint(double lowerKey) const;
+                QVector<QPair<QCPDataRange, QCPDataRange> >
-                QPointF upperFillBasePoint(double upperKey) const;
+                getOverlappingSegments(QVector<QCPDataRange> thisSegments, const QVector<QPointF> *thisData,
-                const QPolygonF getChannelFillPolygon(const QVector<QPointF> *lines) const;
+                                       QVector<QCPDataRange> otherSegments,
+                                       const QVector<QPointF> *otherData) const;
+                bool segmentsIntersect(double aLower, double aUpper, double bLower, double bUpper,
+                                       int &bPrecedence) const;
+                QPointF getFillBasePoint(QPointF matchingDataPoint) const;
+                const QPolygonF getFillPolygon(const QVector<QPointF> *lineData, QCPDataRange segment) const;
+                const QPolygonF getChannelFillPolygon(const QVector<QPointF> *lineData,
+                                                      QCPDataRange thisSegment,
+                                                      const QVector<QPointF> *otherData,
+                                                      QCPDataRange otherSegment) const;
                 int findIndexBelowX(const QVector<QPointF> *data, double x) const;
                 int findIndexAboveX(const QVector<QPointF> *data, double x) const;
                 int findIndexBelowY(const QVector<QPointF> *data, double y) const;
             /* end of 'src/plottables/plottable-financial.h' */
-            /* including file 'src/plottables/plottable-errorbar.h', size 7567           */
+            /* including file 'src/plottables/plottable-errorbar.h', size 7727           */
-            /* commit 633339dadc92cb10c58ef3556b55570685fafb99 2016-09-13 23:54:56 +0200 */
+            /* commit 681a87c5e5365a5c7187d20b4077031003c48449 2017-07-23 23:46:48 +0200 */
             class QCP_LIB_DECL QCPErrorBarsData {
             public:
                 void addData(double errorMinus, double errorPlus);
                 // virtual methods of 1d plottable interface:
-                virtual int dataCount() const;
+                virtual int dataCount() const Q_DECL_OVERRIDE;
-                virtual double dataMainKey(int index) const;
+                virtual double dataMainKey(int index) const Q_DECL_OVERRIDE;
-                virtual double dataSortKey(int index) const;
+                virtual double dataSortKey(int index) const Q_DECL_OVERRIDE;
-                virtual double dataMainValue(int index) const;
+                virtual double dataMainValue(int index) const Q_DECL_OVERRIDE;
-                virtual QCPRange dataValueRange(int index) const;
+                virtual QCPRange dataValueRange(int index) const Q_DECL_OVERRIDE;
-                virtual QPointF dataPixelPosition(int index) const;
+                virtual QPointF dataPixelPosition(int index) const Q_DECL_OVERRIDE;
-                virtual bool sortKeyIsMainKey() const;
+                virtual bool sortKeyIsMainKey() const Q_DECL_OVERRIDE;
-                virtual QCPDataSelection selectTestRect(const QRectF &rect, bool onlySelectable) const;
+                virtual QCPDataSelection selectTestRect(const QRectF &rect,
-                virtual int findBegin(double sortKey, bool expandedRange = true) const;
+                                                        bool onlySelectable) const Q_DECL_OVERRIDE;
-                virtual int findEnd(double sortKey, bool expandedRange = true) const;
+                virtual int findBegin(double sortKey, bool expandedRange = true) const Q_DECL_OVERRIDE;
+                virtual int findEnd(double sortKey, bool expandedRange = true) const Q_DECL_OVERRIDE;
                 // reimplemented virtual methods:
                 virtual double selectTest(const QPointF &pos, bool onlySelectable,

gui/src/Visualization/qcustomplot.cpp +839 -556

               \see initializeParentPlot
             */
-            void QCPLayerable::parentPlotInitialized(QCustomPlot *parentPlot)
+            void QCPLayerable::parentPlotInitialized(QCustomPlot *parentPlot){Q_UNUSED(parentPlot)}
-                Q_UNUSED(parentPlot)
             /*! \internal
             /* end of 'src/axis/range.cpp' */
-            /* including file 'src/selection.cpp', size 21898                            */
+            /* including file 'src/selection.cpp', size 21906                            */
-            /* commit 633339dadc92cb10c58ef3556b55570685fafb99 2016-09-13 23:54:56 +0200 */
+            /* commit 820d2282db70144c358c13433cd74b4175f9252b 2017-07-24 00:24:17 +0200 */
             ////////////////////////////////////////////////////////////////////////////////////////////////////
             //////////////////// QCPDataRange
             }
             /*!
-              Removes all data point indices that are described by \a other from this data range.
+              Removes all data point indices that are described by \a other from this data selection.
             */
             QCPDataSelection &QCPDataSelection::operator-=(const QCPDataSelection &other)
             {
             }
             /*!
-              Removes all data point indices that are described by \a other from this data range.
+              Removes all data point indices that are described by \a other from this data selection.
             */
             QCPDataSelection &QCPDataSelection::operator-=(const QCPDataRange &other)
             {
             /* end of 'src/selectionrect.cpp' */
-            /* including file 'src/layout.cpp', size 74302                               */
+            /* including file 'src/layout.cpp', size 74663                               */
-            /* commit 633339dadc92cb10c58ef3556b55570685fafb99 2016-09-13 23:54:56 +0200 */
+            /* commit a872eb91ec087561efd83dd9cb041a26ab95ce55 2017-07-31 00:21:41 +0200 */
             ////////////////////////////////////////////////////////////////////////////////////////////////////
             //////////////////// QCPMarginGroup
             }
             /*!
-              First calls the QCPLayoutElement::update base class implementation to update the margins on this
+              If \a phase is \ref upLayout, calls \ref updateLayout, which subclasses may reimplement to
-              layout.
+              reposition and resize their cells.
-              Then calls \ref updateLayout which subclasses reimplement to reposition and resize their cells.
+              Finally, the call is propagated down to all child \ref QCPLayoutElement "QCPLayoutElements".
-              Finally, \ref update is called on all child elements.
+              For details about this method and the update phases, see the documentation of \ref
+              QCPLayoutElement::update.
             */
             void QCPLayout::update(UpdatePhase phase)
             {
               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 succeding element's
+              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.
             /*!
               Inserts a new column with empty cells at the column index \a newIndex. Valid values for \a
-              newIndex range from 0 (inserts a row at the left) to \a rowCount (appends a row at the right).
+              newIndex range from 0 (inserts a column at the left) to \a columnCount (appends a column at the
+              right).
               \see insertRow
             */
             {
                 row = -1;
                 column = -1;
-                if (columnCount() == 0 || rowCount() == 0)
+                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;
                 switch (mFillOrder) {
                     case foRowsFirst: {
-                        column = index / rowCount();
+                        column = index / nRows;
-                        row = index % rowCount();
+                        row = index % nRows;
                         break;
                     }
                     case foColumnsFirst: {
-                        row = index / columnCount();
+                        row = index / nCols;
-                        column = index % columnCount();
+                        column = index % nCols;
                         break;
                     }
                 }
                     result.rwidth() += minColWidths.at(i);
                 for (int i = 0; i < minRowHeights.size(); ++i)
                     result.rheight() += minRowHeights.at(i);
-                result.rwidth()
+                result.rwidth() += qMax(0, columnCount() - 1) * mColumnSpacing;
-                    += qMax(0, columnCount() - 1) * mColumnSpacing + mMargins.left() + mMargins.right();
+                result.rheight() += qMax(0, rowCount() - 1) * mRowSpacing;
-                result.rheight() += qMax(0, rowCount() - 1) * mRowSpacing + mMargins.top() + mMargins.bottom();
                 return result;
             }
                     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()
+                result.rwidth() += qMax(0, columnCount() - 1) * mColumnSpacing;
-                    += qMax(0, columnCount() - 1) * mColumnSpacing + mMargins.left() + mMargins.right();
+                result.rheight() += qMax(0, rowCount() - 1) * mRowSpacing;
-                result.rheight() += qMax(0, rowCount() - 1) * mRowSpacing + mMargins.top() + mMargins.bottom();
                 return result;
             }
               Places the minimum column widths and row heights into \a minColWidths and \a minRowHeights
               respectively.
-              The minimum height of a row is the largest minimum height of any element in that row. The minimum
+              The minimum height of a row is the largest minimum height of any element's outer rect in that
-              width of a column is the largest minimum width of any element in that column.
+              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.
                 *minRowHeights = QVector<int>(rowCount(), 0);
                 for (int row = 0; row < rowCount(); ++row) {
                     for (int col = 0; col < columnCount(); ++col) {
-                        if (mElements.at(row).at(col)) {
+                        if (QCPLayoutElement *el = mElements.at(row).at(col)) {
-                            QSize minHint = mElements.at(row).at(col)->minimumSizeHint();
+                            QSize minHint = el->minimumSizeHint();
-                            QSize min = mElements.at(row).at(col)->minimumSize();
+                            QSize min = el->minimumSize();
                             QSize final(min.width() > 0 ? min.width() : minHint.width(),
                                         min.height() > 0 ? min.height() : minHint.height());
+                            final += QSize(el->margins().left() + el->margins().right(),
+                                           el->margins().top() + el->margins().bottom());
                             if (minColWidths->at(col) < final.width())
                                 (*minColWidths)[col] = final.width();
                             if (minRowHeights->at(row) < final.height())
               Places the maximum column widths and row heights into \a maxColWidths and \a maxRowHeights
               respectively.
-              The maximum height of a row is the smallest maximum height of any element in that row. The
+              The maximum height of a row is the smallest maximum height of any element's outer rect in that
-              maximum width of a column is the smallest maximum width of any element in that column.
+              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.
                 *maxRowHeights = QVector<int>(rowCount(), QWIDGETSIZE_MAX);
                 for (int row = 0; row < rowCount(); ++row) {
                     for (int col = 0; col < columnCount(); ++col) {
-                        if (mElements.at(row).at(col)) {
+                        if (QCPLayoutElement *el = mElements.at(row).at(col)) {
-                            QSize maxHint = mElements.at(row).at(col)->maximumSizeHint();
+                            QSize maxHint = el->maximumSizeHint();
-                            QSize max = mElements.at(row).at(col)->maximumSize();
+                            QSize max = el->maximumSize();
                             QSize final(max.width() < QWIDGETSIZE_MAX ? max.width() : maxHint.width(),
                                         max.height() < QWIDGETSIZE_MAX ? max.height() : maxHint.height());
+                            final += QSize(el->margins().left() + el->margins().right(),
+                                           el->margins().top() + el->margins().bottom());
                             if (maxColWidths->at(col) > final.width())
                                 (*maxColWidths)[col] = final.width();
                             if (maxRowHeights->at(row) > final.height())
             void QCPLayoutInset::updateLayout()
             {
                 for (int i = 0; i < mElements.size(); ++i) {
+                    QCPLayoutElement *el = mElements.at(i);
                     QRect insetRect;
                     QSize finalMinSize, finalMaxSize;
-                    QSize minSizeHint = mElements.at(i)->minimumSizeHint();
+                    QSize minSizeHint = el->minimumSizeHint();
-                    QSize maxSizeHint = mElements.at(i)->maximumSizeHint();
+                    QSize maxSizeHint = el->maximumSizeHint();
-                    finalMinSize.setWidth(mElements.at(i)->minimumSize().width() > 0
+                    finalMinSize.setWidth(el->minimumSize().width() > 0 ? el->minimumSize().width()
-                                              ? mElements.at(i)->minimumSize().width()
+                                                                        : minSizeHint.width());
-                                              : minSizeHint.width());
+                    finalMinSize.setHeight(el->minimumSize().height() > 0 ? el->minimumSize().height()
-                    finalMinSize.setHeight(mElements.at(i)->minimumSize().height() > 0
+                                                                          : minSizeHint.height());
-                                               ? mElements.at(i)->minimumSize().height()
+                    finalMaxSize.setWidth(el->maximumSize().width() < QWIDGETSIZE_MAX
-                                               : minSizeHint.height());
+                                              ? el->maximumSize().width()
-                    finalMaxSize.setWidth(mElements.at(i)->maximumSize().width() < QWIDGETSIZE_MAX
-                                              ? mElements.at(i)->maximumSize().width()
                                               : maxSizeHint.width());
-                    finalMaxSize.setHeight(mElements.at(i)->maximumSize().height() < QWIDGETSIZE_MAX
+                    finalMaxSize.setHeight(el->maximumSize().height() < QWIDGETSIZE_MAX
-                                               ? mElements.at(i)->maximumSize().height()
+                                               ? el->maximumSize().height()
                                                : maxSizeHint.height());
+                    finalMinSize += QSize(el->margins().left() + el->margins().right(),
+                                          el->margins().top() + el->margins().bottom());
+                    finalMaxSize += QSize(el->margins().left() + el->margins().right(),
+                                          el->margins().top() + el->margins().bottom());
                     if (mInsetPlacement.at(i) == ipFree) {
                         insetRect = QRect(rect().x() + rect().width() * mInsetRect.at(i).x(),
                                           rect().y() + rect().height() * mInsetRect.at(i).y(),
             /* end of 'src/axis/axistickerlog.cpp' */
-            /* including file 'src/axis/axis.cpp', size 94458                            */
+            /* including file 'src/axis/axis.cpp', size 99397                            */
-            /* commit 633339dadc92cb10c58ef3556b55570685fafb99 2016-09-13 23:54:56 +0200 */
+            /* commit 0cc4d9f61f7bf45321a88fec89d909b020ffa26f 2017-08-14 00:43:29 +0200 */
             ////////////////////////////////////////////////////////////////////////////////////////////////////
                     }
                     else // mScaleType == stLogarithmic
                     {
-                        if (value >= 0 && mRange.upper < 0) // invalid value for logarithmic scale, just draw it
+                        if (value >= 0.0 && mRange.upper < 0.0) // invalid value for logarithmic scale, just
-                                                            // outside visible range
+                                                                // draw it outside visible range
                             return !mRangeReversed ? mAxisRect->right() + 200 : mAxisRect->left() - 200;
-                        else if (value <= 0 && mRange.upper > 0) // invalid value for logarithmic scale, just
+                        else if (value <= 0.0 && mRange.upper >= 0.0) // invalid value for logarithmic scale,
-                                                                 // draw it outside visible range
+                                                                      // just draw it outside visible range
                             return !mRangeReversed ? mAxisRect->left() - 200 : mAxisRect->right() + 200;
                         else {
                             if (!mRangeReversed)
                     }
                     else // mScaleType == stLogarithmic
                     {
-                        if (value >= 0 && mRange.upper < 0) // invalid value for logarithmic scale, just draw it
+                        if (value >= 0.0 && mRange.upper < 0.0) // invalid value for logarithmic scale, just
-                                                            // outside visible range
+                                                                // draw it outside visible range
                             return !mRangeReversed ? mAxisRect->top() - 200 : mAxisRect->bottom() + 200;
-                        else if (value <= 0 && mRange.upper > 0) // invalid value for logarithmic scale, just
+                        else if (value <= 0.0 && mRange.upper >= 0.0) // invalid value for logarithmic scale,
-                                                                 // draw it outside visible range
+                                                                      // just draw it outside visible range
                             return !mRangeReversed ? mAxisRect->bottom() + 200 : mAxisRect->top() - 200;
                         else {
                             if (!mRangeReversed)
             /*! \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.
                 painter->setBrush(QBrush(basePen.color()));
                 QCPVector2D baseLineVector(baseLine.dx(), baseLine.dy());
                 if (lowerEnding.style() != QCPLineEnding::esNone)
-                    lowerEnding.draw(painter, QCPVector2D(baseLine.p1())
+                    lowerEnding.draw(painter,
-                                                  - baseLineVector.normalized() * lowerEnding.realLength()
+                                     QCPVector2D(baseLine.p1())
-                                                        * (lowerEnding.inverted() ? -1 : 1),
+                                         - baseLineVector.normalized() * lowerEnding.realLength()
+                                               * (lowerEnding.inverted() ? -1 : 1),
                                      -baseLineVector);
                 if (upperEnding.style() != QCPLineEnding::esNone)
-                    upperEnding.draw(painter, QCPVector2D(baseLine.p2())
+                    upperEnding.draw(painter,
-                                                  + baseLineVector.normalized() * upperEnding.realLength()
+                                     QCPVector2D(baseLine.p2())
-                                                        * (upperEnding.inverted() ? -1 : 1),
+                                         + baseLineVector.normalized() * upperEnding.realLength()
+                                               * (upperEnding.inverted() ? -1 : 1),
                                      baseLineVector);
                 painter->setAntialiasing(antialiasingBackup);
                             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 = QPixmap(labelData.rotatedTotalBounds.size());
                         cachedLabel->pixmap.fill(Qt::transparent);
                         QCPPainter cachePainter(&cachedLabel->pixmap);
                         cachePainter.setPen(painter->pen());
             /* end of 'src/axis/axis.cpp' */
-            /* including file 'src/scatterstyle.cpp', size 17420                         */
+            /* including file 'src/scatterstyle.cpp', size 17450                         */
-            /* commit 633339dadc92cb10c58ef3556b55570685fafb99 2016-09-13 23:54:56 +0200 */
+            /* commit 820d2282db70144c358c13433cd74b4175f9252b 2017-07-24 00:24:17 +0200 */
             ////////////////////////////////////////////////////////////////////////////////////////////////////
             //////////////////// QCPScatterStyle
               The custom shape line will be drawn with \a pen and filled with \a brush. The size has a slightly
               different meaning than for built-in scatter points: The custom path will be drawn scaled by a
-              factor of \a size/6.0. Since the default \a size is 6, the custom path will appear at a its
+              factor of \a size/6.0. Since the default \a size is 6, the custom path will appear in its
-              natural size by default. To double the size of the path for example, set \a size to 12.
+              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)
                         break;
                     }
                     case ssDiamond: {
-                        painter->drawLine(QLineF(x - w, y, x, y - w));
+                        QPointF lineArray[4]
-                        painter->drawLine(QLineF(x, y - w, x + w, y));
+                            = {QPointF(x - w, y), QPointF(x, y - w), QPointF(x + w, y), QPointF(x, y + w)};
-                        painter->drawLine(QLineF(x + w, y, x, y + w));
+                        painter->drawPolygon(lineArray, 4);
-                        painter->drawLine(QLineF(x, y + w, x - w, y));
                         break;
                     }
                     case ssStar: {
                         break;
                     }
                     case ssTriangle: {
-                        painter->drawLine(QLineF(x - w, y + 0.755 * w, x + w, y + 0.755 * w));
+                        QPointF lineArray[3] = {QPointF(x - w, y + 0.755 * w), QPointF(x + w, y + 0.755 * w),
-                        painter->drawLine(QLineF(x + w, y + 0.755 * w, x, y - 0.977 * w));
+                                                QPointF(x, y - 0.977 * w)};
-                        painter->drawLine(QLineF(x, y - 0.977 * w, x - w, y + 0.755 * w));
+                        painter->drawPolygon(lineArray, 3);
                         break;
                     }
                     case ssTriangleInverted: {
-                        painter->drawLine(QLineF(x - w, y - 0.755 * w, x + w, y - 0.755 * w));
+                        QPointF lineArray[3] = {QPointF(x - w, y - 0.755 * w), QPointF(x + w, y - 0.755 * w),
-                        painter->drawLine(QLineF(x + w, y - 0.755 * w, x, y + 0.977 * w));
+                                                QPointF(x, y + 0.977 * w)};
-                        painter->drawLine(QLineF(x, y + 0.977 * w, x - w, y - 0.755 * 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));
-                        painter->drawRect(QRectF(x - w, y - w, mSize, mSize));
                         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));
-                        painter->drawRect(QRectF(x - w, y - w, mSize, mSize));
                         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));
-                        painter->drawEllipse(QPointF(x, y), w, w);
                         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));
-                        painter->drawEllipse(QPointF(x, y), w, 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));
-                        painter->drawEllipse(QPointF(x, y), w, w);
                         break;
                     }
                     case ssPixmap: {
             // amalgamation: add datacontainer.cpp
-            /* including file 'src/plottable.cpp', size 38861                            */
+            /* including file 'src/plottable.cpp', size 38845                            */
-            /* commit 633339dadc92cb10c58ef3556b55570685fafb99 2016-09-13 23:54:56 +0200 */
+            /* commit b0bed12626f942821097f43091126b6fb7163122 2017-08-13 17:17:33 +0200 */
             ////////////////////////////////////////////////////////////////////////////////////////////////////
             //////////////////// QCPSelectionDecorator
             QCPSelectionDecorator::QCPSelectionDecorator()
                     : mPen(QColor(80, 80, 255), 2.5),
                       mBrush(Qt::NoBrush),
-                      mScatterStyle(QCPScatterStyle::ssNone, QPen(Qt::blue, 2), Qt::NoBrush, 6.0),
+                      mScatterStyle(),
-                      mUsedScatterProperties(QCPScatterStyle::spPen),
+                      mUsedScatterProperties(QCPScatterStyle::spNone),
                       mPlottable(0)
             {
             }
               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)
             /* end of 'src/item.cpp' */
-            /* including file 'src/core.cpp', size 124243                                */
+            /* including file 'src/core.cpp', size 125027                                */
-            /* commit 633339dadc92cb10c58ef3556b55570685fafb99 2016-09-13 23:54:56 +0200 */
+            /* commit 9ede7553208db59867d1ea9f1988cd90e3c7ffed 2017-08-13 17:25:24 +0200 */
             ////////////////////////////////////////////////////////////////////////////////////////////////////
             //////////////////// QCustomPlot
                       mOpenGl(false),
                       mMouseHasMoved(false),
                       mMouseEventLayerable(0),
+                      mMouseSignalLayerable(0),
                       mReplotting(false),
                       mReplotQueued(false),
                       mOpenGlMultisamples(16),
                 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);
             }
             /*!
+              \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.).
                         mSelectionRect->startSelection(event);
                 }
                 else {
-                    // no selection rect interaction, so forward event to layerable under the cursor:
+                    // 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 ignore the event, in
+                        event->accept(); // default impl of QCPLayerable's mouse events call ignore() on the
-                                         // that case propagate to next candidate in list
+                                         // 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);
                         processPointSelection(event);
                     // emit specialized click signals of QCustomPlot instance:
-                    if (QCPAbstractPlottable *ap = qobject_cast<QCPAbstractPlottable *>(mMouseEventLayerable)) {
+                    if (QCPAbstractPlottable *ap
+                        = qobject_cast<QCPAbstractPlottable *>(mMouseSignalLayerable)) {
                         int dataIndex = 0;
-                        if (!mMouseEventLayerableDetails.value<QCPDataSelection>().isEmpty())
+                        if (!mMouseSignalLayerableDetails.value<QCPDataSelection>().isEmpty())
                             dataIndex
-                                = mMouseEventLayerableDetails.value<QCPDataSelection>().dataRange().begin();
+                                = mMouseSignalLayerableDetails.value<QCPDataSelection>().dataRange().begin();
                         emit plottableClick(ap, dataIndex, event);
                     }
-                    else if (QCPAxis *ax = qobject_cast<QCPAxis *>(mMouseEventLayerable))
+                    else if (QCPAxis *ax = qobject_cast<QCPAxis *>(mMouseSignalLayerable))
-                        emit axisClick(ax, mMouseEventLayerableDetails.value<QCPAxis::SelectablePart>(), event);
+                        emit axisClick(ax, mMouseSignalLayerableDetails.value<QCPAxis::SelectablePart>(),
-                    else if (QCPAbstractItem *ai = qobject_cast<QCPAbstractItem *>(mMouseEventLayerable))
+                                       event);
+                    else if (QCPAbstractItem *ai = qobject_cast<QCPAbstractItem *>(mMouseSignalLayerable))
                         emit itemClick(ai, event);
-                    else if (QCPLegend *lg = qobject_cast<QCPLegend *>(mMouseEventLayerable))
+                    else if (QCPLegend *lg = qobject_cast<QCPLegend *>(mMouseSignalLayerable))
                         emit legendClick(lg, 0, event);
                     else if (QCPAbstractLegendItem *li
-                             = qobject_cast<QCPAbstractLegendItem *>(mMouseEventLayerable))
+                             = qobject_cast<QCPAbstractLegendItem *>(mMouseSignalLayerable))
                         emit legendClick(li->parentLegend(), li, event);
+                    mMouseSignalLayerable = 0;
                 }
                 if (mSelectionRect && mSelectionRect->isActive()) // Note: if a click was detected above, the
                                         hue -= 1.0;
                                     if (useAlpha) {
                                         const QRgb rgb
-                                            = QColor::fromHsvF(hue, (1 - t) * lowHsv.saturationF()
+                                            = QColor::fromHsvF(hue,
-                                                                        + t * highHsv.saturationF(),
+                                                               (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();
                                     }
                                     else {
                                         mColorBuffer[i]
-                                            = QColor::fromHsvF(hue, (1 - t) * lowHsv.saturationF()
+                                            = QColor::fromHsvF(hue,
-                                                                        + t * highHsv.saturationF(),
+                                                               (1 - t) * lowHsv.saturationF()
+                                                                   + t * highHsv.saturationF(),
                                                                (1 - t) * lowHsv.valueF() + t * highHsv.valueF())
                                                   .rgb();
                                     }
             /* end of 'src/selectiondecorator-bracket.cpp' */
-            /* including file 'src/layoutelements/layoutelement-axisrect.cpp', size 47509 */
+            /* including file 'src/layoutelements/layoutelement-axisrect.cpp', size 47584 */
-            /* commit 633339dadc92cb10c58ef3556b55570685fafb99 2016-09-13 23:54:56 +0200  */
+            /* commit 77ba168312f935543fc31d1ae9b4cdcf34aae4f9 2017-08-13 18:29:48 +0200  */
             ////////////////////////////////////////////////////////////////////////////////////////////////////
               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 sublasses of QCPAxis) by setting \a axis to an axis that was
+              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
                 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
             void QCPAxisRect::mousePressEvent(QMouseEvent *event, const QVariant &details)
             {
                 Q_UNUSED(details)
-                mDragStart = event->pos(); // need this even when not LeftButton is pressed, to determine in
-                                           // releaseEvent whether it was a full click (no position change
-                                           // between press and release)
                 if (event->buttons() & Qt::LeftButton) {
                     mDragging = true;
                     // initialize antialiasing backup in case we start dragging:
                                 break;
                             if (ax->mScaleType == QCPAxis::stLinear) {
                                 double diff
-                                    = ax->pixelToCoord(mDragStart.x()) - ax->pixelToCoord(event->pos().x());
+                                    = 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(mDragStart.x()) / ax->pixelToCoord(event->pos().x());
+                                    = ax->pixelToCoord(startPos.x()) / ax->pixelToCoord(event->pos().x());
                                 ax->setRange(mDragStartHorzRange.at(i).lower * diff,
                                              mDragStartHorzRange.at(i).upper * diff);
                             }
                                 break;
                             if (ax->mScaleType == QCPAxis::stLinear) {
                                 double diff
-                                    = ax->pixelToCoord(mDragStart.y()) - ax->pixelToCoord(event->pos().y());
+                                    = 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(mDragStart.y()) / ax->pixelToCoord(event->pos().y());
+                                    = ax->pixelToCoord(startPos.y()) / ax->pixelToCoord(event->pos().y());
                                 ax->setRange(mDragStartVertRange.at(i).lower * diff,
                                              mDragStartVertRange.at(i).upper * diff);
                             }
                     {
                         if (mParentPlot->noAntialiasingOnDrag())
                             mParentPlot->setNotAntialiasedElements(QCP::aeAll);
-                        mParentPlot->replot();
+                        mParentPlot->replot(QCustomPlot::rpQueuedReplot);
                     }
                 }
             }
             /* end of 'src/layoutelements/layoutelement-axisrect.cpp' */
-            /* including file 'src/layoutelements/layoutelement-legend.cpp', size 30933  */
+            /* including file 'src/layoutelements/layoutelement-legend.cpp', size 30971  */
-            /* commit 633339dadc92cb10c58ef3556b55570685fafb99 2016-09-13 23:54:56 +0200 */
+            /* commit 305808813c9c6451dca8399c2fc66d68ebd24b5e 2017-08-15 23:03:07 +0200 */
             ////////////////////////////////////////////////////////////////////////////////////////////////////
             //////////////////// QCPAbstractLegendItem
               QCPLegend::setIconBorderPen and \ref QCPLegend::setIconTextPadding.
               The function \ref QCPAbstractPlottable::addToLegend/\ref QCPAbstractPlottable::removeFromLegend
-              creates/removes legend items of this type in the default implementation. However, these functions
+              creates/removes legend items of this type.
-              may be reimplemented such that a different kind of legend item (e.g a direct subclass of
-              QCPAbstractLegendItem) is used for that plottable.
               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
                 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.setWidth(iconSize.width() + mParentLegend->iconTextPadding() + textRect.width());
-                                + mMargins.left() + mMargins.right());
+                result.setHeight(qMax(textRect.height(), iconSize.height()));
-                result.setHeight(qMax(textRect.height(), iconSize.height()) + mMargins.top()
-                                 + mMargins.bottom());
                 return result;
             }
               A legend is a small box somewhere in the plot which lists plottables with their name and icon.
-              Normally, the legend is populated by calling \ref QCPAbstractPlottable::addToLegend. The
+              A legend is populated with legend items by calling \ref QCPAbstractPlottable::addToLegend on the
-              respective legend item can be removed with \ref QCPAbstractPlottable::removeFromLegend. However,
+              plottable, for which a legend item shall be created. In the case of the main legend (\ref
-              QCPLegend also offers an interface to add and manipulate legend items directly: \ref item, \ref
+              QCustomPlot::legend), simply adding plottables to the plot while \ref
-              itemWithPlottable, \ref itemCount, \ref addItem, \ref removeItem, etc.
+              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
             }
             /*! \overload
-             */
+            */
             void QCPLegend::setIconSize(int width, int height)
             {
                 mIconSize.setWidth(width);
             /* end of 'src/layoutelements/layoutelement-legend.cpp' */
-            /* including file 'src/layoutelements/layoutelement-textelement.cpp', size 12759 */
+            /* including file 'src/layoutelements/layoutelement-textelement.cpp', size 12561 */
-            /* commit 633339dadc92cb10c58ef3556b55570685fafb99 2016-09-13 23:54:56 +0200     */
+            /* commit a872eb91ec087561efd83dd9cb041a26ab95ce55 2017-07-31 00:21:41 +0200     */
             ////////////////////////////////////////////////////////////////////////////////////////////////////
             //////////////////// QCPTextElement
             QSize QCPTextElement::minimumSizeHint() const
             {
                 QFontMetrics metrics(mFont);
-                QSize result = metrics.boundingRect(0, 0, 0, 0, Qt::AlignCenter, mText).size();
+                return 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 */
             {
                 QFontMetrics metrics(mFont);
                 QSize result = metrics.boundingRect(0, 0, 0, 0, Qt::AlignCenter, mText).size();
-                result.rheight() += mMargins.top() + mMargins.bottom();
                 result.setWidth(QWIDGETSIZE_MAX);
                 return result;
             }
                 switch (phase) {
                     case upMargins: {
                         if (mType == QCPAxis::atBottom || mType == QCPAxis::atTop) {
-                            setMaximumSize(QWIDGETSIZE_MAX, mBarWidth + mAxisRect.data()->margins().top()
+                            setMaximumSize(QWIDGETSIZE_MAX,
-                                                                + mAxisRect.data()->margins().bottom()
+                                           mBarWidth + mAxisRect.data()->margins().top()
-                                                                + margins().top() + margins().bottom());
+                                               + mAxisRect.data()->margins().bottom() + margins().top()
-                            setMinimumSize(0, mBarWidth + mAxisRect.data()->margins().top()
+                                               + margins().bottom());
-                                                  + mAxisRect.data()->margins().bottom() + margins().top()
+                            setMinimumSize(0,
-                                                  + margins().bottom());
+                                           mBarWidth + mAxisRect.data()->margins().top()
+                                               + mAxisRect.data()->margins().bottom() + margins().top()
+                                               + margins().bottom());
                         }
                         else {
                             setMaximumSize(mBarWidth + mAxisRect.data()->margins().left()
             /* end of 'src/layoutelements/layoutelement-colorscale.cpp' */
-            /* including file 'src/plottables/plottable-graph.cpp', size 72363           */
+            /* including file 'src/plottables/plottable-graph.cpp', size 73960           */
-            /* commit 633339dadc92cb10c58ef3556b55570685fafb99 2016-09-13 23:54:56 +0200 */
+            /* commit 7e7381ef4f218e004d72a218820634fff0959d1b 2017-08-02 00:02:36 +0200 */
             ////////////////////////////////////////////////////////////////////////////////////////////////////
             //////////////////// QCPGraphData
                 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();
                 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) {
                     return result;
                 }
-                result.reserve(data.size() + 2); // added 2 to reserve memory for lower/upper fill base points
-                                                 // that might be needed for fill
                 result.resize(data.size());
                 // transform data points to pixels:
                     return result;
                 }
-                result.reserve(data.size() * 2 + 2); // added 2 to reserve memory for lower/upper fill base
-                                                     // points that might be needed for fill
                 result.resize(data.size() * 2);
                 // calculate steps from data and transform to pixel coordinates:
                     return result;
                 }
-                result.reserve(data.size() * 2 + 2); // added 2 to reserve memory for lower/upper fill base
-                                                     // points that might be needed for fill
                 result.resize(data.size() * 2);
                 // calculate steps from data and transform to pixel coordinates:
                     return result;
                 }
-                result.reserve(data.size() * 2 + 2); // added 2 to reserve memory for lower/upper fill base
-                                                     // points that might be needed for fill
                 result.resize(data.size() * 2);
                 // calculate steps from data and transform to pixel coordinates:
                     return result;
                 }
-                result.resize(data.size()
+                result.resize(data.size() * 2);
-                              * 2); // no need to reserve 2 extra points because impulse plot has no fill
                 // transform data points to pixels:
                 if (keyAxis->orientation() == Qt::Vertical) {
               Draws the fill of the graph using the specified \a painter, with the currently set brush.
-              \a lines contains the points of the graph line, in pixel coordinates.
+              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.
-              If the fill is a normal fill towards the zero-value-line, only the points in \a lines are
+              In order to handle NaN Data points correctly (the fill needs to be split into disjoint areas),
-              required and two extra points at the zero-value-line, which are added by \ref addFillBasePoints
+              this method first determines a list of non-NaN segments with \ref getNonNanSegments, on which to
-              and removed by \ref removeFillBasePoints after the fill drawing is done.
+              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.
-              On the other hand if the fill is a channel fill between this QCPGraph and another QCPGraph (\a
+              Pass the points of this graph's line as \a lines, in pixel coordinates.
-              mChannelFillGraph), the more complex polygon is calculated with the \ref getChannelFillPolygon
-              function, and then drawn.
               \see drawLinePlot, drawImpulsePlot, drawScatterPlot
             */
                     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:
-                    addFillBasePoints(lines);
+                    for (int i = 0; i < segments.size(); ++i)
-                    painter->drawPolygon(QPolygonF(*lines));
+                        painter->drawPolygon(getFillPolygon(lines, segments.at(i)));
-                    removeFillBasePoints(lines);
                 }
                 else {
-                    // draw channel fill between this graph and mChannelFillGraph:
+                    // draw fill between this graph and mChannelFillGraph:
-                    painter->drawPolygon(getChannelFillPolygon(lines));
+                    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));
+                    }
                 }
             }
                 else // don't use adaptive sampling algorithm, transfer points one-to-one from the data
                      // container into the output
                 {
-                    QCPGraphDataContainer::const_iterator it = begin;
+                    lineData->resize(dataCount);
-                    lineData->reserve(dataCount + 2); // +2 for possible fill end points
+                    std::copy(begin, end, lineData->begin());
-                    while (it != end) {
-                        lineData->append(*it);
-                        ++it;
                 }
             }
                 }
             }
-            /*! \internal
+            /*!  \internal
-              The line vector generated by e.g. \ref getLines describes only the line that connects the data
+              This method goes through the passed points in \a lineData and returns a list of the segments
-              points. If the graph needs to be filled, two additional points need to be added at the
+              which don't contain NaN data points.
-              value-zero-line in the lower and upper key positions of the graph. This function calculates these
-              points and adds them to the end of \a lineData. Since the fill is typically drawn before the line
-              stroke, these added points need to be removed again after the fill is done, with the
-              removeFillBasePoints function.
-              The expanding of \a lines by two points will not cause unnecessary memory reallocations, because
+              \a keyOrientation defines whether the \a x or \a y member of the passed QPointF is used to check
-              the data vector generation functions (e.g. \ref getLines) reserve two extra points when they
+              for NaN. If \a keyOrientation is \c Qt::Horizontal, the \a y member is checked, if it is \c
-              allocate memory for \a lines.
+              Qt::Vertical, the \a x member is checked.
-              \see removeFillBasePoints, lowerFillBasePoint, upperFillBasePoint
+              \see getOverlappingSegments, drawFill
             */
-            void QCPGraph::addFillBasePoints(QVector<QPointF> *lines) const
+            QVector<QCPDataRange> QCPGraph::getNonNanSegments(const QVector<QPointF> *lineData,
+                                                              Qt::Orientation keyOrientation) const
             {
-                if (!mKeyAxis) {
+                QVector<QCPDataRange> result;
-                    qDebug() << Q_FUNC_INFO << "invalid key axis";
+                const int n = lineData->size();
-                    return;
+                QCPDataRange currentSegment(-1, -1);
-                if (!lines) {
+                int i = 0;
-                    qDebug() << Q_FUNC_INFO << "passed null as lineData";
-                    return;
-                if (lines->isEmpty())
-                    return;
-                // append points that close the polygon fill at the key axis:
+                if (keyOrientation == Qt::Horizontal) {
-                if (mKeyAxis.data()->orientation() == Qt::Vertical) {
+                    while (i < n) {
-                    *lines << upperFillBasePoint(lines->last().y());
+                        while (i < n && qIsNaN(lineData->at(i).y())) // seek next non-NaN data point
-                    *lines << lowerFillBasePoint(lines->first().y());
+                            ++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 {
+                else // keyOrientation == Qt::Vertical
-                    *lines << upperFillBasePoint(lines->last().x());
-                    *lines << lowerFillBasePoint(lines->first().x());
+                    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
+            /*!  \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.
-              removes the two points from \a lines that were added by \ref addFillBasePoints.
+              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 addFillBasePoints, lowerFillBasePoint, upperFillBasePoint
+              \see getNonNanSegments, segmentsIntersect, drawFill, getChannelFillPolygon
             */
-            void QCPGraph::removeFillBasePoints(QVector<QPointF> *lines) const
+            QVector<QPair<QCPDataRange, QCPDataRange> > QCPGraph::getOverlappingSegments(
+                QVector<QCPDataRange> thisSegments, const QVector<QPointF> *thisData,
+                QVector<QCPDataRange> otherSegments, const QVector<QPointF> *otherData) const
             {
-                if (!lines) {
+                QVector<QPair<QCPDataRange, QCPDataRange> > result;
-                    qDebug() << Q_FUNC_INFO << "passed null as lineData";
+                if (thisData->isEmpty() || otherData->isEmpty() || thisSegments.isEmpty()
-                    return;
+                    || 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;
                 }
-                if (lines->isEmpty())
-                    return;
-                lines->remove(lines->size() - 2, 2);
+                return result;
             }
-            /*! \internal
+            /*!  \internal
+              Returns whether the segments defined by the coordinates (aLower, aUpper) and (bLower, bUpper)
+              have overlap.
-              called by \ref addFillBasePoints to conveniently assign the point which closes the fill polygon
+              The output parameter \a bPrecedence indicates whether the \a b segment reaches farther than the
-              on the lower side of the zero-value-line parallel to the key axis. The logarithmic axis scale
+              \a a segment or not. If \a bPrecedence returns 1, segment \a b reaches the farthest to higher
-              case is a bit special, since the zero-value-line in pixel coordinates is in positive or negative
+              coordinates (i.e. bUpper > aUpper). If it returns -1, segment \a a reaches the farthest. Only if
-              infinity. So this case is handled separately by just closing the fill polygon on the axis which
+              both segment's upper bounds are identical, 0 is returned as \a bPrecedence.
-              lies in the direction towards the zero value.
-              \a lowerKey will be the the key (in pixels) of the returned point. Depending on whether the key
+              It is assumed that the lower bounds always have smaller or equal values than the upper bounds.
-              axis is horizontal or vertical, \a lowerKey will end up as the x or y value of the returned
-              point, respectively.
-              \see upperFillBasePoint, addFillBasePoints
+              \see getOverlappingSegments
             */
-            QPointF QCPGraph::lowerFillBasePoint(double lowerKey) const
+            bool QCPGraph::segmentsIntersect(double aLower, double aUpper, double bLower, double bUpper,
+                                             int &bPrecedence) const
             {
-                QCPAxis *keyAxis = mKeyAxis.data();
+                bPrecedence = 0;
-                QCPAxis *valueAxis = mValueAxis.data();
+                if (aLower > bUpper) {
-                if (!keyAxis || !valueAxis) {
+                    bPrecedence = -1;
-                    qDebug() << Q_FUNC_INFO << "invalid key or value axis";
+                    return false;
-                    return QPointF();
                 }
+                else if (bLower > aUpper) {
-                QPointF point;
+                    bPrecedence = 1;
-                if (valueAxis->scaleType() == QCPAxis::stLinear) {
+                    return false;
-                    if (keyAxis->axisType() == QCPAxis::atLeft) {
-                        point.setX(valueAxis->coordToPixel(0));
-                        point.setY(lowerKey);
-                    else if (keyAxis->axisType() == QCPAxis::atRight) {
-                        point.setX(valueAxis->coordToPixel(0));
-                        point.setY(lowerKey);
-                    else if (keyAxis->axisType() == QCPAxis::atTop) {
-                        point.setX(lowerKey);
-                        point.setY(valueAxis->coordToPixel(0));
-                    else if (keyAxis->axisType() == QCPAxis::atBottom) {
-                        point.setX(lowerKey);
-                        point.setY(valueAxis->coordToPixel(0));
                 }
-                else // valueAxis->mScaleType == QCPAxis::stLogarithmic
+                else {
+                    if (aUpper > bUpper)
-                    // In logarithmic scaling we can't just draw to value zero so we just fill all the way
+                        bPrecedence = -1;
-                    // to the axis which is in the direction towards zero
+                    else if (aUpper < bUpper)
-                    if (keyAxis->orientation() == Qt::Vertical) {
+                        bPrecedence = 1;
-                        if ((valueAxis->range().upper < 0 && !valueAxis->rangeReversed())
-                            || (valueAxis->range().upper > 0 && valueAxis->rangeReversed())) // if range is
+                    return true;
-                                                                                             // negative, zero
-                                                                                             // is on opposite
-                                                                                             // side of key axis
-                            point.setX(keyAxis->axisRect()->right());
-                        else
-                            point.setX(keyAxis->axisRect()->left());
-                        point.setY(lowerKey);
-                    else if (keyAxis->axisType() == QCPAxis::atTop
-                             || keyAxis->axisType() == QCPAxis::atBottom) {
-                        point.setX(lowerKey);
-                        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
-                            point.setY(keyAxis->axisRect()->top());
-                        else
-                            point.setY(keyAxis->axisRect()->bottom());
                 }
-                return point;
             }
             /*! \internal
-              called by \ref addFillBasePoints to conveniently assign the point which closes the fill
+              Returns the point which closes the fill polygon on the zero-value-line parallel to the key axis.
-              polygon on the upper side of the zero-value-line parallel to the key axis. The logarithmic axis
+              The logarithmic axis scale case is a bit special, since the zero-value-line in pixel coordinates
-              scale case is a bit special, since the zero-value-line in pixel coordinates is in positive or
+              is in positive or negative infinity. So this case is handled separately by just closing the fill
-              negative infinity. So this case is handled separately by just closing the fill polygon on the
+              polygon on the axis which lies in the direction towards the zero value.
-              axis which lies in the direction towards the zero value.
-              \a upperKey will be the the key (in pixels) of the returned point. Depending on whether the key
+              \a matchingDataPoint will provide the key (in pixels) of the returned point. Depending on whether
-              axis is horizontal or vertical, \a upperKey will end up as the x or y value of the returned
+              the key axis of this graph is horizontal or vertical, \a matchingDataPoint will provide the x or
-              point, respectively.
+              y value of the returned point, respectively.
-              \see lowerFillBasePoint, addFillBasePoints
             */
-            QPointF QCPGraph::upperFillBasePoint(double upperKey) const
+            QPointF QCPGraph::getFillBasePoint(QPointF matchingDataPoint) const
             {
                 QCPAxis *keyAxis = mKeyAxis.data();
                 QCPAxis *valueAxis = mValueAxis.data();
                     return QPointF();
                 }
-                QPointF point;
+                QPointF result;
                 if (valueAxis->scaleType() == QCPAxis::stLinear) {
-                    if (keyAxis->axisType() == QCPAxis::atLeft) {
+                    if (keyAxis->orientation() == Qt::Horizontal) {
-                        point.setX(valueAxis->coordToPixel(0));
+                        result.setX(matchingDataPoint.x());
-                        point.setY(upperKey);
+                        result.setY(valueAxis->coordToPixel(0));
                     }
-                    else if (keyAxis->axisType() == QCPAxis::atRight) {
+                    else // keyAxis->orientation() == Qt::Vertical
-                        point.setX(valueAxis->coordToPixel(0));
-                        point.setY(upperKey);
+                        result.setX(valueAxis->coordToPixel(0));
+                        result.setY(matchingDataPoint.y());
-                    else if (keyAxis->axisType() == QCPAxis::atTop) {
-                        point.setX(upperKey);
-                        point.setY(valueAxis->coordToPixel(0));
-                    else if (keyAxis->axisType() == QCPAxis::atBottom) {
-                        point.setX(upperKey);
-                        point.setY(valueAxis->coordToPixel(0));
                     }
                 }
                 else // valueAxis->mScaleType == QCPAxis::stLogarithmic
                                                                                              // negative, zero
                                                                                              // is on opposite
                                                                                              // side of key axis
-                            point.setX(keyAxis->axisRect()->right());
+                            result.setX(keyAxis->axisRect()->right());
                         else
-                            point.setX(keyAxis->axisRect()->left());
+                            result.setX(keyAxis->axisRect()->left());
-                        point.setY(upperKey);
+                        result.setY(matchingDataPoint.y());
                     }
                     else if (keyAxis->axisType() == QCPAxis::atTop
                              || keyAxis->axisType() == QCPAxis::atBottom) {
-                        point.setX(upperKey);
+                        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
-                            point.setY(keyAxis->axisRect()->top());
+                            result.setY(keyAxis->axisRect()->top());
                         else
-                            point.setY(keyAxis->axisRect()->bottom());
+                            result.setY(keyAxis->axisRect()->bottom());
                     }
                 }
-                return point;
+                return result;
             }
             /*! \internal
-              Generates the polygon needed for drawing channel fills between this graph and the graph specified
+              Returns the polygon needed for drawing normal fills between this graph and the key axis.
-              in \a mChannelFillGraph (see \ref setChannelFillGraph). The data points representing the line of
-              this graph in pixel coordinates must be passed in \a lines, the corresponding points of the other
-              graph are generated by calling its \ref getLines method.
-              This method may return an empty polygon if the key ranges of the two graphs have no overlap of if
+              Pass the graph's data points (in pixel coordinates) as \a lineData, and specify the \a segment
-              they don't have the same orientation (e.g. one key axis vertical, the other horizontal). For
+              which shall be used for the fill. The collection of \a lineData points described by \a segment
-              increased performance (due to implicit sharing), it is recommended to keep the returned QPolygonF
+              must not contain NaN data points (see \ref getNonNanSegments).
-              const.
+              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> *lines) const
+            const QPolygonF QCPGraph::getChannelFillPolygon(const QVector<QPointF> *thisData,
+                                                            QCPDataRange thisSegment,
+                                                            const QVector<QPointF> *otherData,
+                                                            QCPDataRange otherSegment) const
             {
                 if (!mChannelFillGraph)
                     return QPolygonF();
                                         // fits, valueAxis will fit too, because it's always orthogonal to
                                         // keyAxis)
-                if (lines->isEmpty())
+                if (thisData->isEmpty())
                     return QPolygonF();
-                QVector<QPointF> otherData;
+                QVector<QPointF> thisSegmentData(thisSegment.size());
-                mChannelFillGraph.data()->getLines(&otherData,
+                QVector<QPointF> otherSegmentData(otherSegment.size());
-                                                   QCPDataRange(0, mChannelFillGraph.data()->dataCount()));
+                std::copy(thisData->constBegin() + thisSegment.begin(),
-                if (otherData.isEmpty())
+                          thisData->constBegin() + thisSegment.end(), thisSegmentData.begin());
-                    return QPolygonF();
+                std::copy(otherData->constBegin() + otherSegment.begin(),
-                QVector<QPointF> thisData;
+                          otherData->constBegin() + otherSegment.end(), otherSegmentData.begin());
-                thisData.reserve(
-                    lines->size()
-                    + otherData.size()); // because we will join both vectors at end of this function
-                for (int i = 0; i < lines->size(); ++i) // don't use the vector<<(vector),  it squeezes
-                                                        // internally, which ruins the performance tuning with
-                                                        // reserve()
-                    thisData << lines->at(i);
                 // pointers to be able to swap them, depending which data range needs cropping:
-                QVector<QPointF> *staticData = &thisData;
+                QVector<QPointF> *staticData = &thisSegmentData;
-                QVector<QPointF> *croppedData = &otherData;
+                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
-                    // if an axis range is reversed, the data point keys will be descending. Reverse them, since
-                    // following algorithm assumes ascending keys:
-                    if (staticData->first().x() > staticData->last().x()) {
-                        int size = staticData->size();
-                        for (int i = 0; i < size / 2; ++i)
-                            qSwap((*staticData)[i], (*staticData)[size - 1 - i]);
-                    if (croppedData->first().x() > croppedData->last().x()) {
-                        int size = croppedData->size();
-                        for (int i = 0; i < size / 2; ++i)
-                            qSwap((*croppedData)[i], (*croppedData)[size - 1 - i]);
                     // crop lower bound:
                     if (staticData->first().x() < croppedData->first().x()) // other one must be cropped
                         qSwap(staticData, croppedData);
-                    int lowBound = findIndexBelowX(croppedData, staticData->first().x());
+                    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
+                    // set lowest point of cropped data to fit exactly key position of first static data point
-                    // point via linear interpolation:
+                    // via linear interpolation:
                     if (croppedData->size() < 2)
                         return QPolygonF(); // need at least two points for interpolation
                     double slope;
-                    if (croppedData->at(1).x() - croppedData->at(0).x() != 0)
+                    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
                     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
+                    // set highest point of cropped data to fit exactly key position of last static data point
-                    // point via linear interpolation:
+                    // via linear interpolation:
                     if (croppedData->size() < 2)
-                        return QPolygonF();           // need at least two points for interpolation
+                        return QPolygonF();                 // need at least two points for interpolation
-                    int li = croppedData->size() - 1; // last index
+                    const int li = croppedData->size() - 1; // last index
-                    if (croppedData->at(li).x() - croppedData->at(li - 1).x() != 0)
+                    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
                 else // mKeyAxis->orientation() == Qt::Vertical
                 {
                     // y is key
-                    // similar to "x is key" but switched x,y. Further, lower/upper meaning is inverted compared
-                    // to x,
-                    // because in pixel coordinates, y increases from top to bottom, not bottom to top like data
-                    // coordinate.
-                    // if an axis range is reversed, the data point keys will be descending. Reverse them, since
-                    // following algorithm assumes ascending keys:
-                    if (staticData->first().y() < staticData->last().y()) {
-                        int size = staticData->size();
-                        for (int i = 0; i < size / 2; ++i)
-                            qSwap((*staticData)[i], (*staticData)[size - 1 - i]);
-                    if (croppedData->first().y() < croppedData->last().y()) {
-                        int size = croppedData->size();
-                        for (int i = 0; i < size / 2; ++i)
-                            qSwap((*croppedData)[i], (*croppedData)[size - 1 - i]);
                     // crop lower bound:
-                    if (staticData->first().y() > croppedData->first().y()) // other one must be cropped
+                    if (staticData->first().y() < croppedData->first().y()) // other one must be cropped
                         qSwap(staticData, croppedData);
-                    int lowBound = findIndexAboveY(croppedData, staticData->first().y());
+                    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
+                    // set lowest point of cropped data to fit exactly key position of first static data point
-                    // point via linear interpolation:
+                    // via linear interpolation:
                     if (croppedData->size() < 2)
                         return QPolygonF(); // need at least two points for interpolation
                     double slope;
-                    if (croppedData->at(1).y() - croppedData->at(0).y()
+                    if (!qFuzzyCompare(croppedData->at(1).y(),
-                        != 0) // avoid division by zero in step plots
+                                       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
                     (*croppedData)[0].setY(staticData->first().y());
                     // crop upper bound:
-                    if (staticData->last().y() < croppedData->last().y()) // other one must be cropped
+                    if (staticData->last().y() > croppedData->last().y()) // other one must be cropped
                         qSwap(staticData, croppedData);
-                    int highBound = findIndexBelowY(croppedData, staticData->last().y());
+                    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
+                    // set highest point of cropped data to fit exactly key position of last static data point
-                    // point via linear interpolation:
+                    // via linear interpolation:
                     if (croppedData->size() < 2)
                         return QPolygonF();           // need at least two points for interpolation
                     int li = croppedData->size() - 1; // last index
-                    if (croppedData->at(li).y() - croppedData->at(li - 1).y()
+                    if (!qFuzzyCompare(croppedData->at(li).y(),
-                        != 0) // avoid division by zero in step plots
+                                       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
                 }
                 // return joined:
-                for (int i = otherData.size() - 1; i >= 0;
+                for (int i = otherSegmentData.size() - 1; i >= 0;
                      --i) // insert reversed, otherwise the polygon will be twisted
-                    thisData << otherData.at(i);
+                    thisSegmentData << otherSegmentData.at(i);
-                return QPolygonF(thisData);
+                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 the case when plotting with horizontal key axis.
+              \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.
             */
             /*! \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 the case when plotting with horizontal key axis.
+              \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.
             */
             /*! \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 descending, as is the case when plotting with vertical key axis.
+              \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 = 0; i < data->size(); ++i) {
+                for (int i = data->size() - 1; i >= 0; --i) {
                     if (data->at(i).y() < y) {
-                        if (i > 0)
+                        if (i < data->size() - 1)
-                            return i - 1;
+                            return i + 1;
                         else
-                            return 0;
+                            return data->size() - 1;
                     }
                 }
                 return -1;
             /*! \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 descending, as is the case when plotting with vertical key axis (since
+              \a data points are ordered ascending, as is ensured by \ref getLines/\ref getScatters if the key
-              keys are ordered ascending).
+              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 = data->size() - 1; i >= 0; --i) {
+                for (int i = 0; i < data->size(); ++i) {
                     if (data->at(i).y() > y) {
-                        if (i < data->size() - 1)
+                        if (i > 0)
-                            return i + 1;
+                            return i - 1;
                         else
-                            return data->size() - 1;
+                            return 0;
                     }
                 }
                 return -1;
             /* end of 'src/plottables/plottable-graph.cpp' */
-            /* including file 'src/plottables/plottable-curve.cpp', size 60009           */
+            /* including file 'src/plottables/plottable-curve.cpp', size 63527           */
-            /* commit 633339dadc92cb10c58ef3556b55570685fafb99 2016-09-13 23:54:56 +0200 */
+            /* commit 63bcca79007f7f56dce5dd035560f2e871d1dfc1 2017-07-20 18:02:21 +0200 */
             ////////////////////////////////////////////////////////////////////////////////////////////////////
             //////////////////// QCPCurveData
                 setScatterStyle(QCPScatterStyle());
                 setLineStyle(lsLine);
+                setScatterSkip(0);
             }
             QCPCurve::~QCPCurve()
                                                 double value, double keyMin, double valueMax, double keyMax,
                                                 double valueMin) const
             {
-                double intersectKey = keyMin;     // initial value is just fail-safe
+                // The intersection point interpolation here is done in pixel coordinates, so we don't need to
-                double intersectValue = valueMax; // initial value is just fail-safe
+                // 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
                     {
-                        intersectValue = valueMax;
+                        intersectValuePx = valueMaxPx;
-                        intersectKey
+                        intersectKeyPx = otherKeyPx
-                            = otherKey
+                                         + (keyPx - otherKeyPx) / (valuePx - otherValuePx)
-                              + (key - otherKey) / (value - otherValue) * (intersectValue - otherValue);
+                                               * (intersectValuePx - otherValuePx);
-                        if (intersectKey < keyMin
+                        if (intersectKeyPx < qMin(keyMinPx, keyMaxPx)
-                            || intersectKey > keyMax) // doesn't intersect, so must intersect other:
+                            || 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)
                         {
-                            intersectKey = keyMin;
+                            intersectKeyPx = keyMinPx;
-                            intersectValue
+                            intersectValuePx = otherValuePx
-                                = otherValue
+                                               + (valuePx - otherValuePx) / (keyPx - otherKeyPx)
-                                  + (value - otherValue) / (key - otherKey) * (intersectKey - otherKey);
+                                                     * (intersectKeyPx - otherKeyPx);
                         }
                         break;
                     }
                     case 2: // left edge
                     {
-                        intersectKey = keyMin;
+                        intersectKeyPx = keyMinPx;
-                        intersectValue
+                        intersectValuePx
-                            = otherValue + (value - otherValue) / (key - otherKey) * (intersectKey - otherKey);
+                            = otherValuePx
+                              + (valuePx - otherValuePx) / (keyPx - otherKeyPx) * (intersectKeyPx - otherKeyPx);
                         break;
                     }
                     case 3: // bottom and left edge
                     {
-                        intersectValue = valueMin;
+                        intersectValuePx = valueMinPx;
-                        intersectKey
+                        intersectKeyPx = otherKeyPx
-                            = otherKey
+                                         + (keyPx - otherKeyPx) / (valuePx - otherValuePx)
-                              + (key - otherKey) / (value - otherValue) * (intersectValue - otherValue);
+                                               * (intersectValuePx - otherValuePx);
-                        if (intersectKey < keyMin
+                        if (intersectKeyPx < qMin(keyMinPx, keyMaxPx)
-                            || intersectKey > keyMax) // doesn't intersect, so must intersect other:
+                            || 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)
                         {
-                            intersectKey = keyMin;
+                            intersectKeyPx = keyMinPx;
-                            intersectValue
+                            intersectValuePx = otherValuePx
-                                = otherValue
+                                               + (valuePx - otherValuePx) / (keyPx - otherKeyPx)
-                                  + (value - otherValue) / (key - otherKey) * (intersectKey - otherKey);
+                                                     * (intersectKeyPx - otherKeyPx);
                         }
                         break;
                     }
                     case 4: // top edge
                     {
-                        intersectValue = valueMax;
+                        intersectValuePx = valueMaxPx;
-                        intersectKey
+                        intersectKeyPx = otherKeyPx
-                            = otherKey
+                                         + (keyPx - otherKeyPx) / (valuePx - otherValuePx)
-                              + (key - otherKey) / (value - otherValue) * (intersectValue - otherValue);
+                                               * (intersectValuePx - otherValuePx);
                         break;
                     }
                     case 5: {
                     }
                     case 6: // bottom edge
                     {
-                        intersectValue = valueMin;
+                        intersectValuePx = valueMinPx;
-                        intersectKey
+                        intersectKeyPx = otherKeyPx
-                            = otherKey
+                                         + (keyPx - otherKeyPx) / (valuePx - otherValuePx)
-                              + (key - otherKey) / (value - otherValue) * (intersectValue - otherValue);
+                                               * (intersectValuePx - otherValuePx);
                         break;
                     }
                     case 7: // top and right edge
                     {
-                        intersectValue = valueMax;
+                        intersectValuePx = valueMaxPx;
-                        intersectKey
+                        intersectKeyPx = otherKeyPx
-                            = otherKey
+                                         + (keyPx - otherKeyPx) / (valuePx - otherValuePx)
-                              + (key - otherKey) / (value - otherValue) * (intersectValue - otherValue);
+                                               * (intersectValuePx - otherValuePx);
-                        if (intersectKey < keyMin
+                        if (intersectKeyPx < qMin(keyMinPx, keyMaxPx)
-                            || intersectKey > keyMax) // doesn't intersect, so must intersect other:
+                            || 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)
                         {
-                            intersectKey = keyMax;
+                            intersectKeyPx = keyMaxPx;
-                            intersectValue
+                            intersectValuePx = otherValuePx
-                                = otherValue
+                                               + (valuePx - otherValuePx) / (keyPx - otherKeyPx)
-                                  + (value - otherValue) / (key - otherKey) * (intersectKey - otherKey);
+                                                     * (intersectKeyPx - otherKeyPx);
                         }
                         break;
                     }
                     case 8: // right edge
                     {
-                        intersectKey = keyMax;
+                        intersectKeyPx = keyMaxPx;
-                        intersectValue
+                        intersectValuePx
-                            = otherValue + (value - otherValue) / (key - otherKey) * (intersectKey - otherKey);
+                            = otherValuePx
+                              + (valuePx - otherValuePx) / (keyPx - otherKeyPx) * (intersectKeyPx - otherKeyPx);
                         break;
                     }
                     case 9: // bottom and right edge
                     {
-                        intersectValue = valueMin;
+                        intersectValuePx = valueMinPx;
-                        intersectKey
+                        intersectKeyPx = otherKeyPx
-                            = otherKey
+                                         + (keyPx - otherKeyPx) / (valuePx - otherValuePx)
-                              + (key - otherKey) / (value - otherValue) * (intersectValue - otherValue);
+                                               * (intersectValuePx - otherValuePx);
-                        if (intersectKey < keyMin
+                        if (intersectKeyPx < qMin(keyMinPx, keyMaxPx)
-                            || intersectKey > keyMax) // doesn't intersect, so must intersect other:
+                            || 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)
                         {
-                            intersectKey = keyMax;
+                            intersectKeyPx = keyMaxPx;
-                            intersectValue
+                            intersectValuePx = otherValuePx
-                                = otherValue
+                                               + (valuePx - otherValuePx) / (keyPx - otherKeyPx)
-                                  + (value - otherValue) / (key - otherKey) * (intersectKey - otherKey);
+                                                     * (intersectKeyPx - otherKeyPx);
                         }
                         break;
                     }
                 }
-                return coordsToPixels(intersectKey, intersectValue);
+                if (mKeyAxis->orientation() == Qt::Horizontal)
+                    return QPointF(intersectKeyPx, intersectValuePx);
+                else
+                    return QPointF(intersectValuePx, intersectKeyPx);
             }
             /*! \internal
                                        double keyMin, double valueMax, double keyMax, double valueMin,
                                        QPointF &crossA, QPointF &crossB) const
             {
-                QList<QPointF> intersections;    // x of QPointF corresponds to key and y to value
+                // 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 mayTraverseR(), if line is parallel to value or key axis, R is
+                    // due to region filter in mayTraverse(), if line is parallel to value or key axis, region 5
-                    // traversed here
+                    // is traversed here
                     intersections.append(
-                        QPointF(key, valueMin)); // direction will be taken care of at end of method
+                        mKeyAxis->orientation() == Qt::Horizontal
-                    intersections.append(QPointF(key, valueMax));
+                            ? 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 mayTraverseR(), if line is parallel to value or key axis, R is
+                    // due to region filter in mayTraverse(), if line is parallel to value or key axis, region 5
-                    // traversed here
+                    // is traversed here
                     intersections.append(
-                        QPointF(keyMin, value)); // direction will be taken care of at end of method
+                        mKeyAxis->orientation() == Qt::Horizontal
-                    intersections.append(QPointF(keyMax, value));
+                            ? 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 keyPerValue = (key - prevKey) / (value - prevValue);
+                    double keyPerValuePx = (keyPx - prevKeyPx) / (valuePx - prevValuePx);
                     // check top of rect:
-                    gamma = prevKey + (valueMax - prevValue) * keyPerValue;
+                    gamma = prevKeyPx + (valueMaxPx - prevValuePx) * keyPerValuePx;
-                    if (gamma >= keyMin && gamma <= keyMax)
+                    if (gamma >= qMin(keyMinPx, keyMaxPx)
-                        intersections.append(QPointF(gamma, valueMax));
+                        && 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 = prevKey + (valueMin - prevValue) * keyPerValue;
+                    gamma = prevKeyPx + (valueMinPx - prevValuePx) * keyPerValuePx;
-                    if (gamma >= keyMin && gamma <= keyMax)
+                    if (gamma >= qMin(keyMinPx, keyMaxPx)
-                        intersections.append(QPointF(gamma, valueMin));
+                        && gamma <= qMax(keyMinPx, keyMaxPx)) // qMin/qMax necessary since axes may be reversed
-                    double valuePerKey = 1.0 / keyPerValue;
+                        intersections.append(mKeyAxis->orientation() == Qt::Horizontal
+                                                 ? QPointF(gamma, valueMinPx)
+                                                 : QPointF(valueMinPx, gamma));
+                    const double valuePerKeyPx = 1.0 / keyPerValuePx;
                     // check left of rect:
-                    gamma = prevValue + (keyMin - prevKey) * valuePerKey;
+                    gamma = prevValuePx + (keyMinPx - prevKeyPx) * valuePerKeyPx;
-                    if (gamma >= valueMin && gamma <= valueMax)
+                    if (gamma >= qMin(valueMinPx, valueMaxPx)
-                        intersections.append(QPointF(keyMin, gamma));
+                        && 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 = prevValue + (keyMax - prevKey) * valuePerKey;
+                    gamma = prevValuePx + (keyMaxPx - prevKeyPx) * valuePerKeyPx;
-                    if (gamma >= valueMin && gamma <= valueMax)
+                    if (gamma >= qMin(valueMinPx, valueMaxPx)
-                        intersections.append(QPointF(keyMax, gamma));
+                        && 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:
                 }
                 // possibly re-sort points so optimized point segment has same direction as original segment:
-                if ((key - prevKey) * (intersections.at(1).x() - intersections.at(0).x())
+                double xDelta = keyPx - prevKeyPx;
-                        + (value - prevValue) * (intersections.at(1).y() - intersections.at(0).y())
+                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 = coordsToPixels(intersections.at(0).x(), intersections.at(0).y());
+                crossA = intersections.at(0);
-                crossB = coordsToPixels(intersections.at(1).x(), intersections.at(1).y());
+                crossB = intersections.at(1);
                 return true;
             }
             /* end of 'src/plottables/plottable-statisticalbox.cpp' */
-            /* including file 'src/plottables/plottable-colormap.cpp', size 47531        */
+            /* including file 'src/plottables/plottable-colormap.cpp', size 47881        */
-            /* commit 633339dadc92cb10c58ef3556b55570685fafb99 2016-09-13 23:54:56 +0200 */
+            /* commit 83a770151292397b3ba4984108d7ed167a9aec65 2017-08-13 16:22:21 +0200 */
             ////////////////////////////////////////////////////////////////////////////////////////////////////
             //////////////////// QCPColorMapData
                     : 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)
                     mMapImage = QImage(
                         QSize(valueSize * valueOversamplingFactor, keySize * keyOversamplingFactor), format);
-                QImage *localMapImage = &mMapImage; // this is the image on which the colorization operates.
+                if (mMapImage.isNull()) {
-                                                    // Either the final mMapImage, or if we need oversampling,
+                    qDebug() << Q_FUNC_INFO << "Couldn't create map image (possibly too large for memory)";
-                                                    // mUndersampledMapImage
+                    mMapImage = QImage(QSize(10, 10), format);
-                if (keyOversamplingFactor > 1 || valueOversamplingFactor > 1) {
+                    mMapImage.fill(Qt::black);
-                    // 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
+                else {
+                    QImage *localMapImage = &mMapImage; // this is the image on which the colorization operates.
-                    const int lineCount = keySize;
+                                                        // Either the final mMapImage, or if we need
-                    const int rowCount = valueSize;
+                                                        // oversampling, mUndersampledMapImage
-                    for (int line = 0; line < lineCount; ++line) {
+                    if (keyOversamplingFactor > 1 || valueOversamplingFactor > 1) {
-                        QRgb *pixels = reinterpret_cast<QRgb *>(localMapImage->scanLine(
+                        // resize undersampled map image to actual key/value cell sizes:
-                            lineCount - 1 - line)); // invert scanline index because QImage counts scanlines
+                        if (keyAxis->orientation() == Qt::Horizontal
-                                                    // from top, but our vertical index counts from bottom
+                            && (mUndersampledMapImage.width() != keySize
-                                                    // (mathematical coordinate system)
+                                || mUndersampledMapImage.height() != valueSize))
-                        if (rawAlpha)
+                            mUndersampledMapImage = QImage(QSize(keySize, valueSize), format);
-                            mGradient.colorize(rawData + line, rawAlpha + line, mDataRange, pixels, rowCount,
+                        else if (keyAxis->orientation() == Qt::Vertical
-                                               lineCount, mDataScaleType == QCPAxis::stLogarithmic);
+                                 && (mUndersampledMapImage.width() != valueSize
-                        else
+                                     || mUndersampledMapImage.height() != keySize))
-                            mGradient.colorize(rawData + line, mDataRange, pixels, rowCount, lineCount,
+                            mUndersampledMapImage = QImage(QSize(valueSize, keySize), format);
-                                               mDataScaleType == QCPAxis::stLogarithmic);
+                        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 (keyOversamplingFactor > 1 || valueOversamplingFactor > 1) {
-                    if (keyAxis->orientation() == Qt::Horizontal)
+                        if (keyAxis->orientation() == Qt::Horizontal)
-                        mMapImage = mUndersampledMapImage.scaled(keySize * keyOversamplingFactor,
+                            mMapImage = mUndersampledMapImage.scaled(
-                                                                 valueSize * valueOversamplingFactor,
+                                keySize * keyOversamplingFactor, valueSize * valueOversamplingFactor,
-                                                                 Qt::IgnoreAspectRatio, Qt::FastTransformation);
+                                Qt::IgnoreAspectRatio, Qt::FastTransformation);
-                    else
+                        else
-                        mMapImage = mUndersampledMapImage.scaled(valueSize * valueOversamplingFactor,
+                            mMapImage = mUndersampledMapImage.scaled(
-                                                                 keySize * keyOversamplingFactor,
+                                valueSize * valueOversamplingFactor, keySize * keyOversamplingFactor,
-                                                                 Qt::IgnoreAspectRatio, Qt::FastTransformation);
+                                Qt::IgnoreAspectRatio, Qt::FastTransformation);
+                    }
                 }
                 mMapData->mDataModified = false;
                 mMapImageInvalidated = false;
             /* end of 'src/plottables/plottable-financial.cpp' */
-            /* including file 'src/plottables/plottable-errorbar.cpp', size 37210        */
+            /* including file 'src/plottables/plottable-errorbar.cpp', size 37355        */
-            /* commit 633339dadc92cb10c58ef3556b55570685fafb99 2016-09-13 23:54:56 +0200 */
+            /* commit 6f159843e9ec9ea6431b26591937aea13a9f2751 2017-07-25 11:13:32 +0200 */
             ////////////////////////////////////////////////////////////////////////////////////////////////////
             //////////////////// QCPErrorBarsData
                 QPointF centerPixel = mDataPlottable->interface1D()->dataPixelPosition(index);
                 if (qIsNaN(centerPixel.x()) || qIsNaN(centerPixel.y()))
                     return;
-                QCPAxis *errorAxis = mErrorType == etValueError ? mValueAxis : mKeyAxis;
+                QCPAxis *errorAxis = mErrorType == etValueError ? mValueAxis.data() : mKeyAxis.data();
-                QCPAxis *orthoAxis = mErrorType == etValueError ? mKeyAxis : mValueAxis;
+                QCPAxis *orthoAxis = mErrorType == etValueError ? mKeyAxis.data() : mValueAxis.data();
                 const double centerErrorAxisPixel
                     = errorAxis->orientation() == Qt::Horizontal ? centerPixel.x() : centerPixel.y();
                 const double centerOrthoAxisPixel
                 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()));

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages