HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2836:7a48aa2a436d

Fix issue with ghost axes being drawn when last axis removed...

Miikka Heikkinen -

r2836:7a48aa2a436d

parent child

Context file:

r2836:7a48aa2a436d

Collapse all files

src/charts/axis/cartesianchartaxis.cpp +3 -1

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include <private/cartesianchartaxis_p.h>
             #include <QtCharts/QAbstractAxis>
             #include <private/qabstractaxis_p.h>
             #include <private/chartpresenter_p.h>
             #include <private/abstractchartlayout_p.h>
             #include <private/abstractdomain_p.h>
             #include <private/linearrowitem_p.h>
             #include <QtCharts/QValueAxis>
             #include <QtCharts/QLogValueAxis>
             #include <QtWidgets/QGraphicsLayout>
             #include <QtGui/QTextDocument>
             QT_CHARTS_BEGIN_NAMESPACE
             CartesianChartAxis::CartesianChartAxis(QAbstractAxis *axis, QGraphicsItem *item , bool intervalAxis)
                 : ChartAxisElement(axis, item, intervalAxis)
             {
                 Q_ASSERT(item);
             }
             CartesianChartAxis::~CartesianChartAxis()
             {
             }
             void CartesianChartAxis::createItems(int count)
             {
                 if (arrowItems().size() == 0) {
                     QGraphicsLineItem *arrow = new LineArrowItem(this, this);
                     arrow->setPen(axis()->linePen());
                     arrowGroup()->addToGroup(arrow);
                 }
                 if (intervalAxis() && gridItems().size() == 0) {
                     for (int i = 0 ; i < 2 ; i  ++){
                         QGraphicsLineItem *item = new QGraphicsLineItem(this);
                         item->setPen(axis()->gridLinePen());
                         gridGroup()->addToGroup(item);
                         QGraphicsRectItem *shades = new QGraphicsRectItem(this);
                         shades->setPen(axis()->shadesPen());
                         shades->setBrush(axis()->shadesBrush());
                         shadeGroup()->addToGroup(shades);
                     }
                 }
                 QGraphicsTextItem *title = titleItem();
                 title->setFont(axis()->titleFont());
                 title->setDefaultTextColor(axis()->titleBrush().color());
                 title->setHtml(axis()->titleText());
                 for (int i = 0; i < count; ++i) {
                     QGraphicsLineItem *arrow = new QGraphicsLineItem(this);
                     QGraphicsLineItem *grid = new QGraphicsLineItem(this);
                     QGraphicsTextItem *label = new QGraphicsTextItem(this);
                     label->document()->setDocumentMargin(ChartPresenter::textMargin());
                     arrow->setPen(axis()->linePen());
                     grid->setPen(axis()->gridLinePen());
                     label->setFont(axis()->labelsFont());
                     label->setDefaultTextColor(axis()->labelsBrush().color());
                     label->setRotation(axis()->labelsAngle());
                     arrowGroup()->addToGroup(arrow);
                     gridGroup()->addToGroup(grid);
                     labelGroup()->addToGroup(label);
                     if (gridItems().size() == 1 || (((gridItems().size() + 1) % 2) && gridItems().size() > 0)) {
                         QGraphicsRectItem *shades = new QGraphicsRectItem(this);
                         shades->setPen(axis()->shadesPen());
                         shades->setBrush(axis()->shadesBrush());
                         shadeGroup()->addToGroup(shades);
                     }
                 }
             }
             void CartesianChartAxis::updateMinorTickItems()
             {
                 QValueAxis *valueAxis = qobject_cast<QValueAxis *>(this->axis());
                 if (valueAxis) {
                     int currentCount = minorArrowItems().size();
                     int expectedCount = valueAxis->minorTickCount() * (valueAxis->tickCount() - 1);
                     int diff = expectedCount - currentCount;
                     if (diff > 0) {
                         for (int i = 0; i < diff; i++) {
                             QGraphicsLineItem *minorArrow = new QGraphicsLineItem(this);
                             QGraphicsLineItem *minorGrid = new QGraphicsLineItem(this);
                             minorArrow->setPen(valueAxis->linePen());
                             minorGrid->setPen(valueAxis->minorGridLinePen());
                             minorArrowGroup()->addToGroup(minorArrow);
                             minorGridGroup()->addToGroup(minorGrid);
                         }
                     } else {
                         QList<QGraphicsItem *> minorGridLines = minorGridItems();
                         QList<QGraphicsItem *> minorArrows = minorArrowItems();
                         for (int i = 0; i > diff; i--) {
                             if (!minorGridLines.isEmpty())
                                 delete(minorGridLines.takeLast());
                             if (!minorArrows.isEmpty())
                                 delete(minorArrows.takeLast());
                         }
                     }
                 }
             }
             void CartesianChartAxis::deleteItems(int count)
             {
                 QList<QGraphicsItem *> lines = gridItems();
                 QList<QGraphicsItem *> labels = labelItems();
                 QList<QGraphicsItem *> shades = shadeItems();
                 QList<QGraphicsItem *> axis = arrowItems();
                 for (int i = 0; i < count; ++i) {
                     if (lines.size() == 1 || (((lines.size() + 1) % 2) && lines.size() > 0))
                         delete(shades.takeLast());
                     delete(lines.takeLast());
                     delete(labels.takeLast());
                     delete(axis.takeLast());
                 }
             }
             void CartesianChartAxis::updateLayout(QVector<qreal> &layout)
             {
                 int diff = ChartAxisElement::layout().size() - layout.size();
                 if (diff > 0)
                     deleteItems(diff);
                 else if (diff < 0)
                     createItems(-diff);
                 updateMinorTickItems();
                 if (animation()) {
                     switch (presenter()->state()) {
                     case ChartPresenter::ZoomInState:
                         animation()->setAnimationType(AxisAnimation::ZoomInAnimation);
                         animation()->setAnimationPoint(presenter()->statePoint());
                         break;
                     case ChartPresenter::ZoomOutState:
                         animation()->setAnimationType(AxisAnimation::ZoomOutAnimation);
                         animation()->setAnimationPoint(presenter()->statePoint());
                         break;
                     case ChartPresenter::ScrollUpState:
                     case ChartPresenter::ScrollLeftState:
                         animation()->setAnimationType(AxisAnimation::MoveBackwordAnimation);
                         break;
                     case ChartPresenter::ScrollDownState:
                     case ChartPresenter::ScrollRightState:
                         animation()->setAnimationType(AxisAnimation::MoveForwardAnimation);
                         break;
                     case ChartPresenter::ShowState:
                         animation()->setAnimationType(AxisAnimation::DefaultAnimation);
                         break;
                     }
                     animation()->setValues(ChartAxisElement::layout(), layout);
                     presenter()->startAnimation(animation());
                 } else {
                     setLayout(layout);
                     updateGeometry();
                 }
             }
             bool CartesianChartAxis::isEmpty()
             {
                 return axisGeometry().isEmpty()
                        || gridGeometry().isEmpty()
                        || qFuzzyCompare(min(), max());
             }
             void CartesianChartAxis::setGeometry(const QRectF &axis, const QRectF &grid)
             {
                 m_gridRect = grid;
                 setAxisGeometry(axis);
-                if (isEmpty())
+                if (isEmpty()) {
+                    prepareGeometryChange();
                     return;
+                }
                 QVector<qreal> layout = calculateLayout();
                 updateLayout(layout);
             }
             QSizeF CartesianChartAxis::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(which);
                 Q_UNUSED(constraint);
                 return QSizeF();
             }
             void CartesianChartAxis::handleArrowPenChanged(const QPen &pen)
             {
                 foreach (QGraphicsItem *item, arrowItems())
                     static_cast<QGraphicsLineItem *>(item)->setPen(pen);
             }
             void CartesianChartAxis::handleGridPenChanged(const QPen &pen)
             {
                 foreach (QGraphicsItem *item, gridItems())
                     static_cast<QGraphicsLineItem *>(item)->setPen(pen);
             }
             void CartesianChartAxis::handleMinorArrowPenChanged(const QPen &pen)
             {
                 foreach (QGraphicsItem *item, minorArrowItems())
                     static_cast<QGraphicsLineItem *>(item)->setPen(pen);
             }
             void CartesianChartAxis::handleMinorGridPenChanged(const QPen &pen)
             {
                 foreach (QGraphicsItem *item, minorGridItems())
                     static_cast<QGraphicsLineItem *>(item)->setPen(pen);
             }
             void CartesianChartAxis::handleGridLineColorChanged(const QColor &color)
             {
                 foreach (QGraphicsItem *item, gridItems()) {
                     QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(item);
                     QPen pen = lineItem->pen();
                     pen.setColor(color);
                     lineItem->setPen(pen);
                 }
             }
             void CartesianChartAxis::handleMinorGridLineColorChanged(const QColor &color)
             {
                 foreach (QGraphicsItem *item, minorGridItems()) {
                     QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(item);
                     QPen pen = lineItem->pen();
                     pen.setColor(color);
                     lineItem->setPen(pen);
                 }
             }
             void CartesianChartAxis::handleShadesBrushChanged(const QBrush &brush)
             {
                 foreach (QGraphicsItem *item, shadeItems())
                     static_cast<QGraphicsRectItem *>(item)->setBrush(brush);
             }
             void CartesianChartAxis::handleShadesPenChanged(const QPen &pen)
             {
                 foreach (QGraphicsItem *item, shadeItems())
                     static_cast<QGraphicsRectItem *>(item)->setPen(pen);
             }
             #include "moc_cartesianchartaxis_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/axis/polarchartaxis.cpp +3 -1

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include <private/polarchartaxis_p.h>
             #include <private/qabstractaxis_p.h>
             #include <private/chartpresenter_p.h>
             #include <QtCharts/QValueAxis>
             QT_CHARTS_BEGIN_NAMESPACE
             PolarChartAxis::PolarChartAxis(QAbstractAxis *axis, QGraphicsItem *item, bool intervalAxis)
                 : ChartAxisElement(axis, item, intervalAxis)
             {
             }
             PolarChartAxis::~PolarChartAxis()
             {
             }
             void PolarChartAxis::setGeometry(const QRectF &axis, const QRectF &grid)
             {
                 Q_UNUSED(grid);
                 setAxisGeometry(axis);
-                if (isEmpty())
+                if (isEmpty()) {
+                    prepareGeometryChange();
                     return;
+                }
                 QVector<qreal> layout = calculateLayout();
                 updateLayout(layout);
             }
             QRectF PolarChartAxis::gridGeometry() const
             {
                 return QRectF();
             }
             void PolarChartAxis::updateLayout(QVector<qreal> &layout)
             {
                 int diff = ChartAxisElement::layout().size() - layout.size();
                 if (animation()) {
                     switch (presenter()->state()) {
                     case ChartPresenter::ZoomInState:
                     case ChartPresenter::ZoomOutState:
                     case ChartPresenter::ScrollUpState:
                     case ChartPresenter::ScrollLeftState:
                     case ChartPresenter::ScrollDownState:
                     case ChartPresenter::ScrollRightState:
                     case ChartPresenter::ShowState:
                         animation()->setAnimationType(AxisAnimation::DefaultAnimation);
                         break;
                     }
                     // Update to "old" geometry before starting animation to avoid incorrectly sized
                     // axes lingering in wrong position compared to series plot before animation can kick in.
                     // Note that the position mismatch still exists even with this update, but it will be
                     // far less ugly.
                     updateGeometry();
                 }
                 if (diff > 0)
                     deleteItems(diff);
                 else if (diff < 0)
                     createItems(-diff);
                 updateMinorTickItems();
                 if (animation()) {
                     animation()->setValues(ChartAxisElement::layout(), layout);
                     presenter()->startAnimation(animation());
                 } else {
                     setLayout(layout);
                     updateGeometry();
                 }
             }
             bool PolarChartAxis::isEmpty()
             {
                 return !axisGeometry().isValid() || qFuzzyIsNull(min() - max());
             }
             void PolarChartAxis::deleteItems(int count)
             {
                 QList<QGraphicsItem *> gridLines = gridItems();
                 QList<QGraphicsItem *> labels = labelItems();
                 QList<QGraphicsItem *> shades = shadeItems();
                 QList<QGraphicsItem *> axis = arrowItems();
                 for (int i = 0; i < count; ++i) {
                     if (gridItems().size() == 1 || (((gridLines.size() + 1) % 2) && gridLines.size() > 0))
                         delete(shades.takeLast());
                     delete(gridLines.takeLast());
                     delete(labels.takeLast());
                     delete(axis.takeLast());
                 }
             }
             void PolarChartAxis::handleShadesBrushChanged(const QBrush &brush)
             {
                 foreach (QGraphicsItem *item, shadeItems())
                     static_cast<QGraphicsPathItem *>(item)->setBrush(brush);
             }
             void PolarChartAxis::handleShadesPenChanged(const QPen &pen)
             {
                 foreach (QGraphicsItem *item, shadeItems())
                     static_cast<QGraphicsPathItem *>(item)->setPen(pen);
             }
             #include "moc_polarchartaxis_p.cpp"
             QT_CHARTS_END_NAMESPACE

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