HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1720:79d9101394e5

Fixes rounding issue with labels numbering

Michal Klocek -

r1720:79d9101394e5

parent child

Context file:

r1720:79d9101394e5

Collapse all files

src/axis/categoriesaxis/chartcategoriesaxisx.cpp +35 -18

             /****************************************************************************
              **
              ** 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 "chartcategoriesaxisx_p.h"
             #include "chartpresenter_p.h"
             #include "qbarcategoriesaxis_p.h"
-            #include <cmath>
+            #include <QDebug>
+            #include <qmath.h>
             static int label_padding = 5;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartCategoriesAxisX::ChartCategoriesAxisX(QBarCategoriesAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter),
             m_categoriesAxis(axis)
             {
             }
             ChartCategoriesAxisX::~ChartCategoriesAxisX()
             {
             }
             QVector<qreal> ChartCategoriesAxisX::calculateLayout() const
             {
                 Q_ASSERT(m_categoriesAxis->categories().count()>=1);
                 QVector<qreal> points;
-                points.resize(m_categoriesAxis->categories().count()+1);
+                points.resize(m_categoriesAxis->categories().count()+2);
                 const qreal delta = m_rect.width()/(m_categoriesAxis->categories().count());
-                const qreal min = m_categoriesAxis->d_ptr->min();
+                qreal offset =-m_min-0.5;
-                const qreal max = m_categoriesAxis->d_ptr->max();
-                qreal start =-min-0.5;
+                if(offset<=0) {
-                if(start<=0) {
+                    offset = int(offset * m_rect.width()/(m_max - m_min))%int(delta) + delta;
-                    start = fmod(start * m_rect.width()/(max - min),delta) + delta;
                 }
                 else {
-                    start = fmod(start * m_rect.width()/(max - min),delta);
+                    offset = int(offset * m_rect.width()/(m_max - m_min))%int(delta);
                 }
-                points[m_categoriesAxis->categories().count()] = m_rect.left() + m_rect.width();
+                points[0] = m_rect.left();
+                points[m_categoriesAxis->categories().count()+1] = m_rect.right();
                 for (int i = 0; i < m_categoriesAxis->categories().count(); ++i) {
-                    qreal x = start + i * delta + m_rect.left();
+                    qreal x = offset + i * delta + m_rect.left();
-                    points[i] = x;
+                    points[i+1] = x;
                 }
                 return points;
             }
+            QStringList ChartCategoriesAxisX::createCategoryLabels(const QVector<qreal>& layout) const
+            {
+                QStringList result;
+                qreal d = (m_max - m_min)/m_rect.width();
+                for (int i = 0;i < layout.count()-1; ++i) {
+                    qreal x = qFloor((((layout[i+1] + layout[i])/2-m_rect.left())*d + m_min+0.5));
+                    if ((x < m_categoriesAxis->categories().count()) && (x >= 0)) {
+                        result << m_categoriesAxis->categories().at(x);
+                    }
+                    else {
+                        // No label for x coordinate
+                        result << "";
+                    }
+                }
+                result << "";
+                return result;
+            }
             void ChartCategoriesAxisX::updateGeometry()
             {
                 const QVector<qreal>& layout = ChartAxis::layout();
                 m_minWidth = 0;
                 m_minHeight = 0;
                 if(layout.isEmpty()) return;
-                QStringList ticksList;
+                QStringList ticksList = createCategoryLabels(layout);
-                createCategoryLabels(ticksList,m_min,m_max,m_categoriesAxis->categories());
                 QList<QGraphicsItem *> lines = m_grid->childItems();
                 QList<QGraphicsItem *> labels = m_labels->childItems();
                 QList<QGraphicsItem *> shades = m_shades->childItems();
                 QList<QGraphicsItem *> axis = m_axis->childItems();
                 Q_ASSERT(labels.size() == ticksList.size());
                 Q_ASSERT(layout.size() == ticksList.size());
                 const qreal delta = m_rect.width()/(m_categoriesAxis->categories().count());
                 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
                 lineItem->setLine(m_rect.left(), m_rect.bottom(), m_rect.right(), m_rect.bottom());
                 qreal width = m_rect.left();
                 for (int i = 0; i < layout.size(); ++i) {
                     QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
                     lineItem->setLine(layout[i], m_rect.top(), layout[i], m_rect.bottom());
                     QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
                     labelItem->setText(ticksList.at(i));
                     const QRectF& rect = labelItem->boundingRect();
                     QPointF center = rect.center();
                     labelItem->setTransformOriginPoint(center.x(), center.y());
-                    if(i==layout.size()-1){
+                    if(i==0){
-                        labelItem->setPos(layout[i-1] + (delta)/2 - center.x(), m_rect.bottom() + label_padding);
+                        labelItem->setPos(layout[i+1] - (delta)/2 - center.x(), m_rect.bottom() + label_padding);
                     }else{
-                        labelItem->setPos(layout[i] - (delta)/2 - center.x(), m_rect.bottom() + label_padding);
+                        labelItem->setPos(layout[i] + (delta)/2 - center.x(), m_rect.bottom() + label_padding);
                     }
                     if(labelItem->pos().x()<=width || labelItem->pos().x()+ rect.width()>m_rect.right()) {
                         labelItem->setVisible(false);
                     }
                     else {
                         labelItem->setVisible(true);
                         width=rect.width()+labelItem->pos().x();
                     }
                     m_minWidth+=rect.width();
                     m_minHeight=qMax(rect.height()+label_padding,m_minHeight);
                     if ((i+1)%2 && i>1) {
                         QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2-1));
                         rectItem->setRect(layout[i-1],m_rect.top(),layout[i]-layout[i-1],m_rect.height());
                     }
                     lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
                     lineItem->setLine(layout[i],m_rect.bottom(),layout[i],m_rect.bottom()+5);
                 }
             }
             void ChartCategoriesAxisX::handleAxisUpdated()
             {
                 if(m_categoriesAxis->categories()!=m_categories)
                 {
                     m_categories=m_categoriesAxis->categories();
                     if(ChartAxis::layout().count()==m_categories.size()+1) updateGeometry();
                 }
                 ChartAxis::handleAxisUpdated();
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/categoriesaxis/chartcategoriesaxisx_p.h +2 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 CHARTCATEGORIESAXISX_H
             #define CHARTCATEGORIESAXISX_H
             #include "chartaxis_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QAbstractAxis;
             class ChartPresenter;
             class QBarCategoriesAxis;
             class ChartCategoriesAxisX : public ChartAxis
             {
             public:
                 ChartCategoriesAxisX(QBarCategoriesAxis *axis, ChartPresenter *presenter);
                 ~ChartCategoriesAxisX();
                 AxisType axisType() const { return X_AXIS;}
             protected:
                 QVector<qreal> calculateLayout() const;
                 void updateGeometry();
+            private:
+                QStringList createCategoryLabels(const QVector<qreal>& layout) const;
             Q_SLOTS
                 void handleAxisUpdated();
             private:
                 QStringList m_categories;
                 QBarCategoriesAxis *m_categoriesAxis;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* CHARTCATEGORIESAXISX_H */

src/axis/categoriesaxis/chartcategoriesaxisy.cpp +37 -23

             /****************************************************************************
              **
              ** 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 "chartcategoriesaxisy_p.h"
             #include "chartpresenter_p.h"
             #include "qbarcategoriesaxis_p.h"
-            #include <QDebug>
+            #include <qmath.h>
-            #include <cmath>
             static int label_padding = 5;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartCategoriesAxisY::ChartCategoriesAxisY(QBarCategoriesAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter),
             m_categoriesAxis(axis)
             {
             }
             ChartCategoriesAxisY::~ChartCategoriesAxisY()
             {
             }
             QVector<qreal> ChartCategoriesAxisY::calculateLayout() const
             {
                 Q_ASSERT(m_categoriesAxis->categories().count()>=1);
                 QVector<qreal> points;
-                points.resize(m_categoriesAxis->categories().count()+1);
+                points.resize(m_categoriesAxis->categories().count()+2);
-                qreal delta = m_rect.height()/(m_categoriesAxis->categories().count());
+                const qreal delta = m_rect.height()/(m_categoriesAxis->categories().count());
+                qreal offset = - m_min - 0.5;
-                const qreal min = m_categoriesAxis->d_ptr->min();
-                const qreal max = m_categoriesAxis->d_ptr->max();
-                qreal start =-min-0.5;
-                if(start<=0) {
+                if(offset<=0) {
-                    start = fmod(start * m_rect.height()/(max - min),delta) + delta;
+                    offset = int(offset * m_rect.height()/(m_max - m_min))%int(delta) + delta;
                 }
                 else {
-                    start = fmod(start * m_rect.height()/(max - min),delta);
+                    offset = int(offset * m_rect.height()/(m_max - m_min))%int(delta);
                 }
-                points[m_categoriesAxis->categories().count()] = m_rect.top();
+                points[0] = m_rect.bottom();
+                points[m_categoriesAxis->categories().count()+1] = m_rect.top();
                 for (int i = 0; i < m_categoriesAxis->categories().count(); ++i) {
-                    int y = m_rect.bottom() - i * delta - start;
+                    int y = m_rect.bottom() - i * delta - offset;
-                    points[i] = y;
+                    points[i+1] = y;
                 }
                 return points;
             }
+            QStringList ChartCategoriesAxisY::createCategoryLabels(const QVector<qreal>& layout) const
+            {
+                QStringList result;
+                qreal d = (m_max - m_min)/m_rect.height();
+                for (int i = 0;i < layout.count()-1; ++i) {
+                    qreal x = qFloor(((m_rect.height()- (layout[i+1] + layout[i])/2 + m_rect.top())*d + m_min+0.5));
+                    if ((x < m_categoriesAxis->categories().count()) && (x >= 0)) {
+                        result << m_categoriesAxis->categories().at(x);
+                    }
+                    else {
+                        // No label for x coordinate
+                        result << "";
+                    }
+                }
+                result << "";
+                return result;
+            }
             void ChartCategoriesAxisY::updateGeometry()
             {
                 const QVector<qreal>& layout = ChartAxis::layout();
                 m_minWidth = 0;
                 m_minHeight = 0;
                 if(layout.isEmpty()) return;
-                QStringList ticksList;
+                QStringList ticksList = createCategoryLabels(layout);
-                createCategoryLabels(ticksList,m_min,m_max,m_categoriesAxis->categories());
                 QList<QGraphicsItem *> lines = m_grid->childItems();
                 QList<QGraphicsItem *> labels = m_labels->childItems();
                 QList<QGraphicsItem *> shades = m_shades->childItems();
                 QList<QGraphicsItem *> axis = m_axis->childItems();
                 Q_ASSERT(labels.size() == ticksList.size());
                 Q_ASSERT(layout.size() == ticksList.size());
                 const qreal delta = m_rect.height()/(m_categoriesAxis->categories().count());
                 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
                 lineItem->setLine(m_rect.left() , m_rect.top(), m_rect.left(), m_rect.bottom());
                 qreal height = m_rect.bottom();
                 for (int i = 0; i < layout.size(); ++i) {
                     QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
                     lineItem->setLine(m_rect.left() , layout[i], m_rect.right(), layout[i]);
                     QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
                     labelItem->setText(ticksList.at(i));
                     const QRectF& rect = labelItem->boundingRect();
                     QPointF center = rect.center();
                     labelItem->setTransformOriginPoint(center.x(), center.y());
-                    if(i==layout.size()-1) {
+                    if(i==0) {
-                        labelItem->setPos(m_rect.left() - rect.width() - label_padding ,layout[i-1] - (delta)/2 - center.y());
+                       labelItem->setPos(m_rect.left() - rect.width() - label_padding ,layout[i+1] + (delta)/2 - center.y());
                     }
                     else {
-                        labelItem->setPos(m_rect.left() - rect.width() - label_padding ,layout[i] + (delta)/2 - center.y());
+                        labelItem->setPos(m_rect.left() - rect.width() - label_padding ,layout[i] - (delta)/2 - center.y());
                     }
                     if(labelItem->pos().y()+rect.height()>= height || labelItem->pos().y() < m_rect.top()) {
                         labelItem->setVisible(false);
                     }
                     else {
                         labelItem->setVisible(true);
                         height=labelItem->pos().y();
                     }
                     m_minWidth+=rect.width();
                     m_minHeight=qMax(rect.height()+label_padding,m_minHeight);
                     if ((i+1)%2 && i>1) {
                         QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2-1));
                         rectItem->setRect(m_rect.left(),layout[i],m_rect.width(),layout[i-1]-layout[i]);
                     }
                     lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
                     lineItem->setLine(m_rect.left()-5,layout[i],m_rect.left(),layout[i]);
                 }
             }
             void ChartCategoriesAxisY::handleAxisUpdated()
             {
                 if(m_categoriesAxis->categories()!=m_categories)
                 {
                     m_categories=m_categoriesAxis->categories();
-                    if(ChartAxis::layout().count()==m_categories.size()+1) updateGeometry();
+                    if(ChartAxis::layout().count()==m_categories.size()+1) {
+                        updateGeometry();
+                    }
                 }
                 ChartAxis::handleAxisUpdated();
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/categoriesaxis/chartcategoriesaxisy_p.h +3 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 CHARTCATEGORIESAXISY_H
             #define CHARTCATEGORIESAXISY_H
             #include "chartaxis_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QAbstractAxis;
             class QBarCategoriesAxis;
             class ChartPresenter;
             class ChartCategoriesAxisY : public ChartAxis
             {
             public:
                 ChartCategoriesAxisY(QBarCategoriesAxis *axis, ChartPresenter *presenter);
                 ~ChartCategoriesAxisY();
                 AxisType axisType() const { return Y_AXIS;}
             protected:
                 QVector<qreal> calculateLayout() const;
                 void updateGeometry();
+            private:
+                QStringList createCategoryLabels(const QVector<qreal>& layout) const;
             Q_SLOTS
                     void handleAxisUpdated();
             private:
                 QStringList m_categories;
+                QVector<int> m_labelIndex;
                 QBarCategoriesAxis *m_categoriesAxis;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* CHARTCATEGORIESAXISY_H */

src/axis/chartaxis.cpp +1 -24

             /****************************************************************************
             **
             ** 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 "chartanimator_p.h"
             #include "domain_p.h"
-            #include <QPainter>
-            #include <QDebug>
             #include <qmath.h>
             #include <QDateTime>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartAxis::ChartAxis(QAbstractAxis *axis,ChartPresenter *presenter) : Chart(presenter),
                 m_chartAxis(axis),
                 m_labelsAngle(0),
                 m_grid(new QGraphicsItemGroup(presenter->rootItem())),
                 m_shades(new QGraphicsItemGroup(presenter->rootItem())),
                 m_labels(new QGraphicsItemGroup(presenter->rootItem())),
                 m_axis(new QGraphicsItemGroup(presenter->rootItem())),
                 m_min(0),
                 m_max(0),
                 m_animation(0),
                 m_minWidth(0),
                 m_minHeight(0)
             {
                 //initial initialization
                 m_axis->setZValue(ChartPresenter::AxisZValue);
                 m_axis->setHandlesChildEvents(false);
                 m_shades->setZValue(ChartPresenter::ShadesZValue);
                 m_grid->setZValue(ChartPresenter::GridZValue);
                 QObject::connect(m_chartAxis->d_ptr.data(),SIGNAL(updated()),this,SLOT(handleAxisUpdated()));
                 QGraphicsSimpleTextItem item;
                 m_font = item.font();
             }
             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_axis->children().size() == 0)
                 m_axis->addToGroup(new AxisItem(this));
                 for (int i = 0; i < count; ++i) {
                     m_grid->addToGroup(new QGraphicsLineItem());
                     m_labels->addToGroup(new QGraphicsSimpleTextItem());
                     m_axis->addToGroup(new QGraphicsLineItem());
                     if ((m_grid->childItems().size())%2 && m_grid->childItems().size()>2) m_shades->addToGroup(new QGraphicsRectItem());
                 }
             }
             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_axis->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(diff<0) handleAxisUpdated();
                 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::setAxisOpacity(qreal opacity)
             {
                 m_axis->setOpacity(opacity);
             }
             qreal ChartAxis::axisOpacity() const
             {
                 return m_axis->opacity();
             }
             void ChartAxis::setGridOpacity(qreal opacity)
             {
                 m_grid->setOpacity(opacity);
             }
             qreal ChartAxis::gridOpacity() const
             {
                 return m_grid->opacity();
             }
             void ChartAxis::setLabelsOpacity(qreal opacity)
             {
                 m_labels->setOpacity(opacity);
             }
             qreal ChartAxis::labelsOpacity() const
             {
                 return m_labels->opacity();
             }
             void ChartAxis::setShadesOpacity(qreal opacity)
             {
                 m_shades->setOpacity(opacity);
             }
             qreal ChartAxis::shadesOpacity() const
             {
                 return m_shades->opacity();
             }
             void ChartAxis::setLabelsAngle(int angle)
             {
                 foreach(QGraphicsItem* item , m_labels->childItems()) {
                       item->setRotation(angle);
                 }
                 m_labelsAngle=angle;
             }
             void ChartAxis::setLabelsPen(const QPen &pen)
             {
                 foreach(QGraphicsItem* item , m_labels->childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setPen(pen);
                 }
             }
             void ChartAxis::setLabelsBrush(const QBrush &brush)
             {
                 foreach(QGraphicsItem* item , m_labels->childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setBrush(brush);
                 }
             }
             void ChartAxis::setLabelsFont(const QFont &font)
             {
                 foreach(QGraphicsItem* item , m_labels->childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setFont(font);
                 }
                 m_font = font;
             }
             void ChartAxis::setShadesBrush(const QBrush &brush)
             {
                 foreach(QGraphicsItem* item , m_shades->childItems()) {
                     static_cast<QGraphicsRectItem*>(item)->setBrush(brush);
                 }
             }
             void ChartAxis::setShadesPen(const QPen &pen)
             {
                 foreach(QGraphicsItem* item , m_shades->childItems()) {
                     static_cast<QGraphicsRectItem*>(item)->setPen(pen);
                 }
             }
             void ChartAxis::setAxisPen(const QPen &pen)
             {
                 foreach(QGraphicsItem* item , m_axis->childItems()) {
                        static_cast<QGraphicsLineItem*>(item)->setPen(pen);
                 }
             }
             void ChartAxis::setGridPen(const QPen &pen)
             {
                 foreach(QGraphicsItem* item , m_grid->childItems()) {
                     static_cast<QGraphicsLineItem*>(item)->setPen(pen);
                 }
             }
             bool ChartAxis::isEmpty()
             {
                 return m_rect.isEmpty() || qFuzzyIsNull(m_min - m_max);
             }
             void ChartAxis::handleDomainUpdated()
             {
                 Domain* domain = qobject_cast<Domain*>(sender());
                 qreal min(0);
                 qreal max(0);
                 if(m_chartAxis->orientation()==Qt::Horizontal) {
                     min = domain->minX();
                     max = domain->maxX();
                 }
                 else if (m_chartAxis->orientation()==Qt::Vertical)
                 {
                     min = domain->minY();
                     max = domain->maxY();
                 }
                 if (!qFuzzyIsNull(m_min - min) || !qFuzzyIsNull(m_max - max))
                 {
                     m_min = min;
                     m_max = max;
                     if (!isEmpty()) {
                         QVector<qreal> layout = calculateLayout();
                         updateLayout(layout);
                     }
                 }
             }
             void ChartAxis::handleAxisUpdated()
             {
                 if(isEmpty()) return;
                 if (!m_chartAxis->isVisible()) {
                     setAxisOpacity(0);
                     setGridOpacity(0);
                     setLabelsOpacity(0);
                     setShadesOpacity(0);
                 }
                 else {
                     if (m_chartAxis->isArrowVisible()) {
                         setAxisOpacity(100);
                     }
                     else {
                         setAxisOpacity(0);
                     }
                     if (m_chartAxis->isGridLineVisible()) {
                         setGridOpacity(100);
                     }
                     else {
                         setGridOpacity(0);
                     }
                     if (m_chartAxis->labelsVisible()) {
                         setLabelsOpacity(100);
                     }
                     else {
                         setLabelsOpacity(0);
                     }
                     if (m_chartAxis->shadesVisible()) {
                         setShadesOpacity(100);
                     }
                     else {
                         setShadesOpacity(0);
                     }
                 }
                 setLabelsAngle(m_chartAxis->labelsAngle());
                 setAxisPen(m_chartAxis->axisPen());
                 setLabelsPen(m_chartAxis->labelsPen());
                 setLabelsBrush(m_chartAxis->labelsBrush());
                 setLabelsFont(m_chartAxis->labelsFont());
                 setGridPen(m_chartAxis->gridLinePen());
                 setShadesPen(m_chartAxis->shadesPen());
                 setShadesBrush(m_chartAxis->shadesBrush());
             }
             void ChartAxis::handleGeometryChanged(const QRectF &rect)
             {
                 if(m_rect != rect)
                 {
                     m_rect = rect;
                     if (isEmpty()) return;
                     QVector<qreal> layout = calculateLayout();
                     updateLayout(layout);
                 }
             }
             qreal ChartAxis::minimumWidth()
             {
                 if(m_minWidth == 0) updateGeometry();
                 return m_minWidth;
             }
             qreal ChartAxis::minimumHeight()
             {
                 if(m_minHeight == 0) updateGeometry();
                 return m_minHeight;
             }
             void ChartAxis::axisSelected()
             {
                 qDebug()<<"TODO: axis clicked";
             }
             void ChartAxis::createNumberLabels(QStringList &labels,qreal min, qreal max, int ticks) const
             {
                 Q_ASSERT(max>min);
                 Q_ASSERT(ticks>1);
-                int n = qMax(int(-floor(log10((max-min)/(ticks-1)))),0);
+                int n = qMax(int(-qFloor(log10((max-min)/(ticks-1)))),0);
                 n++;
                 for (int i=0; i< ticks; i++) {
                     qreal value = min + (i * (max - min)/ (ticks-1));
                     labels << QString::number(value,'f',n);
                 }
             }
-            void ChartAxis::createCategoryLabels(QStringList &labels,qreal min, qreal max,const QStringList &categories) const
-                Q_ASSERT(max>min);
-                Q_UNUSED(max);
-                int x = qFloor(min+0.5);
-                int count = 0;
-                // Try to find category for x coordinate
-                while (count < categories.count()+1) {
-                    if ((x < categories.count()) && (x >= 0)) {
-                        labels << categories.at(x);
-                    } else {
-                        // No label for x coordinate
-                        labels << "";
-                    x++;
-                    count++;
             #include "moc_chartaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/chartaxis_p.h 0 -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$
             **
             ****************************************************************************/
             //  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 "chart_p.h"
             #include "axisanimation_p.h"
             #include <QGraphicsItem>
             #include <QFont>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QAbstractAxis;
             class ChartPresenter;
             class ChartAxis : public Chart
             {
                 Q_OBJECT
             public:
                 enum AxisType{ X_AXIS,Y_AXIS };
                 ChartAxis(QAbstractAxis *axis, ChartPresenter *presenter);
                 ~ChartAxis();
                 virtual AxisType axisType() const = 0;
                 void setAxisOpacity(qreal opacity);
                 qreal axisOpacity() const;
                 void setGridOpacity(qreal opacity);
                 qreal gridOpacity() const;
                 void setLabelsOpacity(qreal opacity);
                 qreal labelsOpacity() const;
                 void setShadesOpacity(qreal opacity);
                 qreal shadesOpacity() const;
                 void setLabelsAngle(int angle);
                 int labelsAngle()const { return m_labelsAngle; }
                 void setShadesBrush(const QBrush &brush);
                 void setShadesPen(const QPen &pen);
                 void setAxisPen(const QPen &pen);
                 void setGridPen(const QPen &pen);
                 void setLabelsPen(const QPen &pen);
                 void setLabelsBrush(const QBrush &brush);
                 void setLabelsFont(const QFont &font);
                 void setLayout(QVector<qreal> &layout);
                 QVector<qreal> layout() const { return m_layoutVector; }
                 void setAnimation(AxisAnimation* animation);
                 ChartAnimation* animation() const { return m_animation; };
                 QRectF geometry() const { return m_rect; }
                 qreal minimumWidth();
                 qreal minimumHeight();
             protected:
                 virtual void updateGeometry() = 0;
                 virtual QVector<qreal> calculateLayout() const = 0;
                 void createNumberLabels(QStringList &labels,qreal min, qreal max,int ticks) const;
-                void createCategoryLabels(QStringList &labels,qreal min, qreal max,const QStringList &categories) const;
             public Q_SLOTS:
                 virtual void handleAxisUpdated();
                 virtual void handleDomainUpdated();
                 void handleGeometryChanged(const QRectF &size);
             private:
                 inline bool isEmpty();
                 void createItems(int count);
                 void deleteItems(int count);
                 void updateLayout(QVector<qreal> &layout);
                 void axisSelected();
             protected:
                 QAbstractAxis* m_chartAxis;
                 QRectF m_rect;
                 int m_labelsAngle;
                 QScopedPointer<QGraphicsItemGroup> m_grid;
                 QScopedPointer<QGraphicsItemGroup> m_shades;
                 QScopedPointer<QGraphicsItemGroup> m_labels;
                 QScopedPointer<QGraphicsItemGroup> m_axis;
                 QVector<qreal> m_layoutVector;
                 qreal m_min;
                 qreal m_max;
                 AxisAnimation *m_animation;
                 qreal m_minWidth;
                 qreal m_minHeight;
                 QFont m_font;
                 friend class AxisAnimation;
                 friend class AxisItem;
             };
             class AxisItem: public QGraphicsLineItem
             {
             public:
                 explicit AxisItem(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->axisType()!=ChartAxis::X_AXIS?8:0,m_axis->axisType()!=ChartAxis::Y_AXIS?8:0));
                    return path;
                }
             private:
                ChartAxis* m_axis;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* AXISITEM_H_ */

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