HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2413:f80448ee2136

Add padding for axis title...

Miikka Heikkinen -

r2413:f80448ee2136

parent child

Context file:

r2413:f80448ee2136

Collapse all files

src/axis/chartaxis.cpp +7 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 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 Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial 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 "chartaxis_p.h"
             #include "qabstractaxis.h"
             #include "qabstractaxis_p.h"
             #include "chartpresenter_p.h"
             #include "chartlayout_p.h"
             #include "abstractdomain_p.h"
             #include <qmath.h>
             #include <QDateTime>
             #include <QValueAxis>
             #include <QLogValueAxis>
             #include <QGraphicsLayout>
             #include <QFontMetrics>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartAxis::ChartAxis(QAbstractAxis *axis, QGraphicsItem* item , bool intervalAxis)
                 : ChartElement(item),
                   m_axis(axis),
                   m_labelsAngle(axis->labelsAngle()),
                   m_grid(new QGraphicsItemGroup(item)),
                   m_arrow(new QGraphicsItemGroup(item)),
                   m_shades(new QGraphicsItemGroup(item)),
                   m_labels(new QGraphicsItemGroup(item)),
                   m_title(new QGraphicsSimpleTextItem(item)),
                   m_animation(0),
                   m_labelPadding(5),
-                  m_intervalAxis(intervalAxis)
+                  m_intervalAxis(intervalAxis),
+                  m_titlePadding(3)
             {
                 Q_ASSERT(item);
                 //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);
                 handleVisibleChanged(m_axis->isVisible());
                 connectSlots();
                 setFlag(QGraphicsItem::ItemHasNoContents,true);
             }
             void ChartAxis::connectSlots()
             {
                 QObject::connect(m_axis,SIGNAL(visibleChanged(bool)),this,SLOT(handleVisibleChanged(bool)));
                 QObject::connect(m_axis,SIGNAL(lineVisibleChanged(bool)),this,SLOT(handleArrowVisibleChanged(bool)));
                 QObject::connect(m_axis,SIGNAL(gridVisibleChanged(bool)),this,SLOT(handleGridVisibleChanged(bool)));
                 QObject::connect(m_axis,SIGNAL(labelsVisibleChanged(bool)),this,SLOT(handleLabelsVisibleChanged(bool)));
                 QObject::connect(m_axis,SIGNAL(shadesVisibleChanged(bool)),this,SLOT(handleShadesVisibleChanged(bool)));
                 QObject::connect(m_axis,SIGNAL(labelsAngleChanged(int)),this,SLOT(handleLabelsAngleChanged(int)));
                 QObject::connect(m_axis,SIGNAL(linePenChanged(const QPen&)),this,SLOT(handleArrowPenChanged(const QPen&)));
                 QObject::connect(m_axis,SIGNAL(labelsPenChanged(const QPen&)),this,SLOT(handleLabelsPenChanged(const QPen&)));
                 QObject::connect(m_axis,SIGNAL(labelsBrushChanged(const QBrush&)),this,SLOT(handleLabelsBrushChanged(const QBrush&)));
                 QObject::connect(m_axis,SIGNAL(labelsFontChanged(const QFont&)),this,SLOT(handleLabelsFontChanged(const QFont&)));
                 QObject::connect(m_axis,SIGNAL(gridLinePenChanged(const QPen&)),this,SLOT(handleGridPenChanged(const QPen&)));
                 QObject::connect(m_axis,SIGNAL(shadesPenChanged(const QPen&)),this,SLOT(handleShadesPenChanged(const QPen&)));
                 QObject::connect(m_axis,SIGNAL(shadesBrushChanged(const QBrush&)),this,SLOT(handleShadesBrushChanged(const QBrush&)));
                 QObject::connect(m_axis,SIGNAL(titleTextChanged(const QString&)),this,SLOT(handleTitleTextChanged(const QString&)));
                 QObject::connect(m_axis,SIGNAL(titleFontChanged(const QFont&)),this,SLOT(handleTitleFontChanged(const QFont&)));
                 QObject::connect(m_axis,SIGNAL(titlePenChanged(const QPen&)),this,SLOT(handleTitlePenChanged(const QPen&)));
                 QObject::connect(m_axis,SIGNAL(titleBrushChanged(const QBrush&)),this,SLOT(handleTitleBrushChanged(const QBrush&)));
                 QObject::connect(m_axis,SIGNAL(titleVisibleChanged(bool)),this,SLOT(handleTitleVisibleChanged(bool)));
                 QObject::connect(m_axis->d_ptr.data(),SIGNAL(rangeChanged(qreal,qreal)),this,SLOT(handleRangeChanged(qreal,qreal)));
             }
             ChartAxis::~ChartAxis()
             {
             }
             void ChartAxis::setAnimation(AxisAnimation *animation)
             {
                 m_animation = animation;
             }
             void ChartAxis::setLayout(QVector<qreal> &layout)
             {
                 m_layoutVector = layout;
             }
             void ChartAxis::createItems(int count)
             {
                 if (m_arrow->childItems().size() == 0){
                     QGraphicsLineItem* arrow = new ArrowItem(this, this);
                     arrow->setPen(m_axis->linePen());
                     m_arrow->addToGroup(arrow);
                 }
                 if (m_intervalAxis && m_grid->childItems().size() == 0) {
                     for (int i = 0 ; i < 2 ; i  ++){
                         QGraphicsLineItem* item = new QGraphicsLineItem(this);
                         item->setPen(m_axis->gridLinePen());
                         m_grid->addToGroup(item);
                     }
                 }
                 for (int i = 0; i < count; ++i) {
                     QGraphicsLineItem* arrow = new QGraphicsLineItem(this);
                     arrow->setPen(m_axis->linePen());
                     QGraphicsLineItem* grid = new QGraphicsLineItem(this);
                     grid->setPen(m_axis->gridLinePen());
                     QGraphicsSimpleTextItem* label = new QGraphicsSimpleTextItem(this);
                     label->setFont(m_axis->labelsFont());
                     label->setPen(m_axis->labelsPen());
                     label->setBrush(m_axis->labelsBrush());
                     label->setRotation(m_labelsAngle);
                     m_arrow->addToGroup(arrow);
                     m_grid->addToGroup(grid);
                     m_labels->addToGroup(label);
                     if ((m_grid->childItems().size()) % 2 && m_grid->childItems().size() > 2){
                         QGraphicsRectItem* shades = new QGraphicsRectItem(this);
                         shades->setPen(m_axis->shadesPen());
                         shades->setBrush(m_axis->shadesBrush());
                         m_shades->addToGroup(shades);
                     }
                 }
             }
             void ChartAxis::deleteItems(int count)
             {
                 QList<QGraphicsItem *> lines = m_grid->childItems();
                 QList<QGraphicsItem *> labels = m_labels->childItems();
                 QList<QGraphicsItem *> shades = m_shades->childItems();
                 QList<QGraphicsItem *> axis = m_arrow->childItems();
                 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 ChartAxis::updateLayout(QVector<qreal> &layout)
             {
                 int diff = m_layoutVector.size() - layout.size();
                 if (diff > 0)
                     deleteItems(diff);
                 else if (diff < 0)
                     createItems(-diff);
                 if (m_animation) {
                     switch (presenter()->state()) {
                     case ChartPresenter::ZoomInState:
                         m_animation->setAnimationType(AxisAnimation::ZoomInAnimation);
                         m_animation->setAnimationPoint(presenter()->statePoint());
                         break;
                     case ChartPresenter::ZoomOutState:
                         m_animation->setAnimationType(AxisAnimation::ZoomOutAnimation);
                         m_animation->setAnimationPoint(presenter()->statePoint());
                         break;
                     case ChartPresenter::ScrollUpState:
                     case ChartPresenter::ScrollLeftState:
                         m_animation->setAnimationType(AxisAnimation::MoveBackwordAnimation);
                         break;
                     case ChartPresenter::ScrollDownState:
                     case ChartPresenter::ScrollRightState:
                         m_animation->setAnimationType(AxisAnimation::MoveForwardAnimation);
                         break;
                     case ChartPresenter::ShowState:
                         m_animation->setAnimationType(AxisAnimation::DefaultAnimation);
                         break;
                     }
                     m_animation->setValues(m_layoutVector, layout);
                     presenter()->startAnimation(m_animation);
                 } else {
                     setLayout(layout);
                     updateGeometry();
                 }
             }
             void ChartAxis::setLabelPadding(int padding)
             {
                 m_labelPadding = padding;
             }
+            void ChartAxis::setTitlePadding(int padding)
+            {
+                m_titlePadding = padding;
+            }
             bool ChartAxis::isEmpty()
             {
                 return m_axisRect.isEmpty() || m_gridRect.isEmpty() ||  qFuzzyCompare(min(),max());
             }
             void ChartAxis::setGeometry(const QRectF &axis, const QRectF &grid)
             {
                 m_gridRect = grid;
                 m_axisRect = axis;
                 if (isEmpty())
                     return;
                 QVector<qreal> layout = calculateLayout();
                 updateLayout(layout);
             }
             qreal ChartAxis::min() const
             {
                 return m_axis->d_ptr->min();
             }
             qreal ChartAxis::max() const
             {
                 return m_axis->d_ptr->max();
             }
             QFont ChartAxis::font() const
             {
                 return m_axis->labelsFont();
             }
             QFont ChartAxis::titleFont() const
             {
                 return m_axis->titleFont();
             }
             QString ChartAxis::titleText() const
             {
                 return m_axis->titleText();
             }
             void ChartAxis::axisSelected()
             {
                 emit clicked();
             }
             Qt::Orientation ChartAxis::orientation() const
             {
                 return m_axis->orientation();
             }
             Qt::Alignment ChartAxis::alignment() const
             {
                 return m_axis->alignment();
             }
             void ChartAxis::setLabels(const QStringList &labels)
             {
                 m_labelsList = labels;
             }
             QSizeF ChartAxis::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(which);
                 Q_UNUSED(constraint);
                 return QSizeF();
             }
             //handlers
             void ChartAxis::handleArrowVisibleChanged(bool visible)
             {
                 m_arrow->setVisible(visible);
             }
             void ChartAxis::handleGridVisibleChanged(bool visible)
             {
                 m_grid->setVisible(visible);
             }
             void ChartAxis::handleLabelsVisibleChanged(bool visible)
             {
                 m_labels->setVisible(visible);
             }
             void ChartAxis::handleShadesVisibleChanged(bool visible)
             {
                 m_shades->setVisible(visible);
             }
             void ChartAxis::handleTitleVisibleChanged(bool visible)
             {
                 m_title->setVisible(visible);
                 presenter()->layout()->invalidate();
             }
             void ChartAxis::handleLabelsAngleChanged(int angle)
             {
                 foreach (QGraphicsItem *item, m_labels->childItems())
                     item->setRotation(angle);
                 m_labelsAngle = angle;
             }
             void ChartAxis::handleLabelsPenChanged(const QPen &pen)
             {
                 foreach (QGraphicsItem *item , m_labels->childItems())
                     static_cast<QGraphicsSimpleTextItem *>(item)->setPen(pen);
             }
             void ChartAxis::handleLabelsBrushChanged(const QBrush &brush)
             {
                 foreach (QGraphicsItem *item , m_labels->childItems())
                     static_cast<QGraphicsSimpleTextItem *>(item)->setBrush(brush);
             }
             void ChartAxis::handleLabelsFontChanged(const QFont &font)
             {
                 foreach (QGraphicsItem *item , m_labels->childItems())
                 static_cast<QGraphicsSimpleTextItem *>(item)->setFont(font);
                 QGraphicsLayoutItem::updateGeometry();
                 presenter()->layout()->invalidate();
             }
             void ChartAxis::handleShadesBrushChanged(const QBrush &brush)
             {
                 foreach (QGraphicsItem *item , m_shades->childItems())
                     static_cast<QGraphicsRectItem *>(item)->setBrush(brush);
             }
             void ChartAxis::handleShadesPenChanged(const QPen &pen)
             {
                 foreach (QGraphicsItem *item , m_shades->childItems())
                     static_cast<QGraphicsRectItem *>(item)->setPen(pen);
             }
             void ChartAxis::handleArrowPenChanged(const QPen &pen)
             {
                 foreach (QGraphicsItem *item , m_arrow->childItems())
                     static_cast<QGraphicsLineItem *>(item)->setPen(pen);
             }
             void ChartAxis::handleGridPenChanged(const QPen &pen)
             {
                 foreach (QGraphicsItem *item , m_grid->childItems())
                     static_cast<QGraphicsLineItem *>(item)->setPen(pen);
             }
             void ChartAxis::handleTitleTextChanged(const QString &title)
             {
                 Q_UNUSED(title)
                 QGraphicsLayoutItem::updateGeometry();
                 presenter()->layout()->invalidate();
             }
             void ChartAxis::handleTitlePenChanged(const QPen &pen)
             {
                 m_title->setPen(pen);
             }
             void ChartAxis::handleTitleBrushChanged(const QBrush &brush)
             {
                 m_title->setBrush(brush);
             }
             void ChartAxis::handleTitleFontChanged(const QFont &font)
             {
                 if(m_title->font() != font){
                     m_title->setFont(font);
                     QGraphicsLayoutItem::updateGeometry();
                     presenter()->layout()->invalidate();
                 }
             }
             void ChartAxis::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(m_axis->isGridLineVisible());
                     m_arrow->setVisible(m_axis->isLineVisible());
                     m_shades->setVisible(m_axis->shadesVisible());
                     m_labels->setVisible(m_axis->labelsVisible());
                     m_title->setVisible(m_axis->isTitleVisible());
                 }
                 if(presenter()) presenter()->layout()->invalidate();
             }
             void ChartAxis::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());
                     }
                 }
             }
             //helpers
             QStringList ChartAxis::createValueLabels(qreal min, qreal max, int ticks,const QString& format)
             {
                 //TODO: Q_ASSERT(m_max > m_min);
                 //TODO: Q_ASSERT(ticks > 1);
                 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();
                     for (int i = 0; i < ticks; i++) {
                         qreal value = min + (i * (max - min) / (ticks - 1));
                         if (format.contains("d")
                                 || format.contains("i")
                                 || format.contains("c"))
                             labels << QString().sprintf(array, (qint64)value);
                         else if (format.contains("u")
                                  || format.contains("o")
                                  || format.contains("x", Qt::CaseInsensitive))
                             labels << QString().sprintf(array, (quint64)value);
                         else if (format.contains("f", Qt::CaseInsensitive)
                                   || format.contains("e", Qt::CaseInsensitive)
                                   || format.contains("g", Qt::CaseInsensitive))
                             labels << QString().sprintf(array, value);
                         else
                             labels << QString();
                     }
                 }
                 return labels;
             }
             QStringList ChartAxis::createLogValueLabels(qreal min, qreal max, qreal base, int ticks, const QString& format)
             {
             //    Q_ASSERT(m_max > m_min);
                 //    Q_ASSERT(ticks > 1);
                 QStringList 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();
                     for (int i = firstTick; i < ticks + firstTick; i++) {
                         qreal value = qPow(base, i);
                         if (format.contains("d")
                                 || format.contains("i")
                                 || format.contains("c"))
                             labels << QString().sprintf(array, (qint64)value);
                         else if (format.contains("u")
                                  || format.contains("o")
                                  || format.contains("x", Qt::CaseInsensitive))
                             labels << QString().sprintf(array, (quint64)value);
                         else if (format.contains("f", Qt::CaseInsensitive)
                                   || format.contains("e", Qt::CaseInsensitive)
                                   || format.contains("g", Qt::CaseInsensitive))
                             labels << QString().sprintf(array, value);
                         else
                             labels << QString();
                     }
                 }
                 return labels;
             }
             QStringList ChartAxis::createDateTimeLabels(qreal min, qreal max,int ticks,const QString& format)
             {
                 //TODO: Q_ASSERT(m_max > m_min);
                 //TODO: Q_ASSERT(ticks > 1);
                 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;
             }
             QRect ChartAxis::labelBoundingRect(const QFontMetrics &fn, const QString &label) const
             {
                 QRect boundingRect = fn.boundingRect(label);
                 // Take label rotation into account
                 if (m_labelsAngle) {
                     QTransform transform;
                     transform.rotate(m_labelsAngle);
                     boundingRect = transform.mapRect(boundingRect);
                 }
                 return boundingRect;
             }
             #include "moc_chartaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/chartaxis_p.h +4 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 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 Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial 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 QtCommercial 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 CHARTAXIS_H
             #define CHARTAXIS_H
             #include "qchartglobal.h"
             #include "chartelement_p.h"
             #include "axisanimation_p.h"
             #include <QGraphicsItem>
             #include <QGraphicsLayoutItem>
             #include <QFont>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QAbstractAxis;
             class ChartPresenter;
             class ChartAxis : public ChartElement, public QGraphicsLayoutItem
             {
                 Q_OBJECT
                 Q_INTERFACES(QGraphicsLayoutItem)
             public:
                 ChartAxis(QAbstractAxis *axis, QGraphicsItem* item = 0, bool intervalAxis = false);
                 ~ChartAxis();
                 QAbstractAxis* axis() const { return m_axis; }
                 void setLabelPadding(int padding);
                 int labelPadding() const { return m_labelPadding;};
+                void setTitlePadding(int padding);
+                int titlePadding() const { return m_titlePadding;};
                 QFont titleFont() const;
                 QString titleText() const;
                 void setLayout(QVector<qreal> &layout);
                 QVector<qreal> layout() const { return m_layoutVector; }
                 void setAnimation(AxisAnimation *animation);
                 ChartAnimation *animation() const { return m_animation; };
                 Qt::Orientation orientation() const;
                 Qt::Alignment alignment() const;
                 void setGeometry(const QRectF &axis, const QRectF &grid);
                 QRectF axisGeometry() const { return m_axisRect; }
                 QRectF gridGeometry() const { return m_gridRect; }
                 void setLabels(const QStringList &labels);
                 QStringList labels() const { return m_labelsList; }
                 //this flag indicates that axis is used to show intervals it means labels are in between ticks
                 bool intervalAxis() const { return m_intervalAxis; }
                 virtual QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const;
                 QRectF boundingRect() const{
                     return QRectF();
                 }
                 void paint(QPainter*, const QStyleOptionGraphicsItem*, QWidget*)
                 {
                 }
             //helpers
                 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);
             protected:
                 void setGeometry(const QRectF &size) { Q_UNUSED(size);};
                 virtual void updateGeometry() = 0;
                 virtual QVector<qreal> calculateLayout() const = 0;
                 QList<QGraphicsItem *> lineItems() { 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();};
                 QGraphicsSimpleTextItem* titleItem() const { return m_title.data();}
                 QFont font() const;
                 qreal min() const;
                 qreal max() const;
                 QRect labelBoundingRect(const QFontMetrics &fn, const QString &label) const;
             //handlers
             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);
             	void handleShadesBrushChanged(const QBrush &brush);
             	void handleShadesPenChanged(const QPen &pen);
             	void handleArrowPenChanged(const QPen &pen);
             	void handleGridPenChanged(const QPen &pen);
             	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:
                 inline bool isEmpty();
                 void createItems(int count);
                 void deleteItems(int count);
                 void updateLayout(QVector<qreal> &layout);
                 void axisSelected();
                 void connectSlots();
             private:
                 QAbstractAxis *m_axis;
                 int m_labelsAngle;
                 QRectF m_axisRect;
                 QRectF m_gridRect;
                 QScopedPointer<QGraphicsItemGroup> m_grid;
                 QScopedPointer<QGraphicsItemGroup> m_arrow;
                 QScopedPointer<QGraphicsItemGroup> m_shades;
                 QScopedPointer<QGraphicsItemGroup> m_labels;
                 QScopedPointer<QGraphicsSimpleTextItem> m_title;
                 QVector<qreal> m_layoutVector;
                 AxisAnimation *m_animation;
                 int m_labelPadding;
                 QStringList m_labelsList;
                 bool m_intervalAxis;
+                int m_titlePadding;
                 friend class AxisAnimation;
                 friend class ArrowItem;
             };
             class ArrowItem: public QGraphicsLineItem
             {
             public:
                 explicit ArrowItem(ChartAxis *axis, QGraphicsItem *parent = 0) : QGraphicsLineItem(parent), m_axis(axis) {}
             protected:
                 void mousePressEvent(QGraphicsSceneMouseEvent *event) {
                     Q_UNUSED(event)
                     m_axis->axisSelected();
                 }
                 QRectF boundingRect() const {
                     return shape().boundingRect();
                 }
                 QPainterPath shape() const {
                     QPainterPath path = QGraphicsLineItem::shape();
                     QRectF rect = path.boundingRect();
                     path.addRect(rect.adjusted(0, 0, m_axis->orientation() != Qt::Horizontal ? 8 : 0, m_axis->orientation() != Qt::Vertical ? 8 : 0));
                     return path;
                 }
             private:
                 ChartAxis *m_axis;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* CHARTAXI_H */

src/axis/horizontalaxis.cpp +5 -5

             /****************************************************************************
             **
             ** Copyright (C) 2012 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 Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial 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 "horizontalaxis_p.h"
             #include "qabstractaxis.h"
             #include <QFontMetrics>
             #include <qmath.h>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             HorizontalAxis::HorizontalAxis(QAbstractAxis *axis, QGraphicsItem* item , bool intervalAxis)
                 : ChartAxis(axis, item, intervalAxis)
             {
             }
             HorizontalAxis::~HorizontalAxis()
             {
             }
             void HorizontalAxis::updateGeometry()
             {
                 const QVector<qreal>& layout = ChartAxis::layout();
                 if (layout.isEmpty())
                     return;
                 QStringList labelList = labels();
                 QList<QGraphicsItem *> lines = lineItems();
                 QList<QGraphicsItem *> labels = labelItems();
                 QList<QGraphicsItem *> shades = shadeItems();
                 QList<QGraphicsItem *> axis = arrowItems();
                 QGraphicsSimpleTextItem* title = titleItem();
                 Q_ASSERT(labels.size() == labelList.size());
                 Q_ASSERT(layout.size() == labelList.size());
                 const QRectF &axisRect = axisGeometry();
                 const QRectF &gridRect = gridGeometry();
                 //arrow
                 QGraphicsLineItem *arrowItem = static_cast<QGraphicsLineItem *>(axis.at(0));
                 if (alignment() == Qt::AlignTop)
                     arrowItem->setLine(gridRect.left(), axisRect.bottom(), gridRect.right(), axisRect.bottom());
                 else if (alignment() == Qt::AlignBottom)
                     arrowItem->setLine(gridRect.left(), axisRect.top(), gridRect.right(), axisRect.top());
                 qreal width = 0;
                 QFontMetrics fn(font());
                 //title
                 if (!titleText().isNull()) {
                     QFontMetrics fn(title->font());
                     int size(0);
                     size = gridRect.width();
                     QString titleText = this->titleText();
                     if (fn.boundingRect(titleText).width() > size) {
                         QString string = titleText + "...";
                         while (fn.boundingRect(string).width() > size && string.length() > 3)
                             string.remove(string.length() - 4, 1);
                         title->setText(string);
                     } else {
                         title->setText(titleText);
                     }
                     QPointF center = gridRect.center() - title->boundingRect().center();
                     if (alignment() == Qt::AlignTop) {
-                        title->setPos(center.x(), axisRect.top());
+                        title->setPos(center.x(), axisRect.top() + titlePadding());
                     } else  if (alignment() == Qt::AlignBottom) {
-                        title->setPos(center.x(), axisRect.bottom() - title->boundingRect().height());
+                        title->setPos(center.x(), axisRect.bottom() - title->boundingRect().height() - titlePadding());
                     }
                 }
                 for (int i = 0; i < layout.size(); ++i) {
                     //items
                     QGraphicsLineItem *gridItem = static_cast<QGraphicsLineItem*>(lines.at(i));
                     QGraphicsLineItem *tickItem = static_cast<QGraphicsLineItem*>(axis.at(i + 1));
                     QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem *>(labels.at(i));
                     //grid line
                     gridItem->setLine(layout[i], gridRect.top(), layout[i], gridRect.bottom());
                     //label text wrapping
                     QString text = labelList.at(i);
                     QRectF boundingRect = labelBoundingRect(fn, text);
-                    qreal size = axisRect.bottom() - axisRect.top() - labelPadding() - title->boundingRect().height();
+                    qreal size = axisRect.bottom() - axisRect.top() - labelPadding() - title->boundingRect().height() - (titlePadding() * 2);
                     if (boundingRect.height() > size) {
                         QString label = text + "...";
                         while (boundingRect.height() >= size && label.length() > 3) {
                             label.remove(label.length() - 4, 1);
                             boundingRect = labelBoundingRect(fn, label);
                         }
                         labelItem->setText(label);
                     } else {
                         labelItem->setText(text);
                     }
                     //label transformation origin point
                     const QRectF& rect = labelItem->boundingRect();
                     QPointF center = rect.center();
                     labelItem->setTransformOriginPoint(center.x(), center.y());
                     int heightDiff = rect.height() - boundingRect.height();
                     //ticks and label position
                     if (alignment() == Qt::AlignTop) {
                         labelItem->setPos(layout[i] - center.x(), axisRect.bottom() - rect.height() + (heightDiff / 2) - labelPadding());
                         tickItem->setLine(layout[i], axisRect.bottom(), layout[i], axisRect.bottom() - labelPadding());
                     } else if (alignment() == Qt::AlignBottom) {
                         labelItem->setPos(layout[i] - center.x(), axisRect.top() - (heightDiff / 2) + labelPadding());
                         tickItem->setLine(layout[i], axisRect.top(), layout[i], axisRect.top() + labelPadding());
                     }
                     //label in beetwen
                     if(intervalAxis()&& i+1!=layout.size()) {
                         const qreal delta = (layout[i+1] - layout[i])/2;
                         labelItem->setPos(layout[i] + delta - center.x(), labelItem->pos().y());
                     }
                     //label overlap detection
                     if(labelItem->pos().x() < width ||
                         labelItem->pos().x() < axisRect.left()  ||
                         labelItem->pos().x() + boundingRect.width() -1 > axisRect.right()){
                         labelItem->setVisible(false);
                     } else {
                         labelItem->setVisible(true);
                         width = boundingRect.width() + labelItem->pos().x();
                     }
                     //shades
                     if ((i + 1) % 2 && i > 1) {
                         QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem *>(shades.at(i / 2 - 1));
                         rectItem->setRect(layout[i - 1], gridRect.top(), layout[i] - layout[i - 1], gridRect.height());
                     }
                     // check if the grid line and the axis tick should be shown
                     qreal x = gridItem->line().p1().x();
                     if (x < gridRect.left() || x > gridRect.right()) {
                         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.right(), gridRect.top(), gridRect.right(), gridRect.bottom());
                     gridLine->setVisible(true);
                     gridLine = static_cast<QGraphicsLineItem*>(lines.at(layout.size()+1));
                     gridLine->setLine(gridRect.left(), gridRect.top(), gridRect.left(), gridRect.bottom());
                     gridLine->setVisible(true);
                 }
             }
             QSizeF HorizontalAxis::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(constraint);
                 QFontMetrics fn(titleFont());
                 QSizeF sh(0,0);
                 if (titleText().isNull() || !titleItem()->isVisible())
                     return sh;
                 switch (which) {
                 case Qt::MinimumSize:
-                        sh = QSizeF(fn.boundingRect("...").width(), fn.height());
+                        sh = QSizeF(fn.boundingRect("...").width(), fn.height() + (titlePadding() * 2));
                     break;
                 case Qt::MaximumSize:
                 case Qt::PreferredSize:
-                        sh = QSizeF(fn.boundingRect(axis()->titleText()).width(), fn.height());
+                        sh = QSizeF(fn.boundingRect(axis()->titleText()).width(), fn.height() + (titlePadding() * 2));
                     break;
                 default:
                     break;
                 }
                 return sh;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/verticalaxis.cpp +5 -5

             /****************************************************************************
             **
             ** Copyright (C) 2012 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 Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial 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 <QFontMetrics>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             VerticalAxis::VerticalAxis(QAbstractAxis *axis, QGraphicsItem* item, bool intervalAxis)
                 : ChartAxis(axis, item, intervalAxis)
             {
             }
             VerticalAxis::~VerticalAxis()
             {
             }
             void VerticalAxis::updateGeometry()
             {
                 const QVector<qreal> &layout = ChartAxis::layout();
                 if (layout.isEmpty())
                     return;
                 QStringList labelList = labels();
                 QList<QGraphicsItem *> lines = lineItems();
                 QList<QGraphicsItem *> labels = labelItems();
                 QList<QGraphicsItem *> shades = shadeItems();
                 QList<QGraphicsItem *> axis = arrowItems();
                 QGraphicsSimpleTextItem* 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*>(axis.at(0));
                 //arrow position
                 if (alignment()==Qt::AlignLeft)
                     arrowItem->setLine( axisRect.right() , gridRect.top(), axisRect.right(), gridRect.bottom());
                 else if(alignment()==Qt::AlignRight)
                     arrowItem->setLine( axisRect.left() , gridRect.top(), axisRect.left(), gridRect.bottom());
                 QFontMetrics fn(font());
                 //title
                 if (!titleText().isNull()) {
                     QFontMetrics fn(title->font());
                     int size(0);
                     size = gridRect.height();
                     QString titleText = this->titleText();
                     if (fn.boundingRect(titleText).width() > size) {
                         QString string = titleText + "...";
                         while (fn.boundingRect(string).width() > size && string.length() > 3)
                         string.remove(string.length() - 4, 1);
                         title->setText(string);
                     }
                     else {
                         title->setText(titleText);
                     }
                     QPointF center = gridRect.center() - title->boundingRect().center();
                     if (alignment() == Qt::AlignLeft) {
-                        title->setPos(axisRect.left() - title->boundingRect().width()/2 + title->boundingRect().height()/2 , center.y());
+                        title->setPos(axisRect.left() - title->boundingRect().width() / 2 + title->boundingRect().height() / 2 + titlePadding(), center.y());
                     }
                     else if (alignment() == Qt::AlignRight) {
-                        title->setPos(axisRect.right()- title->boundingRect().width()/2 - title->boundingRect().height()/2, center.y());
+                        title->setPos(axisRect.right() - title->boundingRect().width() / 2 - title->boundingRect().height() / 2 - titlePadding(), center.y());
                     }
                     title->setTransformOriginPoint(title->boundingRect().center());
                     title->setRotation(270);
                 }
                 for (int i = 0; i < layout.size(); ++i) {
                     //items
                     QGraphicsLineItem *gridItem = static_cast<QGraphicsLineItem *>(lines.at(i));
                     QGraphicsLineItem *tickItem = static_cast<QGraphicsLineItem *>(axis.at(i + 1));
                     QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem *>(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 = labelBoundingRect(fn, text);
-                    qreal size = axisRect.right() - axisRect.left() - labelPadding() - title->boundingRect().height();
+                    qreal size = axisRect.right() - axisRect.left() - labelPadding() - title->boundingRect().height() - (titlePadding() * 2);
                     if (boundingRect.width() > size) {
                         QString label = text + "...";
                         while (boundingRect.width() > size && label.length() > 3) {
                             label.remove(label.length() - 4, 1);
                             boundingRect = labelBoundingRect(fn, label);
                         }
                         labelItem->setText(label);
                     } else {
                         labelItem->setText(text);
                     }
                     //label transformation origin point
                     const QRectF &rect = labelItem->boundingRect();
                     QPointF center = rect.center();
                     labelItem->setTransformOriginPoint(center.x(), center.y());
                     int widthDiff = rect.width() - boundingRect.width();
                     //ticks and label position
                     if (alignment() == Qt::AlignLeft) {
                         labelItem->setPos(axisRect.right() - rect.width() + (widthDiff / 2) - labelPadding(), layout[i] - center.y());
                         tickItem->setLine(axisRect.right() - labelPadding(), layout[i], axisRect.right(), layout[i]);
                     } else if (alignment() == Qt::AlignRight) {
                         labelItem->setPos(axisRect.left() + labelPadding() - (widthDiff / 2), layout[i] - center.y());
                         tickItem->setLine(axisRect.left(), layout[i], axisRect.left() + labelPadding(), layout[i]);
                     }
                     //label in beetwen
                     if(intervalAxis()&& i+1!=layout.size()) {
                         const qreal delta = (layout[i+1] - layout[i])/2;
                         labelItem->setPos(labelItem->pos().x() , layout[i] + delta - center.y());
                     }
                     //label overlap detection
                     if(labelItem->pos().y() + boundingRect.height() > height ||
                         labelItem->pos().y() + boundingRect.height()/2 > gridRect.bottom() ||
                         labelItem->pos().y() + boundingRect.height()/2 < gridRect.top()) {
                         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));
                         rectItem->setRect(gridRect.left(), layout[i], gridRect.width(), layout[i - 1] - layout[i]);
                     }
                     // 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);
                 QFontMetrics fn(titleFont());
                 QSizeF sh(0,0);
                 if (titleText().isNull() || !titleItem()->isVisible())
                     return sh;
                 switch (which) {
                 case Qt::MinimumSize:
-                        sh = QSizeF(fn.height(), fn.boundingRect("...").width());
+                        sh = QSizeF(fn.height() + (titlePadding() * 2), fn.boundingRect("...").width());
                     break;
                 case Qt::MaximumSize:
                 case Qt::PreferredSize:
-                        sh = QSizeF(fn.height(), fn.boundingRect(axis()->titleText()).width());
+                        sh = QSizeF(fn.height() + (titlePadding() * 2), fn.boundingRect(axis()->titleText()).width());
                     break;
                 default:
                     break;
                 }
                 return sh;
             }
             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