HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2592:621c955c10d2

Fix text item margins...

Miikka Heikkinen -

r2592:621c955c10d2

parent child

Context file:

r2592:621c955c10d2

Collapse all files

src/axis/cartesianchartaxis.cpp +2 0

             /****************************************************************************
             **
             ** 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);
                     }
                 }
                 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 0

             /****************************************************************************
             **
             ** 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);
             }
             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/chartaxiselement_p.h +2 -2

             /****************************************************************************
             **
             ** 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$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the Qt Enterprise Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef CHARTAXISELEMENT_H
             #define CHARTAXISELEMENT_H
             #include "qchartglobal.h"
             #include "chartelement_p.h"
             #include "axisanimation_p.h"
             #include <QGraphicsItem>
             #include <QGraphicsLayoutItem>
             #include <QFont>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartPresenter;
             class QAbstractAxis;
             class ChartAxisElement : public ChartElement, public QGraphicsLayoutItem
             {
                 Q_OBJECT
                 using QGraphicsLayoutItem::setGeometry;
             public:
                 ChartAxisElement(QAbstractAxis *axis, QGraphicsItem *item, bool intervalAxis = false);
                 ~ChartAxisElement();
                 virtual QRectF gridGeometry() const = 0;
                 virtual void setGeometry(const QRectF &axis, const QRectF &grid) = 0;
                 virtual bool isEmpty() = 0;
                 void setAnimation(AxisAnimation *animation) { m_animation = animation; }
                 AxisAnimation *animation() const { return m_animation; }
                 QAbstractAxis *axis() const { return m_axis; }
                 void setLayout(QVector<qreal> &layout) { m_layout = layout; }
                 QVector<qreal> &layout() { return m_layout; } // Modifiable reference
-                inline qreal labelPadding() const { return qreal(1.0); }
+                inline qreal labelPadding() const { return qreal(4.0); }
-                inline qreal titlePadding() const { return qreal(1.0); }
+                inline qreal titlePadding() const { return qreal(2.0); }
                 void setLabels(const QStringList &labels) { m_labelsList = labels; }
                 QStringList labels() const { return m_labelsList; }
                 qreal min() const;
                 qreal max() const;
                 QRectF axisGeometry() const { return m_axisRect; }
                 void setAxisGeometry(const QRectF &axisGeometry) { m_axisRect = axisGeometry; }
                 void axisSelected();
                 //this flag indicates that axis is used to show intervals it means labels are in between ticks
                 bool intervalAxis() const { return m_intervalAxis; }
                 static QStringList createValueLabels(qreal max, qreal min, int ticks, const QString &format);
                 static QStringList createLogValueLabels(qreal min, qreal max, qreal base, int ticks, const QString &format);
                 static QStringList createDateTimeLabels(qreal max, qreal min, int ticks, const QString &format);
                 // from QGraphicsLayoutItem
                 QRectF boundingRect() const
                 {
                     return QRectF();
                 }
                 // from QGraphicsLayoutItem
                 void paint(QPainter*, const QStyleOptionGraphicsItem*, QWidget*)
                 {
                 }
             protected:
                 virtual QVector<qreal> calculateLayout() const = 0;
                 virtual void updateLayout(QVector<qreal> &layout) = 0;
                 QList<QGraphicsItem *> gridItems() { return m_grid->childItems(); }
                 QList<QGraphicsItem *> labelItems() { return m_labels->childItems(); }
                 QList<QGraphicsItem *> shadeItems() { return m_shades->childItems(); }
                 QList<QGraphicsItem *> arrowItems() { return m_arrow->childItems(); }
                 QGraphicsTextItem *titleItem() const { return m_title.data(); }
                 QGraphicsItemGroup *gridGroup() { return m_grid.data(); }
                 QGraphicsItemGroup *labelGroup() { return m_labels.data(); }
                 QGraphicsItemGroup *shadeGroup() { return m_shades.data(); }
                 QGraphicsItemGroup *arrowGroup() { return m_arrow.data(); }
             public Q_SLOTS:
                 void handleVisibleChanged(bool visible);
                 void handleArrowVisibleChanged(bool visible);
                 void handleGridVisibleChanged(bool visible);
                 void handleLabelsVisibleChanged(bool visible);
                 void handleShadesVisibleChanged(bool visible);
                 void handleLabelsAngleChanged(int angle);
                 virtual void handleShadesBrushChanged(const QBrush &brush) = 0;
                 virtual void handleShadesPenChanged(const QPen &pen) = 0;
                 virtual void handleArrowPenChanged(const QPen &pen) = 0;
                 virtual void handleGridPenChanged(const QPen &pen) = 0;
                 void handleLabelsPenChanged(const QPen &pen);
                 void handleLabelsBrushChanged(const QBrush &brush);
                 void handleLabelsFontChanged(const QFont &font);
                 void handleTitlePenChanged(const QPen &pen);
                 void handleTitleBrushChanged(const QBrush &brush);
                 void handleTitleFontChanged(const QFont &font);
                 void handleTitleTextChanged(const QString &title);
                 void handleTitleVisibleChanged(bool visible);
                 void handleRangeChanged(qreal min, qreal max);
             Q_SIGNALS:
                 void clicked();
             private:
                 void connectSlots();
                 QAbstractAxis *m_axis;
                 AxisAnimation *m_animation;
                 QVector<qreal> m_layout;
                 QStringList m_labelsList;
                 QRectF m_axisRect;
                 QScopedPointer<QGraphicsItemGroup> m_grid;
                 QScopedPointer<QGraphicsItemGroup> m_arrow;
                 QScopedPointer<QGraphicsItemGroup> m_shades;
                 QScopedPointer<QGraphicsItemGroup> m_labels;
                 QScopedPointer<QGraphicsTextItem> m_title;
                 bool m_intervalAxis;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* CHARTAXISELEMENT_H */

src/axis/polarchartaxisangular.cpp +2 0

             /****************************************************************************
             **
             ** 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) {
                         labelItem->setHtml(labelList.at(i));
                         const QRectF &rect = labelItem->boundingRect();
                         QPointF labelCenter = rect.center();
                         labelItem->setTransformOriginPoint(labelCenter.x(), labelCenter.y());
                         QRectF boundingRect = ChartPresenter::textBoundingRect(axis()->labelsFont(), labelList.at(i), axis()->labelsAngle());
                         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 dummyRect;
                     title->setHtml(ChartPresenter::truncatedText(axis()->titleFont(), titleText, qreal(0.0), axisGeometry().width(), Qt::Horizontal, dummyRect));
                     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);
                 }
                 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 +2 0

             /****************************************************************************
             **
             ** 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) {
                         labelItem->setHtml(labelList.at(i));
                         QRectF labelRect = labelItem->boundingRect();
                         QPointF labelCenter = labelRect.center();
                         labelItem->setTransformOriginPoint(labelCenter.x(), labelCenter.y());
                         QRectF boundingRect = ChartPresenter::textBoundingRect(axis()->labelsFont(), labelList.at(i), axis()->labelsAngle());
                         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 dummyRect;
                     title->setHtml(ChartPresenter::truncatedText(axis()->titleFont(), titleText, qreal(0.0), radius, Qt::Horizontal, dummyRect));
                     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);
                 }
                 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

src/axis/verticalaxis.cpp +1 -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 "verticalaxis_p.h"
             #include "qabstractaxis.h"
             #include "chartpresenter_p.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             VerticalAxis::VerticalAxis(QAbstractAxis *axis, QGraphicsItem *item, bool intervalAxis)
                 : CartesianChartAxis(axis, item, intervalAxis)
             {
             }
             VerticalAxis::~VerticalAxis()
             {
             }
             void VerticalAxis::updateGeometry()
             {
                 const QVector<qreal> &layout = ChartAxisElement::layout();
                 if (layout.isEmpty())
                     return;
                 QStringList labelList = labels();
                 QList<QGraphicsItem *> lines = gridItems();
                 QList<QGraphicsItem *> labels = labelItems();
                 QList<QGraphicsItem *> shades = shadeItems();
                 QList<QGraphicsItem *> arrow = arrowItems();
                 QGraphicsTextItem *title = titleItem();
                 Q_ASSERT(labels.size() == labelList.size());
                 Q_ASSERT(layout.size() == labelList.size());
                 const QRectF &axisRect = axisGeometry();
                 const QRectF &gridRect = gridGeometry();
                 qreal height = axisRect.bottom();
                 //arrow
                 QGraphicsLineItem *arrowItem = static_cast<QGraphicsLineItem*>(arrow.at(0));
                 //arrow position
                 if (axis()->alignment() == Qt::AlignLeft)
                     arrowItem->setLine(axisRect.right(), gridRect.top(), axisRect.right(), gridRect.bottom());
                 else if (axis()->alignment() == Qt::AlignRight)
                     arrowItem->setLine(axisRect.left(), gridRect.top(), axisRect.left(), gridRect.bottom());
                 //title
                 QRectF titleBoundingRect;
                 QString titleText = axis()->titleText();
                 qreal availableSpace = axisRect.width() - labelPadding();
                 if (!titleText.isEmpty() && titleItem()->isVisible()) {
                     availableSpace -= titlePadding() * 2.0;
                     qreal minimumLabelWidth = ChartPresenter::textBoundingRect(axis()->labelsFont(), "...").width();
                     QString truncatedTitle = ChartPresenter::truncatedText(axis()->titleFont(), titleText, qreal(0.0),
                                                                            gridRect.height(), Qt::Horizontal, titleBoundingRect);
                     qreal titleSpace = availableSpace - minimumLabelWidth;
-                    if (titleSpace < titleBoundingRect.width()) {
+                    if (titleSpace < titleBoundingRect.height()) {
                         // Need to also truncate title vertically (multiline title)
                         bool skip = false;
                         if (truncatedTitle.endsWith("...")) {
                             if (truncatedTitle.size() == 3)
                                 skip = true; // Already truncated to minimum
                             else
                                 truncatedTitle.chop(3);
                         }
                         if (!skip)
                             truncatedTitle = ChartPresenter::truncatedText(axis()->titleFont(), truncatedTitle, qreal(0.0),
                                                                            titleSpace, Qt::Vertical, titleBoundingRect);
                     }
                     title->setHtml(truncatedTitle);
                     titleBoundingRect = title->boundingRect();
                     QPointF center = gridRect.center() - titleBoundingRect.center();
                     if (axis()->alignment() == Qt::AlignLeft)
                         title->setPos(axisRect.left() - titleBoundingRect.width() / 2.0 + titleBoundingRect.height() / 2.0 + titlePadding(), center.y());
                     else if (axis()->alignment() == Qt::AlignRight)
                         title->setPos(axisRect.right() - titleBoundingRect.width() / 2.0 - titleBoundingRect.height() / 2.0 - titlePadding(), center.y());
                     title->setTransformOriginPoint(titleBoundingRect.center());
                     title->setRotation(270);
                     availableSpace -= titleBoundingRect.height();
                 }
                 for (int i = 0; i < layout.size(); ++i) {
                     //items
                     QGraphicsLineItem *gridItem = static_cast<QGraphicsLineItem *>(lines.at(i));
                     QGraphicsLineItem *tickItem = static_cast<QGraphicsLineItem *>(arrow.at(i + 1));
                     QGraphicsTextItem *labelItem = static_cast<QGraphicsTextItem *>(labels.at(i));
                     //grid line
                     gridItem->setLine(gridRect.left(), layout[i], gridRect.right(), layout[i]);
                     //label text wrapping
                     QString text = labelList.at(i);
                     QRectF boundingRect;
                     labelItem->setHtml(ChartPresenter::truncatedText(axis()->labelsFont(), text, axis()->labelsAngle(),
                                        availableSpace, Qt::Horizontal, boundingRect));
                     //label transformation origin point
                     const QRectF &rect = labelItem->boundingRect();
                     QPointF center = rect.center();
                     labelItem->setTransformOriginPoint(center.x(), center.y());
                     qreal widthDiff = rect.width() - boundingRect.width();
                     qreal heightDiff = rect.height() - boundingRect.height();
                     //ticks and label position
                     if (axis()->alignment() == Qt::AlignLeft) {
                         labelItem->setPos(axisRect.right() - rect.width() + (widthDiff / 2.0) - labelPadding(), layout[i] - center.y());
                         tickItem->setLine(axisRect.right() - labelPadding(), layout[i], axisRect.right(), layout[i]);
                     } else if (axis()->alignment() == Qt::AlignRight) {
                         labelItem->setPos(axisRect.left() + labelPadding() - (widthDiff / 2.0), layout[i] - center.y());
                         tickItem->setLine(axisRect.left(), layout[i], axisRect.left() + labelPadding(), layout[i]);
                     }
                     //label in between
                     bool forceHide = false;
                     if (intervalAxis() && (i + 1) != layout.size()) {
                         qreal lowerBound = qMin(layout[i], gridRect.bottom());
                         qreal upperBound = qMax(layout[i + 1], gridRect.top());
                         const qreal delta = lowerBound - upperBound;
                         // Hide label in case visible part of the category at the grid edge is too narrow
                         if (delta < boundingRect.height()
                             && (lowerBound == gridRect.bottom() || upperBound == gridRect.top())) {
                             forceHide = true;
                         } else {
                             labelItem->setPos(labelItem->pos().x() , lowerBound - (delta / 2.0) - center.y());
                         }
                     }
                     //label overlap detection - compensate one pixel for rounding errors
                     if (labelItem->pos().y() + boundingRect.height() > height || forceHide ||
                         (labelItem->pos().y() + (heightDiff / 2.0) - 1.0) > axisRect.bottom() ||
                         labelItem->pos().y() + (heightDiff / 2.0) < (axisRect.top() - 1.0)) {
                         labelItem->setVisible(false);
                     }
                     else {
                         labelItem->setVisible(true);
                         height=labelItem->pos().y();
                     }
                     //shades
                     if ((i + 1) % 2 && i > 1) {
                         QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem *>(shades.at(i / 2 - 1));
                         qreal lowerBound = qMin(layout[i - 1], gridRect.bottom());
                         qreal upperBound = qMax(layout[i], gridRect.top());
                         rectItem->setRect(gridRect.left(), upperBound, gridRect.width(), lowerBound - upperBound);
                         if (rectItem->rect().height() <= 0.0)
                             rectItem->setVisible(false);
                         else
                             rectItem->setVisible(true);
                     }
                     // check if the grid line and the axis tick should be shown
                     qreal y = gridItem->line().p1().y();
                     if ((y < gridRect.top() || y > gridRect.bottom()))
                     {
                         gridItem->setVisible(false);
                         tickItem->setVisible(false);
                     }else{
                         gridItem->setVisible(true);
                         tickItem->setVisible(true);
                     }
                 }
                 //begin/end grid line in case labels between
                 if (intervalAxis()) {
                     QGraphicsLineItem *gridLine;
                     gridLine = static_cast<QGraphicsLineItem *>(lines.at(layout.size()));
                     gridLine->setLine(gridRect.left(), gridRect.top(), gridRect.right(), gridRect.top());
                     gridLine->setVisible(true);
                     gridLine = static_cast<QGraphicsLineItem*>(lines.at(layout.size() + 1));
                     gridLine->setLine(gridRect.left(), gridRect.bottom(), gridRect.right(), gridRect.bottom());
                     gridLine->setVisible(true);
                 }
             }
             QSizeF VerticalAxis::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(constraint);
                 QSizeF sh(0, 0);
                 if (axis()->titleText().isEmpty() || !titleItem()->isVisible())
                     return sh;
                 switch (which) {
                 case Qt::MinimumSize: {
                     QRectF titleRect = ChartPresenter::textBoundingRect(axis()->titleFont(), "...");
                     sh = QSizeF(titleRect.height() + (titlePadding() * 2.0), titleRect.width());
                     break;
                 }
                 case Qt::MaximumSize:
                 case Qt::PreferredSize: {
                     QRectF titleRect = ChartPresenter::textBoundingRect(axis()->titleFont(), axis()->titleText());
                     sh = QSizeF(titleRect.height() + (titlePadding() * 2.0), titleRect.width());
                     break;
                 }
                 default:
                     break;
                 }
                 return sh;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/abstractbarchartitem.cpp +4 -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 "abstractbarchartitem_p.h"
             #include "bar_p.h"
             #include "qbarset.h"
             #include "qbarset_p.h"
             #include "qabstractbarseries.h"
             #include "qabstractbarseries_p.h"
             #include "qchart.h"
             #include "chartpresenter_p.h"
             #include "charttheme_p.h"
             #include "baranimation_p.h"
             #include "chartdataset_p.h"
             #include <QPainter>
+            #include <QTextDocument>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             AbstractBarChartItem::AbstractBarChartItem(QAbstractBarSeries *series, QGraphicsItem* item) :
                 ChartItem(series->d_func(),item),
                 m_animation(0),
                 m_series(series)
             {
                 setFlag(ItemClipsChildrenToShape);
                 connect(series->d_func(), SIGNAL(updatedLayout()), this, SLOT(handleLayoutChanged()));
                 connect(series->d_func(), SIGNAL(updatedBars()), this, SLOT(handleUpdatedBars()));
                 connect(series->d_func(), SIGNAL(labelsVisibleChanged(bool)), this, SLOT(handleLabelsVisibleChanged(bool)));
                 connect(series->d_func(), SIGNAL(restructuredBars()), this, SLOT(handleDataStructureChanged()));
                 connect(series, SIGNAL(visibleChanged()), this, SLOT(handleVisibleChanged()));
                 connect(series, SIGNAL(opacityChanged()), this, SLOT(handleOpacityChanged()));
                 setZValue(ChartPresenter::BarSeriesZValue);
                 handleDataStructureChanged();
                 handleVisibleChanged();
                 handleUpdatedBars();
             }
             AbstractBarChartItem::~AbstractBarChartItem()
             {
             }
             void AbstractBarChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(painter);
                 Q_UNUSED(option);
                 Q_UNUSED(widget);
             }
             QRectF AbstractBarChartItem::boundingRect() const
             {
                 return m_rect;
             }
             void AbstractBarChartItem::applyLayout(const QVector<QRectF> &layout)
             {
                 QSizeF size = geometry().size();
                 if (geometry().size().isValid()) {
                     if (m_animation) {
                         if (m_layout.count() == 0 || m_oldSize != size) {
                             initializeLayout();
                             m_oldSize = size;
                         }
                         m_animation->setup(m_layout, layout);
                         presenter()->startAnimation(m_animation);
                     } else {
                         setLayout(layout);
                         update();
                     }
                 }
             }
             void AbstractBarChartItem::setAnimation(BarAnimation *animation)
             {
                 m_animation = animation;
             }
             void AbstractBarChartItem::setLayout(const QVector<QRectF> &layout)
             {
                 if (layout.count() != m_bars.count())
                     return;
                 m_layout = layout;
                 for (int i = 0; i < m_bars.count(); i++) {
                     m_bars.at(i)->setRect(layout.at(i));
                     QGraphicsTextItem *label = m_labels.at(i);
                     label->setPos(layout.at(i).center() - label->boundingRect().center());
                 }
             }
             //handlers
             void AbstractBarChartItem::handleDomainUpdated()
             {
                 m_domainMinX = domain()->minX();
                 m_domainMaxX = domain()->maxX();
                 m_domainMinY = domain()->minY();
                 m_domainMaxY = domain()->maxY();
                 QRectF rect(QPointF(0,0),domain()->size());
                 if(m_rect != rect){
                     prepareGeometryChange();
                     m_rect = rect;
                 }
                 handleLayoutChanged();
             }
             void AbstractBarChartItem::handleLayoutChanged()
             {
                 if ((m_rect.width() <= 0) || (m_rect.height() <= 0))
                     return; // rect size zero.
                 QVector<QRectF> layout = calculateLayout();
                 applyLayout(layout);
                 handleUpdatedBars();
             }
             void AbstractBarChartItem::handleLabelsVisibleChanged(bool visible)
             {
                 foreach (QGraphicsTextItem *label, m_labels)
                     label->setVisible(visible);
                 update();
             }
             void AbstractBarChartItem::handleDataStructureChanged()
             {
                 foreach (QGraphicsItem *item, childItems())
                     delete item;
                 m_bars.clear();
                 m_labels.clear();
                 m_layout.clear();
                 // Create new graphic items for bars
                 for (int c = 0; c < m_series->d_func()->categoryCount(); c++) {
                     for (int s = 0; s < m_series->count(); s++) {
                         QBarSet *set = m_series->d_func()->barsetAt(s);
                         // Bars
                         Bar *bar = new Bar(set, c, this);
                         m_bars.append(bar);
                         connect(bar, SIGNAL(clicked(int,QBarSet*)), m_series, SIGNAL(clicked(int,QBarSet*)));
                         connect(bar, SIGNAL(hovered(bool,QBarSet*)), m_series, SIGNAL(hovered(bool,QBarSet*)));
                         connect(bar, SIGNAL(clicked(int,QBarSet*)), set, SIGNAL(clicked(int)));
                         connect(bar, SIGNAL(hovered(bool,QBarSet*)), set, SIGNAL(hovered(bool)));
                         //            m_layout.append(QRectF(0, 0, 1, 1));
                         // Labels
-                        m_labels.append(new QGraphicsTextItem(this));
+                        QGraphicsTextItem *newLabel = new QGraphicsTextItem(this);
+                        newLabel->document()->setDocumentMargin(ChartPresenter::textMargin());
+                        m_labels.append(newLabel);
                     }
                 }
                 if(themeManager()) themeManager()->updateSeries(m_series);
                 handleLayoutChanged();
                 handleVisibleChanged();
             }
             void AbstractBarChartItem::handleVisibleChanged()
             {
                 bool visible = m_series->isVisible();
                 if (visible)
                     handleLabelsVisibleChanged(m_series->isLabelsVisible());
                 else
                     handleLabelsVisibleChanged(visible);
                 foreach (QGraphicsItem *bar, m_bars)
                     bar->setVisible(visible);
             }
             void AbstractBarChartItem::handleOpacityChanged()
             {
                 foreach (QGraphicsItem *item, childItems())
                     item->setOpacity(m_series->opacity());
             }
             void AbstractBarChartItem::handleUpdatedBars()
             {
                 // Handle changes in pen, brush, labels etc.
                 int categoryCount = m_series->d_func()->categoryCount();
                 int setCount = m_series->count();
                 int itemIndex(0);
                 for (int category = 0; category < categoryCount; category++) {
                     for (int set = 0; set < setCount; set++) {
                         QBarSetPrivate *barSet = m_series->d_func()->barsetAt(set)->d_ptr.data();
                         Bar *bar = m_bars.at(itemIndex);
                         bar->setPen(barSet->m_pen);
                         bar->setBrush(barSet->m_brush);
                         bar->update();
                         QGraphicsTextItem *label = m_labels.at(itemIndex);
                         label->setHtml(QString("%1").arg(barSet->value(category)));
                         label->setFont(barSet->m_labelFont);
                         label->setDefaultTextColor(barSet->m_labelBrush.color());
                         label->update();
                         itemIndex++;
                     }
                 }
             }
             #include "moc_abstractbarchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartpresenter.cpp +6 0

             /****************************************************************************
              **
              ** 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 "chartpresenter_p.h"
             #include "qchart.h"
             #include "chartitem_p.h"
             #include "qchart_p.h"
             #include "qabstractaxis.h"
             #include "qabstractaxis_p.h"
             #include "chartdataset_p.h"
             #include "chartanimation_p.h"
             #include "qabstractseries_p.h"
             #include "qareaseries.h"
             #include "chartaxiselement_p.h"
             #include "chartbackground_p.h"
             #include "cartesianchartlayout_p.h"
             #include "polarchartlayout_p.h"
             #include "charttitle_p.h"
             #include <QTimer>
+            #include <QTextDocument>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartPresenter::ChartPresenter(QChart *chart, QChart::ChartType type)
                 : QObject(chart),
                   m_chart(chart),
                   m_options(QChart::NoAnimation),
                   m_state(ShowState),
                   m_background(0),
                   m_plotAreaBackground(0),
                   m_title(0)
             {
                 if (type == QChart::ChartTypeCartesian)
                     m_layout = new CartesianChartLayout(this);
                 else if (type == QChart::ChartTypePolar)
                     m_layout = new PolarChartLayout(this);
                 Q_ASSERT(m_layout);
             }
             ChartPresenter::~ChartPresenter()
             {
             }
             void ChartPresenter::setGeometry(const QRectF rect)
             {
                 if (m_rect != rect) {
                     m_rect = rect;
                     foreach (ChartItem *chart, m_chartItems) {
                         chart->domain()->setSize(rect.size());
                         chart->setPos(rect.topLeft());
                     }
                 }
             }
             QRectF ChartPresenter::geometry() const
             {
                 return m_rect;
             }
             void ChartPresenter::handleAxisAdded(QAbstractAxis *axis)
             {
                 axis->d_ptr->initializeGraphics(rootItem());
                 axis->d_ptr->initializeAnimations(m_options);
                 ChartAxisElement *item = axis->d_ptr->axisItem();
                 item->setPresenter(this);
                 item->setThemeManager(m_chart->d_ptr->m_themeManager);
                 m_axisItems<<item;
                 m_axes<<axis;
                 m_layout->invalidate();
             }
             void ChartPresenter::handleAxisRemoved(QAbstractAxis *axis)
             {
                 ChartAxisElement *item  = axis->d_ptr->m_item.take();
                 item->hide();
                 item->disconnect();
                 item->deleteLater();
                 m_axisItems.removeAll(item);
                 m_axes.removeAll(axis);
                 m_layout->invalidate();
             }
             void ChartPresenter::handleSeriesAdded(QAbstractSeries *series)
             {
                 series->d_ptr->initializeGraphics(rootItem());
                 series->d_ptr->initializeAnimations(m_options);
                 ChartItem *chart = series->d_ptr->chartItem();
                 chart->setPresenter(this);
                 chart->setThemeManager(m_chart->d_ptr->m_themeManager);
                 chart->domain()->setSize(m_rect.size());
                 chart->setPos(m_rect.topLeft());
                 chart->handleDomainUpdated(); //this could be moved to intializeGraphics when animator is refactored
                 m_chartItems<<chart;
                 m_series<<series;
                 m_layout->invalidate();
             }
             void ChartPresenter::handleSeriesRemoved(QAbstractSeries *series)
             {
                 ChartItem *chart  = series->d_ptr->m_item.take();
                 chart->hide();
                 chart->disconnect();
                 chart->deleteLater();
                 m_chartItems.removeAll(chart);
                 m_series.removeAll(series);
                 m_layout->invalidate();
             }
             void ChartPresenter::setAnimationOptions(QChart::AnimationOptions options)
             {
                 if (m_options != options) {
                     QChart::AnimationOptions oldOptions = m_options;
                     m_options = options;
                     if (options.testFlag(QChart::SeriesAnimations) != oldOptions.testFlag(QChart::SeriesAnimations)) {
                         foreach (QAbstractSeries *series, m_series)
                             series->d_ptr->initializeAnimations(m_options);
                     }
                     if (options.testFlag(QChart::GridAxisAnimations) != oldOptions.testFlag(QChart::GridAxisAnimations)) {
                         foreach (QAbstractAxis *axis, m_axes)
                             axis->d_ptr->initializeAnimations(m_options);
                     }
                     m_layout->invalidate(); // So that existing animations don't just stop halfway
                 }
             }
             void ChartPresenter::setState(State state,QPointF point)
             {
             	m_state=state;
             	m_statePoint=point;
             }
             QChart::AnimationOptions ChartPresenter::animationOptions() const
             {
                 return m_options;
             }
             void ChartPresenter::createBackgroundItem()
             {
                 if (!m_background) {
                     m_background = new ChartBackground(rootItem());
                     m_background->setPen(Qt::NoPen); // Theme doesn't touch pen so don't use default
                     m_background->setBrush(QChartPrivate::defaultBrush());
                     m_background->setZValue(ChartPresenter::BackgroundZValue);
                 }
             }
             void ChartPresenter::createPlotAreaBackgroundItem()
             {
                 if (!m_plotAreaBackground) {
                     if (m_chart->chartType() == QChart::ChartTypeCartesian)
                         m_plotAreaBackground = new QGraphicsRectItem(rootItem());
                     else
                         m_plotAreaBackground = new QGraphicsEllipseItem(rootItem());
                     // Use transparent pen instead of Qt::NoPen, as Qt::NoPen causes
                     // antialising artifacts with axis lines for some reason.
                     m_plotAreaBackground->setPen(QPen(Qt::transparent));
                     m_plotAreaBackground->setBrush(Qt::NoBrush);
                     m_plotAreaBackground->setZValue(ChartPresenter::PlotAreaZValue);
                     m_plotAreaBackground->setVisible(false);
                 }
             }
             void ChartPresenter::createTitleItem()
             {
                 if (!m_title) {
                     m_title = new ChartTitle(rootItem());
                     m_title->setZValue(ChartPresenter::BackgroundZValue);
                 }
             }
             void ChartPresenter::startAnimation(ChartAnimation *animation)
             {
                 animation->stop();
                 QTimer::singleShot(0, animation, SLOT(startChartAnimation()));
             }
             void ChartPresenter::setBackgroundBrush(const QBrush &brush)
             {
                 createBackgroundItem();
                 m_background->setBrush(brush);
                 m_layout->invalidate();
             }
             QBrush ChartPresenter::backgroundBrush() const
             {
                 if (!m_background)
                     return QBrush();
                 return m_background->brush();
             }
             void ChartPresenter::setBackgroundPen(const QPen &pen)
             {
                 createBackgroundItem();
                 m_background->setPen(pen);
                 m_layout->invalidate();
             }
             QPen ChartPresenter::backgroundPen() const
             {
                 if (!m_background)
                     return QPen();
                 return m_background->pen();
             }
             void ChartPresenter::setBackgroundRoundness(qreal diameter)
             {
                 createBackgroundItem();
                 m_background->setDiameter(diameter);
                 m_layout->invalidate();
             }
             qreal ChartPresenter::backgroundRoundness() const
             {
                 if (!m_background)
                     return 0;
                 return m_background->diameter();
             }
             void ChartPresenter::setPlotAreaBackgroundBrush(const QBrush &brush)
             {
                 createPlotAreaBackgroundItem();
                 m_plotAreaBackground->setBrush(brush);
                 m_layout->invalidate();
             }
             QBrush ChartPresenter::plotAreaBackgroundBrush() const
             {
                 if (!m_plotAreaBackground)
                     return QBrush();
                 return m_plotAreaBackground->brush();
             }
             void ChartPresenter::setPlotAreaBackgroundPen(const QPen &pen)
             {
                 createPlotAreaBackgroundItem();
                 m_plotAreaBackground->setPen(pen);
                 m_layout->invalidate();
             }
             QPen ChartPresenter::plotAreaBackgroundPen() const
             {
                 if (!m_plotAreaBackground)
                     return QPen();
                 return m_plotAreaBackground->pen();
             }
             void ChartPresenter::setTitle(const QString &title)
             {
                 createTitleItem();
                 m_title->setText(title);
                 m_layout->invalidate();
             }
             QString ChartPresenter::title() const
             {
                 if (!m_title)
                     return QString();
                 return m_title->text();
             }
             void ChartPresenter::setTitleFont(const QFont &font)
             {
                 createTitleItem();
                 m_title->setFont(font);
                 m_layout->invalidate();
             }
             QFont ChartPresenter::titleFont() const
             {
                 if (!m_title)
                     return QFont();
                 return m_title->font();
             }
             void ChartPresenter::setTitleBrush(const QBrush &brush)
             {
                 createTitleItem();
                 m_title->setDefaultTextColor(brush.color());
                 m_layout->invalidate();
             }
             QBrush ChartPresenter::titleBrush() const
             {
                 if (!m_title)
                     return QBrush();
                 return QBrush(m_title->defaultTextColor());
             }
             void ChartPresenter::setBackgroundVisible(bool visible)
             {
                 createBackgroundItem();
                 m_background->setVisible(visible);
             }
             bool ChartPresenter::isBackgroundVisible() const
             {
                 if (!m_background)
                     return false;
                 return m_background->isVisible();
             }
             void ChartPresenter::setPlotAreaBackgroundVisible(bool visible)
             {
                 createPlotAreaBackgroundItem();
                 m_plotAreaBackground->setVisible(visible);
             }
             bool ChartPresenter::isPlotAreaBackgroundVisible() const
             {
                 if (!m_plotAreaBackground)
                     return false;
                 return m_plotAreaBackground->isVisible();
             }
             void ChartPresenter::setBackgroundDropShadowEnabled(bool enabled)
             {
                 createBackgroundItem();
                 m_background->setDropShadowEnabled(enabled);
             }
             bool ChartPresenter::isBackgroundDropShadowEnabled() const
             {
                 if (!m_background)
                     return false;
                 return m_background->isDropShadowEnabled();
             }
             AbstractChartLayout *ChartPresenter::layout()
             {
                 return m_layout;
             }
             QLegend *ChartPresenter::legend()
             {
                 return m_chart->legend();
             }
             void ChartPresenter::setVisible(bool visible)
             {
                 m_chart->setVisible(visible);
             }
             ChartBackground *ChartPresenter::backgroundElement()
             {
                 return m_background;
             }
             QAbstractGraphicsShapeItem *ChartPresenter::plotAreaElement()
             {
                 return m_plotAreaBackground;
             }
             QList<ChartAxisElement *>  ChartPresenter::axisItems() const
             {
                 return m_axisItems;
             }
             QList<ChartItem *> ChartPresenter::chartItems() const
             {
                 return m_chartItems;
             }
             ChartTitle *ChartPresenter::titleElement()
             {
                 return m_title;
             }
             QRectF ChartPresenter::textBoundingRect(const QFont &font, const QString &text, qreal angle)
             {
                 static QGraphicsTextItem dummyTextItem;
+                static bool initMargin = true;
+                if (initMargin) {
+                    dummyTextItem.document()->setDocumentMargin(textMargin());
+                    initMargin = false;
+                }
                 dummyTextItem.setFont(font);
                 dummyTextItem.setHtml(text);
                 QRectF boundingRect = dummyTextItem.boundingRect();
                 // Take rotation into account
                 if (angle) {
                     QTransform transform;
                     transform.rotate(angle);
                     boundingRect = transform.mapRect(boundingRect);
                 }
                 return boundingRect;
             }
             // boundingRect parameter returns the rotated bounding rect of the text
             QString ChartPresenter::truncatedText(const QFont &font, const QString &text, qreal angle,
                                                   qreal maxSize, Qt::Orientation constraintOrientation,
                                                   QRectF &boundingRect)
             {
                 QString truncatedString(text);
                 boundingRect = textBoundingRect(font, truncatedString, angle);
                 qreal checkDimension = ((constraintOrientation == Qt::Horizontal)
                                        ? boundingRect.width() : boundingRect.height());
                 if (checkDimension > maxSize) {
                     // It can be assumed that almost any amount of string manipulation is faster
                     // than calculating one bounding rectangle, so first prepare a list of truncated strings
                     // to try.
                     static const char *truncateMatchString = "&#?[0-9a-zA-Z]*;$";
                     static QRegExp truncateMatcher(truncateMatchString);
                     QVector<QString> testStrings(text.length());
                     int count(0);
                     static QLatin1Char closeTag('>');
                     static QLatin1Char openTag('<');
                     static QLatin1Char semiColon(';');
                     static QLatin1String ellipsis("...");
                     while (truncatedString.length() > 1) {
                         int chopIndex(-1);
                         int chopCount(1);
                         QChar lastChar(truncatedString.at(truncatedString.length() - 1));
                         if (lastChar == closeTag)
                             chopIndex = truncatedString.lastIndexOf(openTag);
                         else if (lastChar == semiColon)
                             chopIndex = truncateMatcher.indexIn(truncatedString, 0);
                         if (chopIndex != -1)
                             chopCount = truncatedString.length() - chopIndex;
                         truncatedString.chop(chopCount);
                         testStrings[count] = truncatedString + ellipsis;
                         count++;
                     }
                     // Binary search for best fit
                     int minIndex(0);
                     int maxIndex(count - 1);
                     int bestIndex(count);
                     QRectF checkRect;
                     while (maxIndex >= minIndex) {
                         int mid = (maxIndex + minIndex) / 2;
                         checkRect = textBoundingRect(font, testStrings.at(mid), angle);
                         checkDimension = ((constraintOrientation == Qt::Horizontal)
                                          ? checkRect.width() : checkRect.height());
                         if (checkDimension > maxSize) {
                             // Checked index too large, all under this are also too large
                             minIndex = mid + 1;
                         } else {
                             // Checked index fits, all over this also fit
                             maxIndex = mid - 1;
                             bestIndex = mid;
                             boundingRect = checkRect;
                         }
                     }
                     // Default to "..." if nothing fits
                     if (bestIndex == count) {
                         boundingRect = textBoundingRect(font, ellipsis, angle);
                         truncatedString = ellipsis;
                     } else {
                         truncatedString = testStrings.at(bestIndex);
                     }
                 }
                 return truncatedString;
             }
             #include "moc_chartpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartpresenter_p.h +1 0

             /****************************************************************************
             **
             ** 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$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the Qt Enterprise Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef CHARTPRESENTER_H
             #define CHARTPRESENTER_H
             #include "qchartglobal.h"
             #include "qchart.h" //because of QChart::ChartThemeId
             #include <QRectF>
             #include <QMargins>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartItem;
             class AxisItem;
             class QAbstractSeries;
             class ChartDataSet;
             class AbstractDomain;
             class ChartAxisElement;
             class ChartAnimator;
             class ChartBackground;
             class ChartTitle;
             class ChartAnimation;
             class AbstractChartLayout;
             class ChartPresenter: public QObject
             {
                 Q_OBJECT
             public:
                 enum ZValues {
                     BackgroundZValue = -1,
                     PlotAreaZValue,
                     ShadesZValue,
                     GridZValue,
                     AxisZValue,
                     SeriesZValue,
                     LineChartZValue = SeriesZValue,
                     SplineChartZValue = SeriesZValue,
                     BarSeriesZValue = SeriesZValue,
                     ScatterSeriesZValue = SeriesZValue,
                     PieSeriesZValue = SeriesZValue,
                     BoxPlotSeriesZValue = SeriesZValue,
                     LegendZValue,
                     TopMostZValue
                 };
                 enum State {
                     ShowState,
                     ScrollUpState,
                     ScrollDownState,
                     ScrollLeftState,
                     ScrollRightState,
                     ZoomInState,
                     ZoomOutState
                 };
                 ChartPresenter(QChart *chart, QChart::ChartType type);
                 virtual ~ChartPresenter();
                 void setGeometry(QRectF rect);
                 QRectF geometry() const;
                 QGraphicsItem *rootItem(){ return m_chart; }
                 ChartBackground *backgroundElement();
                 QAbstractGraphicsShapeItem *plotAreaElement();
                 ChartTitle *titleElement();
                 QList<ChartAxisElement *> axisItems() const;
                 QList<ChartItem *> chartItems() const;
                 QLegend *legend();
                 void setBackgroundBrush(const QBrush &brush);
                 QBrush backgroundBrush() const;
                 void setBackgroundPen(const QPen &pen);
                 QPen backgroundPen() const;
                 void setBackgroundRoundness(qreal diameter);
                 qreal backgroundRoundness() const;
                 void setPlotAreaBackgroundBrush(const QBrush &brush);
                 QBrush plotAreaBackgroundBrush() const;
                 void setPlotAreaBackgroundPen(const QPen &pen);
                 QPen plotAreaBackgroundPen() const;
                 void setTitle(const QString &title);
                 QString title() const;
                 void setTitleFont(const QFont &font);
                 QFont titleFont() const;
                 void setTitleBrush(const QBrush &brush);
                 QBrush titleBrush() const;
                 void setBackgroundVisible(bool visible);
                 bool isBackgroundVisible() const;
                 void setPlotAreaBackgroundVisible(bool visible);
                 bool isPlotAreaBackgroundVisible() const;
                 void setBackgroundDropShadowEnabled(bool enabled);
                 bool isBackgroundDropShadowEnabled() const;
                 void setVisible(bool visible);
                 void setAnimationOptions(QChart::AnimationOptions options);
                 QChart::AnimationOptions animationOptions() const;
                 void startAnimation(ChartAnimation *animation);
                 void setState(State state,QPointF point);
                 State state() const { return m_state; }
                 QPointF statePoint() const { return m_statePoint; }
                 AbstractChartLayout *layout();
                 QChart::ChartType chartType() const { return m_chart->chartType(); }
                 QChart *chart() { return m_chart; }
                 static QRectF textBoundingRect(const QFont &font, const QString &text, qreal angle = 0.0);
                 static QString truncatedText(const QFont &font, const QString &text, qreal angle, qreal maxSize,
                                              Qt::Orientation constraintOrientation, QRectF &boundingRect);
+                inline static qreal textMargin() { return qreal(0.5); }
             private:
                 void createBackgroundItem();
                 void createPlotAreaBackgroundItem();
                 void createTitleItem();
             public Q_SLOTS:
                 void handleSeriesAdded(QAbstractSeries *series);
                 void handleSeriesRemoved(QAbstractSeries *series);
                 void handleAxisAdded(QAbstractAxis *axis);
                 void handleAxisRemoved(QAbstractAxis *axis);
             private:
                 QChart *m_chart;
                 QList<ChartItem *> m_chartItems;
                 QList<ChartAxisElement *> m_axisItems;
                 QList<QAbstractSeries *> m_series;
                 QList<QAbstractAxis *> m_axes;
                 QChart::AnimationOptions m_options;
                 State m_state;
                 QPointF m_statePoint;
                 AbstractChartLayout *m_layout;
                 ChartBackground *m_background;
                 QAbstractGraphicsShapeItem *m_plotAreaBackground;
                 ChartTitle *m_title;
                 QRectF m_rect;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* CHARTPRESENTER_H */

src/charttitle.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 "charttitle_p.h"
             #include "chartpresenter_p.h"
             #include <QFont>
             #include <QFontMetrics>
             #include <QDebug>
+            #include <QTextDocument>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartTitle::ChartTitle(QGraphicsItem *parent)
                 : QGraphicsTextItem(parent)
             {
+                document()->setDocumentMargin(ChartPresenter::textMargin());
             }
             ChartTitle::~ChartTitle()
             {
             }
             void ChartTitle::setText(const QString &text)
             {
                 m_text = text;
             }
             QString ChartTitle::text() const
             {
                 return m_text;
             }
             void ChartTitle::setGeometry(const QRectF &rect)
             {
                 QRectF dummyRect;
                 QGraphicsTextItem::setHtml(ChartPresenter::truncatedText(font(), m_text, qreal(0.0), rect.width(), Qt::Horizontal, dummyRect));
                 setPos(rect.topLeft());
             }
             QSizeF ChartTitle::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(constraint);
                 QSizeF sh;
                 switch (which) {
                 case Qt::MinimumSize: {
                     QRectF titleRect = ChartPresenter::textBoundingRect(font(), "...");
                     sh = QSizeF(titleRect.width(), titleRect.height());
                     break;
                 }
                 case Qt::PreferredSize:
                 case Qt::MaximumSize: {
                     QRectF titleRect = ChartPresenter::textBoundingRect(font(), m_text);
                     sh = QSizeF(titleRect.width(), titleRect.height());
                     break;
                 }
                 case Qt::MinimumDescent: {
                     QFontMetrics fn(font());
                     sh = QSizeF(0, fn.descent());
                     break;
                 }
                 default:
                     break;
                 }
                 return sh;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/legend/legendmarkeritem.cpp +6 -3

             /****************************************************************************
              **
              ** 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 <QPainter>
             #include <QGraphicsSceneEvent>
             #include <QGraphicsTextItem>
+            #include <QTextDocument>
             #include "qlegend.h"
             #include "qlegend_p.h"
             #include "qlegendmarker.h"
             #include "qlegendmarker_p.h"
             #include "legendmarkeritem_p.h"
             #include "chartpresenter_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             LegendMarkerItem::LegendMarkerItem(QLegendMarkerPrivate *marker, QGraphicsObject *parent) :
                 QGraphicsObject(parent),
                 m_marker(marker),
                 m_markerRect(0,0,10.0,10.0),
                 m_boundingRect(0,0,0,0),
                 m_textItem(new QGraphicsTextItem(this)),
                 m_rectItem(new QGraphicsRectItem(this)),
-                m_margin(1),
+                m_margin(3),
-                m_space(2),
+                m_space(4),
                 m_hovering(false),
                 m_pressPos(0, 0)
             {
                 m_rectItem->setRect(m_markerRect);
+                m_textItem->document()->setDocumentMargin(ChartPresenter::textMargin());
                 setAcceptHoverEvents(true);
             }
             LegendMarkerItem::~LegendMarkerItem()
             {
                 if (m_hovering) {
                     emit m_marker->q_ptr->hovered(false);
                 }
             }
             void LegendMarkerItem::setPen(const QPen &pen)
             {
                 m_rectItem->setPen(pen);
             }
             QPen LegendMarkerItem::pen() const
             {
                 return m_rectItem->pen();
             }
             void LegendMarkerItem::setBrush(const QBrush &brush)
             {
                 m_rectItem->setBrush(brush);
             }
             QBrush LegendMarkerItem::brush() const
             {
                 return m_rectItem->brush();
             }
             void LegendMarkerItem::setFont(const QFont &font)
             {
                 m_textItem->setFont(font);
                 QFontMetrics fn(font);
                 m_markerRect = QRectF(0,0,fn.height()/2,fn.height()/2);
                 updateGeometry();
             }
             QFont LegendMarkerItem::font() const
             {
                 return m_textItem->font();
             }
             void LegendMarkerItem::setLabel(const QString label)
             {
                 m_label = label;
                 updateGeometry();
             }
             QString LegendMarkerItem::label() const
             {
                 return m_label;
             }
             void LegendMarkerItem::setLabelBrush(const QBrush &brush)
             {
                 m_textItem->setDefaultTextColor(brush.color());
             }
             QBrush LegendMarkerItem::labelBrush() const
             {
                 return QBrush(m_textItem->defaultTextColor());
             }
             void LegendMarkerItem::setGeometry(const QRectF &rect)
             {
                 qreal width = rect.width();
                 qreal x = m_margin + m_markerRect.width() + m_space + m_margin;
                 QRectF truncatedRect;
                 m_textItem->setHtml(ChartPresenter::truncatedText(m_textItem->font(), m_label, qreal(0.0), width - x, Qt::Horizontal, truncatedRect));
                 qreal y = qMax(m_markerRect.height() + 2 * m_margin, truncatedRect.height() + 2 * m_margin);
                 const QRectF &textRect = m_textItem->boundingRect();
                 m_textItem->setPos(x - m_margin, y / 2 - textRect.height() / 2);
                 m_rectItem->setRect(m_markerRect);
-                m_rectItem->setPos(m_margin, y / 2  - m_markerRect.height() / 2);
+                // The textMargin adjustments to position are done to make default case rects less blurry with anti-aliasing
+                m_rectItem->setPos(m_margin - ChartPresenter::textMargin(), y / 2.0  - m_markerRect.height() / 2.0 + ChartPresenter::textMargin());
                 prepareGeometryChange();
                 m_boundingRect = QRectF(0, 0, x + textRect.width() + m_margin, y);
             }
             QRectF LegendMarkerItem::boundingRect() const
             {
                 return m_boundingRect;
             }
             void LegendMarkerItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(option)
                 Q_UNUSED(widget)
                 Q_UNUSED(painter)
             }
             QSizeF LegendMarkerItem::sizeHint(Qt::SizeHint which, const QSizeF& constraint) const
             {
                 Q_UNUSED(constraint)
                 QSizeF sh;
                 switch (which) {
                 case Qt::MinimumSize: {
                     QRectF labelRect = ChartPresenter::textBoundingRect(m_textItem->font(), "...");
                     sh = QSizeF(labelRect.width() + (2.0 * m_margin) + m_space + m_markerRect.width(),
                                 qMax(m_markerRect.height(), labelRect.height()) + (2.0 * m_margin));
                     break;
                 }
                 case Qt::PreferredSize: {
                     QRectF labelRect = ChartPresenter::textBoundingRect(m_textItem->font(), m_label);
                     sh = QSizeF(labelRect.width() + (2.0 * m_margin) + m_space + m_markerRect.width(),
                                 qMax(m_markerRect.height(), labelRect.height()) + (2.0 * m_margin));
                     break;
                 }
                 default:
                     break;
                 }
                 return sh;
             }
             void LegendMarkerItem::hoverEnterEvent(QGraphicsSceneHoverEvent *event)
             {
                 Q_UNUSED(event)
                 m_hovering = true;
                 emit m_marker->q_ptr->hovered(true);
             }
             void LegendMarkerItem::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
             {
                 Q_UNUSED(event)
                 m_hovering = false;
                 emit m_marker->q_ptr->hovered(false);
             }
             #include "moc_legendmarkeritem_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