HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2608:001bc2f70487

Fix setting the axis title...

Titta Heikkala -

r2608:001bc2f70487

parent child

Context file:

r2608:001bc2f70487

Collapse all files

src/axis/cartesianchartaxis.cpp +5 -4

             /****************************************************************************
             **
             ** Copyright (C) 2013 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Enterprise Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Enterprise licenses may use this file in
             ** accordance with the Qt Enterprise License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "cartesianchartaxis_p.h"
             #include "qabstractaxis.h"
             #include "qabstractaxis_p.h"
             #include "chartpresenter_p.h"
             #include "abstractchartlayout_p.h"
             #include "abstractdomain_p.h"
             #include "linearrowitem_p.h"
             #include <QValueAxis>
             #include <QLogValueAxis>
             #include <QGraphicsLayout>
             #include <QTextDocument>
             QTCOMMERCIALCHART_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);
                     }
                 }
+                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());
-                    QGraphicsTextItem *title = titleItem();
                     arrow->setPen(axis()->linePen());
                     grid->setPen(axis()->gridLinePen());
                     label->setFont(axis()->labelsFont());
                     label->setDefaultTextColor(axis()->labelsBrush().color());
                     label->setRotation(axis()->labelsAngle());
-                    title->setFont(axis()->titleFont());
-                    title->setDefaultTextColor(axis()->titleBrush().color());
-                    title->setHtml(axis()->titleText());
                     arrowGroup()->addToGroup(arrow);
                     gridGroup()->addToGroup(grid);
                     labelGroup()->addToGroup(label);
                     if ((gridItems().size()) % 2 && gridItems().size() > 2) {
                         QGraphicsRectItem* shades = new QGraphicsRectItem(this);
                         shades->setPen(axis()->shadesPen());
                         shades->setBrush(axis()->shadesBrush());
                         shadeGroup()->addToGroup(shades);
                     }
                 }
             }
             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() % 2 && lines.size() > 1)
                         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);
                 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())
                     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::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"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/chartaxiselement.cpp +2 -1

             /****************************************************************************
             **
             ** Copyright (C) 2013 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Enterprise Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Enterprise licenses may use this file in
             ** accordance with the Qt Enterprise License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "chartaxiselement_p.h"
             #include "qabstractaxis_p.h"
             #include "chartpresenter_p.h"
             #include "abstractchartlayout_p.h"
             #include <qmath.h>
             #include <QDateTime>
             #include <QTextDocument>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             static const char *labelFormatMatchString = "%[\\-\\+#\\s\\d\\.lhjztL]*([dicuoxfegXFEG])";
             static QRegExp *labelFormatMatcher = 0;
             class StaticLabelFormatMatcherDeleter
             {
             public:
                 StaticLabelFormatMatcherDeleter() {}
                 ~StaticLabelFormatMatcherDeleter() { delete labelFormatMatcher; }
             };
             static StaticLabelFormatMatcherDeleter staticLabelFormatMatcherDeleter;
             ChartAxisElement::ChartAxisElement(QAbstractAxis *axis, QGraphicsItem *item, bool intervalAxis)
                 : ChartElement(item),
                   m_axis(axis),
                   m_animation(0),
                   m_grid(new QGraphicsItemGroup(item)),
                   m_arrow(new QGraphicsItemGroup(item)),
                   m_shades(new QGraphicsItemGroup(item)),
                   m_labels(new QGraphicsItemGroup(item)),
                   m_title(new QGraphicsTextItem(item)),
                   m_intervalAxis(intervalAxis)
             {
                 //initial initialization
                 m_arrow->setHandlesChildEvents(false);
                 m_arrow->setZValue(ChartPresenter::AxisZValue);
                 m_labels->setZValue(ChartPresenter::AxisZValue);
                 m_shades->setZValue(ChartPresenter::ShadesZValue);
                 m_grid->setZValue(ChartPresenter::GridZValue);
                 m_title->setZValue(ChartPresenter::GridZValue);
                 m_title->document()->setDocumentMargin(ChartPresenter::textMargin());
                 handleVisibleChanged(axis->isVisible());
                 connectSlots();
                 setFlag(QGraphicsItem::ItemHasNoContents, true);
             }
             ChartAxisElement::~ChartAxisElement()
             {
             }
             void ChartAxisElement::connectSlots()
             {
                 QObject::connect(axis(), SIGNAL(visibleChanged(bool)), this, SLOT(handleVisibleChanged(bool)));
                 QObject::connect(axis(), SIGNAL(lineVisibleChanged(bool)), this, SLOT(handleArrowVisibleChanged(bool)));
                 QObject::connect(axis(), SIGNAL(gridVisibleChanged(bool)), this, SLOT(handleGridVisibleChanged(bool)));
                 QObject::connect(axis(), SIGNAL(labelsVisibleChanged(bool)), this, SLOT(handleLabelsVisibleChanged(bool)));
                 QObject::connect(axis(), SIGNAL(shadesVisibleChanged(bool)), this, SLOT(handleShadesVisibleChanged(bool)));
                 QObject::connect(axis(), SIGNAL(labelsAngleChanged(int)), this, SLOT(handleLabelsAngleChanged(int)));
                 QObject::connect(axis(), SIGNAL(linePenChanged(const QPen&)), this, SLOT(handleArrowPenChanged(const QPen&)));
                 QObject::connect(axis(), SIGNAL(labelsPenChanged(const QPen&)), this, SLOT(handleLabelsPenChanged(const QPen&)));
                 QObject::connect(axis(), SIGNAL(labelsBrushChanged(const QBrush&)), this, SLOT(handleLabelsBrushChanged(const QBrush&)));
                 QObject::connect(axis(), SIGNAL(labelsFontChanged(const QFont&)), this, SLOT(handleLabelsFontChanged(const QFont&)));
                 QObject::connect(axis(), SIGNAL(gridLinePenChanged(const QPen&)), this, SLOT(handleGridPenChanged(const QPen&)));
                 QObject::connect(axis(), SIGNAL(shadesPenChanged(const QPen&)), this, SLOT(handleShadesPenChanged(const QPen&)));
                 QObject::connect(axis(), SIGNAL(shadesBrushChanged(const QBrush&)), this, SLOT(handleShadesBrushChanged(const QBrush&)));
                 QObject::connect(axis(), SIGNAL(titleTextChanged(const QString&)), this, SLOT(handleTitleTextChanged(const QString&)));
                 QObject::connect(axis(), SIGNAL(titleFontChanged(const QFont&)), this, SLOT(handleTitleFontChanged(const QFont&)));
                 QObject::connect(axis(), SIGNAL(titlePenChanged(const QPen&)), this, SLOT(handleTitlePenChanged(const QPen&)));
                 QObject::connect(axis(), SIGNAL(titleBrushChanged(const QBrush&)), this, SLOT(handleTitleBrushChanged(const QBrush&)));
                 QObject::connect(axis(), SIGNAL(titleVisibleChanged(bool)), this, SLOT(handleTitleVisibleChanged(bool)));
                 QObject::connect(axis()->d_ptr.data(), SIGNAL(rangeChanged(qreal, qreal)), this, SLOT(handleRangeChanged(qreal, qreal)));
             }
             void ChartAxisElement::handleArrowVisibleChanged(bool visible)
             {
                 m_arrow->setVisible(visible);
             }
             void ChartAxisElement::handleGridVisibleChanged(bool visible)
             {
                 m_grid->setVisible(visible);
             }
             void ChartAxisElement::handleLabelsVisibleChanged(bool visible)
             {
                 QGraphicsLayoutItem::updateGeometry();
                 presenter()->layout()->invalidate();
                 m_labels->setVisible(visible);
             }
             void ChartAxisElement::handleShadesVisibleChanged(bool visible)
             {
                 m_shades->setVisible(visible);
             }
             void ChartAxisElement::handleTitleVisibleChanged(bool visible)
             {
                 QGraphicsLayoutItem::updateGeometry();
                 presenter()->layout()->invalidate();
                 m_title->setVisible(visible);
             }
             void ChartAxisElement::handleLabelsAngleChanged(int angle)
             {
                 foreach (QGraphicsItem *item, m_labels->childItems())
                     item->setRotation(angle);
                 QGraphicsLayoutItem::updateGeometry();
                 presenter()->layout()->invalidate();
             }
             void ChartAxisElement::handleLabelsPenChanged(const QPen &pen)
             {
                 Q_UNUSED(pen)
             }
             void ChartAxisElement::handleLabelsBrushChanged(const QBrush &brush)
             {
                 foreach (QGraphicsItem *item, m_labels->childItems())
                     static_cast<QGraphicsTextItem *>(item)->setDefaultTextColor(brush.color());
             }
             void ChartAxisElement::handleLabelsFontChanged(const QFont &font)
             {
                 foreach (QGraphicsItem *item, m_labels->childItems())
                     static_cast<QGraphicsTextItem *>(item)->setFont(font);
                 QGraphicsLayoutItem::updateGeometry();
                 presenter()->layout()->invalidate();
             }
             void ChartAxisElement::handleTitleTextChanged(const QString &title)
             {
                 QGraphicsLayoutItem::updateGeometry();
                 presenter()->layout()->invalidate();
-                m_title->setHtml(title);
+                if (title.isEmpty() || !m_title->isVisible())
+                    m_title->setHtml(title);
             }
             void ChartAxisElement::handleTitlePenChanged(const QPen &pen)
             {
                 Q_UNUSED(pen)
             }
             void ChartAxisElement::handleTitleBrushChanged(const QBrush &brush)
             {
                 m_title->setDefaultTextColor(brush.color());
             }
             void ChartAxisElement::handleTitleFontChanged(const QFont &font)
             {
                 if (m_title->font() != font) {
                     m_title->setFont(font);
                     QGraphicsLayoutItem::updateGeometry();
                     presenter()->layout()->invalidate();
                 }
             }
             void ChartAxisElement::handleVisibleChanged(bool visible)
             {
                 setVisible(visible);
                 if (!visible) {
                     m_grid->setVisible(visible);
                     m_arrow->setVisible(visible);
                     m_shades->setVisible(visible);
                     m_labels->setVisible(visible);
                     m_title->setVisible(visible);
                 } else {
                     m_grid->setVisible(axis()->isGridLineVisible());
                     m_arrow->setVisible(axis()->isLineVisible());
                     m_shades->setVisible(axis()->shadesVisible());
                     m_labels->setVisible(axis()->labelsVisible());
                     m_title->setVisible(axis()->isTitleVisible());
                 }
                 if (presenter()) presenter()->layout()->invalidate();
             }
             void ChartAxisElement::handleRangeChanged(qreal min, qreal max)
             {
                 Q_UNUSED(min);
                 Q_UNUSED(max);
                 if (!isEmpty()) {
                     QVector<qreal> layout = calculateLayout();
                     updateLayout(layout);
                     QSizeF before = effectiveSizeHint(Qt::PreferredSize);
                     QSizeF after = sizeHint(Qt::PreferredSize);
                     if (before != after) {
                         QGraphicsLayoutItem::updateGeometry();
                         // We don't want to call invalidate on layout, since it will change minimum size of
                         // component, which we would like to avoid since it causes nasty flips when scrolling
                         // or zooming, instead recalculate layout and use plotArea for extra space.
                         presenter()->layout()->setGeometry(presenter()->layout()->geometry());
                     }
                 }
             }
             bool ChartAxisElement::isEmpty()
             {
                 return axisGeometry().isEmpty()
                        || gridGeometry().isEmpty()
                        || qFuzzyCompare(min(), max());
             }
             qreal ChartAxisElement::min() const
             {
                 return m_axis->d_ptr->min();
             }
             qreal ChartAxisElement::max() const
             {
                 return m_axis->d_ptr->max();
             }
             static void appendFormattedLabel(const QString &capStr, const QByteArray &array,
                                              QStringList &labels, qreal value)
             {
                 if (capStr.isEmpty()) {
                     labels << QString();
                 } else if (capStr.at(0) == QLatin1Char('d')
                     || capStr.at(0) == QLatin1Char('i')
                     || capStr.at(0) == QLatin1Char('c')) {
                     labels << QString().sprintf(array, (qint64)value);
                 } else if (capStr.at(0) == QLatin1Char('u')
                          || capStr.at(0) == QLatin1Char('o')
                          || capStr.at(0) == QLatin1Char('x')
                          || capStr.at(0) == QLatin1Char('X')) {
                     labels << QString().sprintf(array, (quint64)value);
                 } else if (capStr.at(0) == QLatin1Char('f')
                            || capStr.at(0) == QLatin1Char('F')
                            || capStr.at(0) == QLatin1Char('e')
                            || capStr.at(0) == QLatin1Char('E')
                            || capStr.at(0) == QLatin1Char('g')
                            || capStr.at(0) == QLatin1Char('G')) {
                     labels << QString().sprintf(array, value);
                 } else {
                     labels << QString();
                 }
             }
             QStringList ChartAxisElement::createValueLabels(qreal min, qreal max, int ticks, const QString &format)
             {
                 QStringList labels;
                 if (max <= min || ticks < 1)
                     return labels;
                 int n = qMax(int(-qFloor(log10((max - min) / (ticks - 1)))), 0);
                 n++;
                 if (format.isNull()) {
                     for (int i = 0; i < ticks; i++) {
                         qreal value = min + (i * (max - min) / (ticks - 1));
                         labels << QString::number(value, 'f', n);
                     }
                 } else {
                     QByteArray array = format.toLatin1();
                     QString capStr;
                     if (!labelFormatMatcher)
                         labelFormatMatcher = new QRegExp(labelFormatMatchString);
                     if (labelFormatMatcher->indexIn(format, 0) != -1)
                         capStr = labelFormatMatcher->cap(1);
                     for (int i = 0; i < ticks; i++) {
                         qreal value = min + (i * (max - min) / (ticks - 1));
                         appendFormattedLabel(capStr, array, labels, value);
                     }
                 }
                 return labels;
             }
             QStringList ChartAxisElement::createLogValueLabels(qreal min, qreal max, qreal base, int ticks, const QString &format)
             {
                 QStringList labels;
                 if (max <= min || ticks < 1)
                     return labels;
                 int n = 0;
                 if (ticks > 1)
                     n = qMax(int(-qFloor(log10((max - min) / (ticks - 1)))), 0);
                 n++;
                 int firstTick;
                 if (base > 1)
                     firstTick = ceil(log10(min) / log10(base));
                 else
                     firstTick = ceil(log10(max) / log10(base));
                 if (format.isNull()) {
                     for (int i = firstTick; i < ticks + firstTick; i++) {
                         qreal value = qPow(base, i);
                         labels << QString::number(value, 'f', n);
                     }
                 } else {
                     QByteArray array = format.toLatin1();
                     QString capStr;
                     if (!labelFormatMatcher)
                         labelFormatMatcher = new QRegExp(labelFormatMatchString);
                     if (labelFormatMatcher->indexIn(format, 0) != -1)
                         capStr = labelFormatMatcher->cap(1);
                     for (int i = firstTick; i < ticks + firstTick; i++) {
                         qreal value = qPow(base, i);
                         appendFormattedLabel(capStr, array, labels, value);
                     }
                 }
                 return labels;
             }
             QStringList ChartAxisElement::createDateTimeLabels(qreal min, qreal max,int ticks,const QString &format)
             {
                 QStringList labels;
                 if (max <= min || ticks < 1)
                     return labels;
                 int n = qMax(int(-floor(log10((max - min) / (ticks - 1)))), 0);
                 n++;
                 for (int i = 0; i < ticks; i++) {
                     qreal value = min + (i * (max - min) / (ticks - 1));
                     labels << QDateTime::fromMSecsSinceEpoch(value).toString(format);
                 }
                 return labels;
             }
             void ChartAxisElement::axisSelected()
             {
                 emit clicked();
             }
             #include "moc_chartaxiselement_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/polarchartaxisangular.cpp +5 -4

             /****************************************************************************
             **
             ** Copyright (C) 2013 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Enterprise Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Enterprise licenses may use this file in
             ** accordance with the Qt Enterprise License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "polarchartaxisangular_p.h"
             #include "chartpresenter_p.h"
             #include "abstractchartlayout_p.h"
             #include "qabstractaxis.h"
             #include "qabstractaxis_p.h"
             #include <QDebug>
             #include <qmath.h>
             #include <QTextDocument>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             PolarChartAxisAngular::PolarChartAxisAngular(QAbstractAxis *axis, QGraphicsItem *item, bool intervalAxis)
                 : PolarChartAxis(axis, item, intervalAxis)
             {
             }
             PolarChartAxisAngular::~PolarChartAxisAngular()
             {
             }
             void PolarChartAxisAngular::updateGeometry()
             {
                 QGraphicsLayoutItem::updateGeometry();
                 const QVector<qreal> &layout = this->layout();
                 if (layout.isEmpty())
                     return;
                 createAxisLabels(layout);
                 QStringList labelList = labels();
                 QPointF center = axisGeometry().center();
                 QList<QGraphicsItem *> arrowItemList = arrowItems();
                 QList<QGraphicsItem *> gridItemList = gridItems();
                 QList<QGraphicsItem *> labelItemList = labelItems();
                 QList<QGraphicsItem *> shadeItemList = shadeItems();
                 QGraphicsTextItem *title = titleItem();
                 QGraphicsEllipseItem *axisLine = static_cast<QGraphicsEllipseItem *>(arrowItemList.at(0));
                 axisLine->setRect(axisGeometry());
                 qreal radius = axisGeometry().height() / 2.0;
                 QRectF previousLabelRect;
                 QRectF firstLabelRect;
                 qreal labelHeight = 0;
                 bool firstShade = true;
                 bool nextTickVisible = false;
                 if (layout.size())
                     nextTickVisible = !(layout.at(0) < 0.0 || layout.at(0) > 360.0);
                 for (int i = 0; i < layout.size(); ++i) {
                     qreal angularCoordinate = layout.at(i);
                     QGraphicsLineItem *gridLineItem = static_cast<QGraphicsLineItem *>(gridItemList.at(i));
                     QGraphicsLineItem *tickItem = static_cast<QGraphicsLineItem *>(arrowItemList.at(i + 1));
                     QGraphicsTextItem *labelItem = static_cast<QGraphicsTextItem *>(labelItemList.at(i));
                     QGraphicsPathItem *shadeItem = 0;
                     if (i == 0)
                         shadeItem = static_cast<QGraphicsPathItem *>(shadeItemList.at(0));
                     else if (i % 2)
                         shadeItem = static_cast<QGraphicsPathItem *>(shadeItemList.at((i / 2) + 1));
                     // Ignore ticks outside valid range
                     bool currentTickVisible = nextTickVisible;
                     if ((i == layout.size() - 1)
                         || layout.at(i + 1) < 0.0
                         || layout.at(i + 1) > 360.0) {
                         nextTickVisible = false;
                     } else {
                         nextTickVisible = true;
                     }
                     qreal labelCoordinate = angularCoordinate;
                     qreal labelVisible = currentTickVisible;
                     if (intervalAxis()) {
                         qreal farEdge;
                         if (i == (layout.size() - 1))
                             farEdge = 360.0;
                         else
                             farEdge = qMin(qreal(360.0), layout.at(i + 1));
                         // Adjust the labelCoordinate to show it if next tick is visible
                         if (nextTickVisible)
                             labelCoordinate = qMax(qreal(0.0), labelCoordinate);
                         labelCoordinate = (labelCoordinate + farEdge) / 2.0;
                         // Don't display label once the category gets too small near the axis
                         if (labelCoordinate < 5.0 || labelCoordinate > 355.0)
                             labelVisible = false;
                         else
                             labelVisible = true;
                     }
                     // Need this also in label calculations, so determine it first
                     QLineF tickLine(QLineF::fromPolar(radius - tickWidth(), 90.0 - angularCoordinate).p2(),
                                     QLineF::fromPolar(radius + tickWidth(), 90.0 - angularCoordinate).p2());
                     tickLine.translate(center);
                     // Angular axis label
                     if (axis()->labelsVisible() && labelVisible) {
                         QRectF boundingRect = ChartPresenter::textBoundingRect(axis()->labelsFont(),
                                                                                labelList.at(i),
                                                                                axis()->labelsAngle());
                         labelItem->setTextWidth(boundingRect.width());
                         labelItem->setHtml(labelList.at(i));
                         const QRectF &rect = labelItem->boundingRect();
                         QPointF labelCenter = rect.center();
                         labelItem->setTransformOriginPoint(labelCenter.x(), labelCenter.y());
                         boundingRect.moveCenter(labelCenter);
                         QPointF positionDiff(rect.topLeft() - boundingRect.topLeft());
                         QPointF labelPoint;
                         if (intervalAxis()) {
                             QLineF labelLine = QLineF::fromPolar(radius + tickWidth(), 90.0 - labelCoordinate);
                             labelLine.translate(center);
                             labelPoint = labelLine.p2();
                         } else {
                             labelPoint = tickLine.p2();
                         }
                         QRectF labelRect = moveLabelToPosition(labelCoordinate, labelPoint, boundingRect);
                         labelItem->setPos(labelRect.topLeft() + positionDiff);
                         // Store height for title calculations
                         qreal labelClearance = axisGeometry().top() - labelRect.top();
                         labelHeight = qMax(labelHeight, labelClearance);
                         // Label overlap detection
                         if (i && (previousLabelRect.intersects(labelRect) || firstLabelRect.intersects(labelRect))) {
                             labelVisible = false;
                         } else {
                             // Store labelRect for future comparison. Some area is deducted to make things look
                             // little nicer, as usually intersection happens at label corner with angular labels.
                             labelRect.adjust(-2.0, -4.0, -2.0, -4.0);
                             if (firstLabelRect.isEmpty())
                                 firstLabelRect = labelRect;
                             previousLabelRect = labelRect;
                             labelVisible = true;
                         }
                     }
                     labelItem->setVisible(labelVisible);
                     if (!currentTickVisible) {
                         gridLineItem->setVisible(false);
                         tickItem->setVisible(false);
                         if (shadeItem)
                             shadeItem->setVisible(false);
                         continue;
                     }
                     // Angular grid line
                     QLineF gridLine = QLineF::fromPolar(radius, 90.0 - angularCoordinate);
                     gridLine.translate(center);
                     gridLineItem->setLine(gridLine);
                     gridLineItem->setVisible(true);
                     // Tick
                     tickItem->setLine(tickLine);
                     tickItem->setVisible(true);
                     // Shades
                     if (i % 2 || (i == 0 && !nextTickVisible)) {
                         QPainterPath path;
                         path.moveTo(center);
                         if (i == 0) {
                             // If first tick is also the last, we need to custom fill the first partial arc
                             // or it won't get filled.
                             path.arcTo(axisGeometry(), 90.0 - layout.at(0), layout.at(0));
                             path.closeSubpath();
                         } else {
                             qreal nextCoordinate;
                             if (!nextTickVisible) // Last visible tick
                                 nextCoordinate = 360.0;
                             else
                                 nextCoordinate = layout.at(i + 1);
                             qreal arcSpan = angularCoordinate - nextCoordinate;
                             path.arcTo(axisGeometry(), 90.0 - angularCoordinate, arcSpan);
                             path.closeSubpath();
                             // Add additional arc for first shade item if there is a partial arc to be filled
                             if (firstShade) {
                                 QGraphicsPathItem *specialShadeItem = static_cast<QGraphicsPathItem *>(shadeItemList.at(0));
                                 if (layout.at(i - 1) > 0.0) {
                                     QPainterPath specialPath;
                                     specialPath.moveTo(center);
                                     specialPath.arcTo(axisGeometry(), 90.0 - layout.at(i - 1), layout.at(i - 1));
                                     specialPath.closeSubpath();
                                     specialShadeItem->setPath(specialPath);
                                     specialShadeItem->setVisible(true);
                                 } else {
                                     specialShadeItem->setVisible(false);
                                 }
                             }
                         }
                         shadeItem->setPath(path);
                         shadeItem->setVisible(true);
                         firstShade = false;
                     }
                 }
                 // Title, centered above the chart
                 QString titleText = axis()->titleText();
                 if (!titleText.isEmpty() && axis()->isTitleVisible()) {
                     QRectF truncatedRect;
                     qreal availableTitleHeight = axisGeometry().height() - labelPadding() - titlePadding() * 2.0;
                     qreal minimumLabelHeight = ChartPresenter::textBoundingRect(axis()->labelsFont(), "...").height();
                     availableTitleHeight -= minimumLabelHeight;
                     title->setHtml(ChartPresenter::truncatedText(axis()->titleFont(), titleText, qreal(0.0),
                                                                  axisGeometry().width(), availableTitleHeight,
                                                                  truncatedRect));
                     title->setTextWidth(truncatedRect.width());
                     QRectF titleBoundingRect = title->boundingRect();
                     QPointF titleCenter = center - titleBoundingRect.center();
                     title->setPos(titleCenter.x(), axisGeometry().top() - titlePadding() * 2.0 - titleBoundingRect.height() - labelHeight);
                 }
             }
             Qt::Orientation PolarChartAxisAngular::orientation() const
             {
                 return Qt::Horizontal;
             }
             void PolarChartAxisAngular::createItems(int count)
             {
                 if (arrowItems().count() == 0) {
                     // angular axis line
                     QGraphicsEllipseItem *arrow = new QGraphicsEllipseItem(presenter()->rootItem());
                     arrow->setPen(axis()->linePen());
                     arrowGroup()->addToGroup(arrow);
                 }
+                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(presenter()->rootItem());
                     QGraphicsLineItem *grid = new QGraphicsLineItem(presenter()->rootItem());
                     QGraphicsTextItem *label = new QGraphicsTextItem(presenter()->rootItem());
                     label->document()->setDocumentMargin(ChartPresenter::textMargin());
-                    QGraphicsTextItem *title = titleItem();
                     arrow->setPen(axis()->linePen());
                     grid->setPen(axis()->gridLinePen());
                     label->setFont(axis()->labelsFont());
                     label->setDefaultTextColor(axis()->labelsBrush().color());
                     label->setRotation(axis()->labelsAngle());
-                    title->setFont(axis()->titleFont());
-                    title->setDefaultTextColor(axis()->titleBrush().color());
-                    title->setHtml(axis()->titleText());
                     arrowGroup()->addToGroup(arrow);
                     gridGroup()->addToGroup(grid);
                     labelGroup()->addToGroup(label);
                     if (gridItems().size() == 1 || (((gridItems().size() + 1) % 2) && gridItems().size() > 0)) {
                         QGraphicsPathItem *shade = new QGraphicsPathItem(presenter()->rootItem());
                         shade->setPen(axis()->shadesPen());
                         shade->setBrush(axis()->shadesBrush());
                         shadeGroup()->addToGroup(shade);
                     }
                 }
             }
             void PolarChartAxisAngular::handleArrowPenChanged(const QPen &pen)
             {
                 bool first = true;
                 foreach (QGraphicsItem *item, arrowItems()) {
                     if (first) {
                         first = false;
                         // First arrow item is the outer circle of axis
                         static_cast<QGraphicsEllipseItem *>(item)->setPen(pen);
                     } else {
                         static_cast<QGraphicsLineItem *>(item)->setPen(pen);
                     }
                 }
             }
             void PolarChartAxisAngular::handleGridPenChanged(const QPen &pen)
             {
                 foreach (QGraphicsItem *item, gridItems())
                     static_cast<QGraphicsLineItem *>(item)->setPen(pen);
             }
             QSizeF PolarChartAxisAngular::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(which);
                 Q_UNUSED(constraint);
                 return QSizeF(-1, -1);
             }
             qreal PolarChartAxisAngular::preferredAxisRadius(const QSizeF &maxSize)
             {
                 qreal radius = maxSize.height() / 2.0;
                 if (maxSize.width() < maxSize.height())
                     radius = maxSize.width() / 2.0;
                 if (axis()->labelsVisible()) {
                     QVector<qreal> layout = calculateLayout();
                     if (layout.isEmpty())
                         return radius;
                     createAxisLabels(layout);
                     QStringList labelList = labels();
                     QFont font = axis()->labelsFont();
                     QRectF maxRect;
                     maxRect.setSize(maxSize);
                     maxRect.moveCenter(QPointF(0.0, 0.0));
                     // This is a horrible way to find out the maximum radius for angular axis and its labels.
                     // It just increments the radius down until everyhing fits the constraint size.
                     // Proper way would be to actually calculate it but this seems to work reasonably fast as it is.
                     bool nextTickVisible = false;
                     for (int i = 0; i < layout.size(); ) {
                         if ((i == layout.size() - 1)
                             || layout.at(i + 1) < 0.0
                             || layout.at(i + 1) > 360.0) {
                             nextTickVisible = false;
                         } else {
                             nextTickVisible = true;
                         }
                         qreal labelCoordinate = layout.at(i);
                         qreal labelVisible;
                         if (intervalAxis()) {
                             qreal farEdge;
                             if (i == (layout.size() - 1))
                                 farEdge = 360.0;
                             else
                                 farEdge = qMin(qreal(360.0), layout.at(i + 1));
                             // Adjust the labelCoordinate to show it if next tick is visible
                             if (nextTickVisible)
                                 labelCoordinate = qMax(qreal(0.0), labelCoordinate);
                             labelCoordinate = (labelCoordinate + farEdge) / 2.0;
                         }
                         if (labelCoordinate < 0.0 || labelCoordinate > 360.0)
                             labelVisible = false;
                         else
                             labelVisible = true;
                         if (!labelVisible) {
                             i++;
                             continue;
                         }
                         QRectF boundingRect = ChartPresenter::textBoundingRect(axis()->labelsFont(), labelList.at(i), axis()->labelsAngle());
                         QPointF labelPoint = QLineF::fromPolar(radius + tickWidth(), 90.0 - labelCoordinate).p2();
                         boundingRect = moveLabelToPosition(labelCoordinate, labelPoint, boundingRect);
                         QRectF intersectRect = maxRect.intersected(boundingRect);
                         if (boundingRect.isEmpty() || intersectRect == boundingRect) {
                             i++;
                         } else {
                             qreal reduction(0.0);
                             // If there is no intersection, reduce by smallest dimension of label rect to be on the safe side
                             if (intersectRect.isEmpty()) {
                                 reduction = qMin(boundingRect.height(), boundingRect.width());
                             } else {
                                 // Approximate needed radius reduction is the amount label rect exceeds max rect in either dimension.
                                 // Could be further optimized by figuring out the proper math how to calculate exact needed reduction.
                                 reduction = qMax(boundingRect.height() - intersectRect.height(),
                                                  boundingRect.width() - intersectRect.width());
                             }
                             // Typically the approximated reduction is little low, so add one
                             radius -= (reduction + 1.0);
                             if (radius < 1.0) // safeguard
                                 return 1.0;
                         }
                     }
                 }
                 if (!axis()->titleText().isEmpty() && axis()->isTitleVisible()) {
                     QRectF titleRect = ChartPresenter::textBoundingRect(axis()->titleFont(), axis()->titleText());
                     radius -= titlePadding() + (titleRect.height() / 2.0);
                     if (radius < 1.0) // safeguard
                         return 1.0;
                 }
                 return radius;
             }
             QRectF PolarChartAxisAngular::moveLabelToPosition(qreal angularCoordinate, QPointF labelPoint, QRectF labelRect) const
             {
                 if (angularCoordinate == 0.0)
                     labelRect.moveCenter(labelPoint + QPointF(0, -labelRect.height() / 2.0));
                 else if (angularCoordinate < 90.0)
                     labelRect.moveBottomLeft(labelPoint);
                 else if (angularCoordinate == 90.0)
                     labelRect.moveCenter(labelPoint + QPointF(labelRect.width() / 2.0 + 2.0, 0)); // +2 so that it does not hit the radial axis
                 else if (angularCoordinate < 180.0)
                     labelRect.moveTopLeft(labelPoint);
                 else if (angularCoordinate == 180.0)
                     labelRect.moveCenter(labelPoint + QPointF(0, labelRect.height() / 2.0));
                 else if (angularCoordinate < 270.0)
                     labelRect.moveTopRight(labelPoint);
                 else if (angularCoordinate == 270.0)
                     labelRect.moveCenter(labelPoint + QPointF(-labelRect.width() / 2.0 - 2.0, 0)); // -2 so that it does not hit the radial axis
                 else if (angularCoordinate < 360.0)
                     labelRect.moveBottomRight(labelPoint);
                 else
                     labelRect.moveCenter(labelPoint + QPointF(0, -labelRect.height() / 2.0));
                 return labelRect;
             }
             #include "moc_polarchartaxisangular_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/polarchartaxisradial.cpp +5 -4

             /****************************************************************************
             **
             ** Copyright (C) 2013 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Enterprise Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Enterprise licenses may use this file in
             ** accordance with the Qt Enterprise License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "polarchartaxisradial_p.h"
             #include "chartpresenter_p.h"
             #include "abstractchartlayout_p.h"
             #include "qabstractaxis_p.h"
             #include "linearrowitem_p.h"
             #include <QTextDocument>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             PolarChartAxisRadial::PolarChartAxisRadial(QAbstractAxis *axis, QGraphicsItem *item, bool intervalAxis)
                 : PolarChartAxis(axis, item, intervalAxis)
             {
             }
             PolarChartAxisRadial::~PolarChartAxisRadial()
             {
             }
             void PolarChartAxisRadial::updateGeometry()
             {
                 const QVector<qreal> &layout = this->layout();
                 if (layout.isEmpty())
                     return;
                 createAxisLabels(layout);
                 QStringList labelList = labels();
                 QPointF center = axisGeometry().center();
                 QList<QGraphicsItem *> arrowItemList = arrowItems();
                 QList<QGraphicsItem *> gridItemList = gridItems();
                 QList<QGraphicsItem *> labelItemList = labelItems();
                 QList<QGraphicsItem *> shadeItemList = shadeItems();
                 QGraphicsTextItem* title = titleItem();
                 qreal radius = axisGeometry().height() / 2.0;
                 QLineF line(center, center + QPointF(0, -radius));
                 QGraphicsLineItem *axisLine = static_cast<QGraphicsLineItem *>(arrowItemList.at(0));
                 axisLine->setLine(line);
                 QRectF previousLabelRect;
                 bool firstShade = true;
                 bool nextTickVisible = false;
                 if (layout.size())
                     nextTickVisible = !(layout.at(0) < 0.0 || layout.at(0) > radius);
                 for (int i = 0; i < layout.size(); ++i) {
                     qreal radialCoordinate = layout.at(i);
                     QGraphicsEllipseItem *gridItem = static_cast<QGraphicsEllipseItem *>(gridItemList.at(i));
                     QGraphicsLineItem *tickItem = static_cast<QGraphicsLineItem *>(arrowItemList.at(i + 1));
                     QGraphicsTextItem *labelItem = static_cast<QGraphicsTextItem *>(labelItemList.at(i));
                     QGraphicsPathItem *shadeItem = 0;
                     if (i == 0)
                         shadeItem = static_cast<QGraphicsPathItem *>(shadeItemList.at(0));
                     else if (i % 2)
                         shadeItem = static_cast<QGraphicsPathItem *>(shadeItemList.at((i / 2) + 1));
                     // Ignore ticks outside valid range
                     bool currentTickVisible = nextTickVisible;
                     if ((i == layout.size() - 1)
                         || layout.at(i + 1) < 0.0
                         || layout.at(i + 1) > radius) {
                         nextTickVisible = false;
                     } else {
                         nextTickVisible = true;
                     }
                     qreal labelCoordinate = radialCoordinate;
                     qreal labelVisible = currentTickVisible;
                     qreal labelPad = labelPadding() / 2.0;
                     if (intervalAxis()) {
                         qreal farEdge;
                         if (i == (layout.size() - 1))
                             farEdge = radius;
                         else
                             farEdge = qMin(radius, layout.at(i + 1));
                         // Adjust the labelCoordinate to show it if next tick is visible
                         if (nextTickVisible)
                             labelCoordinate = qMax(qreal(0.0), labelCoordinate);
                         labelCoordinate = (labelCoordinate + farEdge) / 2.0;
                         if (labelCoordinate > 0.0 && labelCoordinate < radius)
                             labelVisible =  true;
                         else
                             labelVisible = false;
                     }
                     // Radial axis label
                     if (axis()->labelsVisible() && labelVisible) {
                         QRectF boundingRect = ChartPresenter::textBoundingRect(axis()->labelsFont(),
                                                                                labelList.at(i),
                                                                                axis()->labelsAngle());
                         labelItem->setTextWidth(boundingRect.width());
                         labelItem->setHtml(labelList.at(i));
                         QRectF labelRect = labelItem->boundingRect();
                         QPointF labelCenter = labelRect.center();
                         labelItem->setTransformOriginPoint(labelCenter.x(), labelCenter.y());
                         boundingRect.moveCenter(labelCenter);
                         QPointF positionDiff(labelRect.topLeft() - boundingRect.topLeft());
                         QPointF labelPoint = center;
                         if (intervalAxis())
                             labelPoint += QPointF(labelPad, -labelCoordinate - (boundingRect.height() / 2.0));
                         else
                             labelPoint += QPointF(labelPad, labelPad - labelCoordinate);
                         labelRect.moveTopLeft(labelPoint);
                         labelItem->setPos(labelRect.topLeft() + positionDiff);
                         // Label overlap detection
                         labelRect.setSize(boundingRect.size());
                         if ((i && previousLabelRect.intersects(labelRect))
                              || !axisGeometry().contains(labelRect)) {
                             labelVisible = false;
                         } else {
                             previousLabelRect = labelRect;
                             labelVisible = true;
                         }
                     }
                     labelItem->setVisible(labelVisible);
                     if (!currentTickVisible) {
                         gridItem->setVisible(false);
                         tickItem->setVisible(false);
                         if (shadeItem)
                             shadeItem->setVisible(false);
                         continue;
                     }
                     // Radial grid line
                     QRectF gridRect;
                     gridRect.setWidth(radialCoordinate * 2.0);
                     gridRect.setHeight(radialCoordinate * 2.0);
                     gridRect.moveCenter(center);
                     gridItem->setRect(gridRect);
                     gridItem->setVisible(true);
                     // Tick
                     QLineF tickLine(-tickWidth(), 0.0, tickWidth(), 0.0);
                     tickLine.translate(center.rx(), gridRect.top());
                     tickItem->setLine(tickLine);
                     tickItem->setVisible(true);
                     // Shades
                     if (i % 2 || (i == 0 && !nextTickVisible)) {
                         QPainterPath path;
                         if (i == 0) {
                             // If first tick is also the last, we need to custom fill the inner circle
                             // or it won't get filled.
                             QRectF innerCircle(0.0, 0.0, layout.at(0) * 2.0, layout.at(0) * 2.0);
                             innerCircle.moveCenter(center);
                             path.addEllipse(innerCircle);
                         } else {
                             QRectF otherGridRect;
                             if (!nextTickVisible) { // Last visible tick
                                 otherGridRect = axisGeometry();
                             } else {
                                 qreal otherGridRectDimension = layout.at(i + 1) * 2.0;
                                 otherGridRect.setWidth(otherGridRectDimension);
                                 otherGridRect.setHeight(otherGridRectDimension);
                                 otherGridRect.moveCenter(center);
                             }
                             path.addEllipse(gridRect);
                             path.addEllipse(otherGridRect);
                             // Add additional shading in first visible shade item if there is a partial tick
                             // to be filled at the center (log & category axes)
                             if (firstShade) {
                                 QGraphicsPathItem *specialShadeItem = static_cast<QGraphicsPathItem *>(shadeItemList.at(0));
                                 if (layout.at(i - 1) > 0.0) {
                                     QRectF innerCircle(0.0, 0.0, layout.at(i - 1) * 2.0, layout.at(i - 1) * 2.0);
                                     innerCircle.moveCenter(center);
                                     QPainterPath specialPath;
                                     specialPath.addEllipse(innerCircle);
                                     specialShadeItem->setPath(specialPath);
                                     specialShadeItem->setVisible(true);
                                 } else {
                                     specialShadeItem->setVisible(false);
                                 }
                             }
                         }
                         shadeItem->setPath(path);
                         shadeItem->setVisible(true);
                         firstShade = false;
                     }
                 }
                 // Title, along the 0 axis
                 QString titleText = axis()->titleText();
                 if (!titleText.isEmpty() && axis()->isTitleVisible()) {
                     QRectF truncatedRect;
                     title->setHtml(ChartPresenter::truncatedText(axis()->titleFont(), titleText, qreal(0.0),
                                                                  radius, radius, truncatedRect));
                     title->setTextWidth(truncatedRect.width());
                     QRectF titleBoundingRect = title->boundingRect();
                     QPointF titleCenter = titleBoundingRect.center();
                     QPointF arrowCenter = axisLine->boundingRect().center();
                     QPointF titleCenterDiff = arrowCenter - titleCenter;
                     title->setPos(titleCenterDiff.x() - titlePadding() - (titleBoundingRect.height() / 2.0), titleCenterDiff.y());
                     title->setTransformOriginPoint(titleCenter);
                     title->setRotation(270.0);
                 }
                 QGraphicsLayoutItem::updateGeometry();
             }
             Qt::Orientation PolarChartAxisRadial::orientation() const
             {
                 return Qt::Vertical;
             }
             void PolarChartAxisRadial::createItems(int count)
             {
                  if (arrowItems().count() == 0) {
                     // radial axis center line
                     QGraphicsLineItem *arrow = new LineArrowItem(this, presenter()->rootItem());
                     arrow->setPen(axis()->linePen());
                     arrowGroup()->addToGroup(arrow);
                 }
+                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(presenter()->rootItem());
                     QGraphicsEllipseItem *grid = new QGraphicsEllipseItem(presenter()->rootItem());
                     QGraphicsTextItem *label = new QGraphicsTextItem(presenter()->rootItem());
                     label->document()->setDocumentMargin(ChartPresenter::textMargin());
-                    QGraphicsTextItem *title = titleItem();
                     arrow->setPen(axis()->linePen());
                     grid->setPen(axis()->gridLinePen());
                     label->setFont(axis()->labelsFont());
                     label->setDefaultTextColor(axis()->labelsBrush().color());
                     label->setRotation(axis()->labelsAngle());
-                    title->setFont(axis()->titleFont());
-                    title->setDefaultTextColor(axis()->titleBrush().color());
-                    title->setHtml(axis()->titleText());
                     arrowGroup()->addToGroup(arrow);
                     gridGroup()->addToGroup(grid);
                     labelGroup()->addToGroup(label);
                     if (gridItems().size() == 1 || (((gridItems().size() + 1) % 2) && gridItems().size() > 0)) {
                         QGraphicsPathItem *shade = new QGraphicsPathItem(presenter()->rootItem());
                         shade->setPen(axis()->shadesPen());
                         shade->setBrush(axis()->shadesBrush());
                         shadeGroup()->addToGroup(shade);
                     }
                 }
             }
             void PolarChartAxisRadial::handleArrowPenChanged(const QPen &pen)
             {
                 foreach (QGraphicsItem *item, arrowItems())
                     static_cast<QGraphicsLineItem *>(item)->setPen(pen);
             }
             void PolarChartAxisRadial::handleGridPenChanged(const QPen &pen)
             {
                 foreach (QGraphicsItem *item, gridItems())
                     static_cast<QGraphicsEllipseItem *>(item)->setPen(pen);
             }
             QSizeF PolarChartAxisRadial::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(which);
                 Q_UNUSED(constraint);
                 return QSizeF(-1.0, -1.0);
             }
             qreal PolarChartAxisRadial::preferredAxisRadius(const QSizeF &maxSize)
             {
                 qreal radius = maxSize.height() / 2.0;
                 if (maxSize.width() < maxSize.height())
                     radius = maxSize.width() / 2.0;
                 return radius;
             }
             #include "moc_polarchartaxisradial_p.cpp"
             QTCOMMERCIALCHART_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