HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1561:8267a30e4282

Removed generic chartaxis

Marek Rosa -

r1561:8267a30e4282

parent child

Context file:

r1561:8267a30e4282

Collapse all files

src/axis/axis.pri +4 -4

             INCLUDEPATH += $$PWD
             DEPENDPATH += $$PWD
             SOURCES += \
                 $$PWD/chartaxis.cpp \
-                $$PWD/chartaxisx.cpp \
+            #    $$PWD/chartaxisx.cpp \
-                $$PWD/chartaxisy.cpp \
+            #    $$PWD/chartaxisy.cpp \
                 $$PWD/chartvaluesaxisx.cpp \
                 $$PWD/chartvaluesaxisy.cpp \
                 $$PWD/chartcategoriesaxisx.cpp \
                 $$PWD/chartcategoriesaxisy.cpp \
                 $$PWD/qcategoriesaxis.cpp \
                 $$PWD/qvaluesaxis.cpp \
                 $$PWD/qabstractaxis.cpp
             PRIVATE_HEADERS += \
                 $$PWD/chartaxis_p.h \
-                $$PWD/chartaxisx_p.h \
+            #    $$PWD/chartaxisx_p.h \
-                $$PWD/chartaxisy_p.h \
+            #    $$PWD/chartaxisy_p.h \
                 $$PWD/chartvaluesaxisx_p.h \
                 $$PWD/chartvaluesaxisy_p.h \
                 $$PWD/chartcategoriesaxisx_p.h \
                 $$PWD/chartcategoriesaxisy_p.h \
                 $$PWD/qcategoriesaxis_p.h \
                 $$PWD/qvaluesaxis_p.h \
                 $$PWD/qabstractaxis_p.h
             PUBLIC_HEADERS += \
                 $$PWD/qcategoriesaxis.h \
                 $$PWD/qvaluesaxis.h \
                 $$PWD/qabstractaxis.h

src/axis/chartcategoriesaxisy.cpp +4 -3

             /****************************************************************************
             **
             ** 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 "qabstractaxis.h"
             #include "chartpresenter_p.h"
             #include "chartanimator_p.h"
             #include <QGraphicsLayout>
             #include <QDebug>
             #include <QFontMetrics>
             static int label_padding = 5;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartCategoriesAxisY::ChartCategoriesAxisY(QAbstractAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter)
             {
             }
             ChartCategoriesAxisY::~ChartCategoriesAxisY()
             {
             }
             QVector<qreal> ChartCategoriesAxisY::calculateLayout() const
             {
                 Q_ASSERT(m_ticksCount>=2);
                 QVector<qreal> points;
                 points.resize(m_ticksCount);
-                const qreal deltaX = m_rect.width()/(m_ticksCount-1);
+                const qreal deltaY = m_rect.height()/(m_ticksCount-1);
                 for (int i = 0; i < m_ticksCount; ++i) {
-                    int x = i * deltaX + m_rect.left();
+                    int y = i * -deltaY + m_rect.bottom();
-                    points[i] = x;
+                    points[i] = y;
                 }
                 return points;
             }
             void ChartCategoriesAxisY::updateGeometry()
             {
                 const QVector<qreal>& layout = ChartAxis::layout();
                 m_minWidth = 0;
                 m_minHeight = 0;
                 if(layout.isEmpty()) return;
                 QStringList ticksList;
                 bool categories = createLabels(ticksList,m_min,m_max,layout.size());
                 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());
                 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
                 lineItem->setLine(m_rect.left(), m_rect.bottom(), m_rect.right(), m_rect.bottom());
                 qreal width = 0;
                 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));
                     if (!categories || i<1) {
                         labelItem->setText(ticksList.at(i));
                         const QRectF& rect = labelItem->boundingRect();
                         QPointF center = rect.center();
                         labelItem->setTransformOriginPoint(center.x(), center.y());
                         labelItem->setPos(layout[i] - center.x(), m_rect.bottom() + label_padding);
                         if(labelItem->pos().x()<=width){
                             labelItem->setVisible(false);
                             lineItem->setVisible(false);
                         }else{
                             labelItem->setVisible(true);
                             lineItem->setVisible(true);
                             width=rect.width()+labelItem->pos().x();
                         }
                         m_minWidth+=rect.width();
                         m_minHeight=qMax(rect.height(),m_minHeight);
                     }
                     else {
                         labelItem->setText(ticksList.at(i));
                         const QRectF& rect = labelItem->boundingRect();
                         QPointF center = rect.center();
                         labelItem->setTransformOriginPoint(center.x(), center.y());
                         labelItem->setPos(layout[i] - (layout[i] - layout[i-1])/2 - center.x(), m_rect.bottom() + label_padding);
                         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);
                 }
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/chartvaluesaxisx.cpp +20 -10

             /****************************************************************************
             **
             ** 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 "chartvaluesaxisx_p.h"
             #include "qabstractaxis.h"
             #include "chartpresenter_p.h"
             #include "chartanimator_p.h"
             #include <QGraphicsLayout>
             #include <QDebug>
             #include <QFontMetrics>
+            #include <cmath>
             static int label_padding = 5;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartValuesAxisX::ChartValuesAxisX(QAbstractAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter)
             {
             }
             ChartValuesAxisX::~ChartValuesAxisX()
             {
             }
             QVector<qreal> ChartValuesAxisX::calculateLayout() const
             {
                 Q_ASSERT(m_ticksCount>=2);
                 QVector<qreal> points;
                 points.resize(m_ticksCount);
                 const qreal deltaX = m_rect.width()/(m_ticksCount-1);
                 for (int i = 0; i < m_ticksCount; ++i) {
                     int x = i * deltaX + m_rect.left();
                     points[i] = x;
                 }
                 return points;
             }
             void ChartValuesAxisX::updateGeometry()
             {
                 const QVector<qreal>& layout = ChartAxis::layout();
                 m_minWidth = 0;
                 m_minHeight = 0;
                 if(layout.isEmpty()) return;
                 QStringList ticksList;
-                bool categories = createLabels(ticksList,m_min,m_max,layout.size());
+                int ticks = layout.size();
+                int n = qMax(int(-floor(log10((m_max-m_min)/(ticks-1)))),0);
+                n++;
+                for (int i=0; i< ticks; i++) {
+                    qreal value = m_min + (i * (m_max - m_min)/ (ticks-1));
+                    Q_UNUSED(value);
+                    ticksList << QString::number(value,'f',n);
+                }
+                bool categories = false; //createLabels(ticksList,m_min,m_max,layout.size());
                 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());
                 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
                 lineItem->setLine(m_rect.left(), m_rect.bottom(), m_rect.right(), m_rect.bottom());
                 qreal width = 0;
                 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));
                     if (!categories || i<1) {
                         labelItem->setText(ticksList.at(i));
                         const QRectF& rect = labelItem->boundingRect();
                         QPointF center = rect.center();
                         labelItem->setTransformOriginPoint(center.x(), center.y());
                         labelItem->setPos(layout[i] - center.x(), m_rect.bottom() + label_padding);
                         if(labelItem->pos().x()<=width){
                             labelItem->setVisible(false);
                             lineItem->setVisible(false);
                         }else{
                             labelItem->setVisible(true);
                             lineItem->setVisible(true);
                             width=rect.width()+labelItem->pos().x();
                         }
                         m_minWidth+=rect.width();
                         m_minHeight=qMax(rect.height(),m_minHeight);
                     }
-                    else {
+            //        else {
-                        labelItem->setText(ticksList.at(i));
+            //            labelItem->setText(ticksList.at(i));
-                        const QRectF& rect = labelItem->boundingRect();
+            //            const QRectF& rect = labelItem->boundingRect();
-                        QPointF center = rect.center();
+            //            QPointF center = rect.center();
-                        labelItem->setTransformOriginPoint(center.x(), center.y());
+            //            labelItem->setTransformOriginPoint(center.x(), center.y());
-                        labelItem->setPos(layout[i] - (layout[i] - layout[i-1])/2 - center.x(), m_rect.bottom() + label_padding);
+            //            labelItem->setPos(layout[i] - (layout[i] - layout[i-1])/2 - center.x(), m_rect.bottom() + label_padding);
-                        m_minWidth+=rect.width();
+            //            m_minWidth+=rect.width();
-                        m_minHeight=qMax(rect.height()+label_padding,m_minHeight);
+            //            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);
                 }
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/chartvaluesaxisy.cpp +37 -20

             /****************************************************************************
             **
             ** 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 "chartvaluesaxisy_p.h"
             #include "qabstractaxis.h"
             #include "chartpresenter_p.h"
             #include "chartanimator_p.h"
             #include <QGraphicsLayout>
             #include <QDebug>
             #include <QFontMetrics>
+            #include <cmath>
             static int label_padding = 5;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartValuesAxisY::ChartValuesAxisY(QAbstractAxis *axis,ChartPresenter *presenter) : ChartAxis(axis,presenter)
             {
             }
             ChartValuesAxisY::~ChartValuesAxisY()
             {
             }
             QVector<qreal> ChartValuesAxisY::calculateLayout() const
             {
                 Q_ASSERT(m_ticksCount>=2);
                 QVector<qreal> points;
                 points.resize(m_ticksCount);
-                const qreal deltaX = m_rect.width()/(m_ticksCount-1);
+                const qreal deltaY = m_rect.height()/(m_ticksCount-1);
                 for (int i = 0; i < m_ticksCount; ++i) {
-                    int x = i * deltaX + m_rect.left();
+                    int y = i * -deltaY + m_rect.bottom();
-                    points[i] = x;
+                    points[i] = y;
                 }
                 return points;
             }
             void ChartValuesAxisY::updateGeometry()
             {
-                const QVector<qreal>& layout = ChartAxis::layout();
+                const QVector<qreal> &layout = ChartAxis::layout();
                 m_minWidth = 0;
                 m_minHeight = 0;
                 if(layout.isEmpty()) return;
                 QStringList ticksList;
-                bool categories = createLabels(ticksList,m_min,m_max,layout.size());
+                int ticks = layout.size();
+                int n = qMax(int(-floor(log10((m_max-m_min)/(ticks-1)))),0);
+                n++;
+                for (int i=0; i< ticks; i++) {
+                    qreal value = m_min + (i * (m_max - m_min)/ (ticks-1));
+                    Q_UNUSED(value);
+                    ticksList << QString::number(value,'f',n);
+                }
+                bool categories = false;
+            //    bool categories = createLabels(ticksList,m_min,m_max,layout.size());
                 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());
+                qreal height =  2*m_rect.bottom();
                 QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
-                lineItem->setLine(m_rect.left(), m_rect.bottom(), m_rect.right(), m_rect.bottom());
+                lineItem->setLine(m_rect.left() , m_rect.top(), m_rect.left(), m_rect.bottom());
-                qreal width = 0;
                 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());
+                    lineItem->setLine(m_rect.left() , layout[i], m_rect.right(), layout[i]);
                     QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
                     if (!categories || i<1) {
                         labelItem->setText(ticksList.at(i));
                         const QRectF& rect = labelItem->boundingRect();
                         QPointF center = rect.center();
                         labelItem->setTransformOriginPoint(center.x(), center.y());
-                        labelItem->setPos(layout[i] - center.x(), m_rect.bottom() + label_padding);
+                        labelItem->setPos(m_rect.left() - rect.width() - label_padding , layout[i]-center.y());
-                        if(labelItem->pos().x()<=width){
+                        if(labelItem->pos().y()+rect.height()>height) {
                             labelItem->setVisible(false);
                             lineItem->setVisible(false);
-                        }else{
+                        else {
                             labelItem->setVisible(true);
                             lineItem->setVisible(true);
-                            width=rect.width()+labelItem->pos().x();
+                            height=labelItem->pos().y();
                         }
-                        m_minWidth+=rect.width();
-                        m_minHeight=qMax(rect.height(),m_minHeight);
+                        m_minWidth=qMax(rect.width()+label_padding,m_minWidth);
+                        m_minHeight+=rect.height();
                     }
                     else {
                         labelItem->setText(ticksList.at(i));
                         const QRectF& rect = labelItem->boundingRect();
+                        m_minWidth=qMax(rect.width(),m_minWidth);
+                        m_minHeight+=rect.height();
                         QPointF center = rect.center();
                         labelItem->setTransformOriginPoint(center.x(), center.y());
-                        labelItem->setPos(layout[i] - (layout[i] - layout[i-1])/2 - center.x(), m_rect.bottom() + label_padding);
+                        labelItem->setPos(m_rect.left() - rect.width() - label_padding , layout[i] - (layout[i] - layout[i-1])/2 -center.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(layout[i-1],m_rect.top(),layout[i]-layout[i-1],m_rect.height());
+                        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(layout[i],m_rect.bottom(),layout[i],m_rect.bottom()+5);
+                    lineItem->setLine(m_rect.left()-5,layout[i],m_rect.left(),layout[i]);
                 }
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/qcategoriesaxis.cpp +4 -4

             /****************************************************************************
             **
             ** 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 "qcategoriesaxis.h"
             #include "qcategoriesaxis_p.h"
-            #include "chartaxisx_p.h"
+            #include "chartcategoriesaxisx_p.h"
-            #include "chartaxisy_p.h"
+            #include "chartcategoriesaxisy_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QCategoriesAxis::QCategoriesAxis(QObject *parent):
                 QAbstractAxis(*new QCategoriesAxisPrivate(this),parent)
             {
             }
             QCategoriesAxis::~QCategoriesAxis()
             {
             }
             QCategoriesAxis::QCategoriesAxis(QCategoriesAxisPrivate &d,QObject *parent):QAbstractAxis(d,parent)
             {
             }
             /*!
                 Appends \a categories to axis
             */
             void QCategoriesAxis::append(const QStringList &categories)
             {
                 Q_D(QCategoriesAxis);
                 d->m_categories.append(categories);
                 emit categoriesChanged();
             }
             /*!
                 Appends \a category to axis
             */
             void QCategoriesAxis::append(const QString &category)
             {
                 Q_D(QCategoriesAxis);
                 d->m_categories.append(category);
                 emit categoriesChanged();
             }
             /*!
                 Removes \a category from axis
             */
             void QCategoriesAxis::remove(const QString &category)
             {
                 Q_D(QCategoriesAxis);
                 if (d->m_categories.contains(category)) {
                     d->m_categories.removeAt(d->m_categories.indexOf(category));
                     emit categoriesChanged();
                 }
             }
             /*!
                 Inserts \a category to axis at \a index
             */
             void QCategoriesAxis::insert(int index, const QString &category)
             {
                 Q_D(QCategoriesAxis);
                 d->m_categories.insert(index,category);
                 emit categoriesChanged();
             }
             /*!
               Removes all categories.
              */
             void QCategoriesAxis::clear()
             {
                 Q_D(QCategoriesAxis);
                 d->m_categories.clear();
                 emit categoriesChanged();
             }
             void QCategoriesAxis::setCategories(const QStringList &categories)
             {
                 Q_D(QCategoriesAxis);
                 d->m_categories = categories;
                 emit categoriesChanged();
             }
             QStringList QCategoriesAxis::categories()
             {
                 Q_D(QCategoriesAxis);
                 return d->m_categories;
             }
             /*!
               Returns number of categories.
              */
             int QCategoriesAxis::count() const
             {
                 Q_D(const QCategoriesAxis);
                 return d->m_categories.count();
             }
             /*!
                 Returns category at \a index. Index must be valid.
             */
             QString QCategoriesAxis::at(int index) const
             {
                 Q_D(const QCategoriesAxis);
                 return d->m_categories.at(index);
             }
             /*!
                 Sets minimum category to \a minCategory.
             */
             void QCategoriesAxis::setMin(const QString& minCategory)
             {
                 Q_D(QCategoriesAxis);
                 int minIndex = d->m_categories.indexOf(minCategory);
                 if (minIndex == -1)
                     return;
             //    else
             //        QAbstractAxis::setMin(minIndex);
             }
             /*!
                 Sets maximum category to \a maxCategory.
             */
             void QCategoriesAxis::setMax(const QString& maxCategory)
             {
                 Q_D(QCategoriesAxis);
                 int maxIndex = d->m_categories.indexOf(maxCategory);
                 if (maxIndex == -1)
                     return;
             //    else
             //        QAbstractAxis::setMax(maxIndex);
             }
             /*!
                 Sets range from \a minCategory to \a maxCategory
             */
             void QCategoriesAxis::setRange(const QString& minCategory, const QString& maxCategory)
             {
                 // TODO: what if maxCategory < minCategory?
                 setMin(minCategory);
                 setMax(maxCategory);
             }
             /*!
                 Returns the type of axis.
             */
             QAbstractAxis::AxisType QCategoriesAxis::type() const
             {
                 return AxisTypeCategories;
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QCategoriesAxisPrivate::QCategoriesAxisPrivate(QCategoriesAxis* q):
                 QAbstractAxisPrivate(q)
             {
             }
             QCategoriesAxisPrivate::~QCategoriesAxisPrivate()
             {
             }
             void QCategoriesAxisPrivate::setMin(const QVariant& min)
             {
                 Q_Q(QCategoriesAxis);
                 q->setMin(min.toString());
             }
             void QCategoriesAxisPrivate::setMax(const QVariant& max)
             {
                 Q_Q(QCategoriesAxis);
                 q->setMax(max.toString());
             }
             void QCategoriesAxisPrivate::setRange(const QVariant& min, const QVariant& max)
             {
                Q_Q(QCategoriesAxis);
                q->setRange(min.toString(),max.toString());
             }
             int QCategoriesAxisPrivate::ticksCount() const
             {
                 return m_categories.count()+1;
             }
             ChartAxis* QCategoriesAxisPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q( QCategoriesAxis);
                 if(m_orientation == Qt::Vertical){
-                    return new ChartAxisY(q,presenter);
+                    return new ChartCategoriesAxisY(q,presenter);
                 }else{
-                    return new ChartAxisX(q,presenter);
+                    return new ChartCategoriesAxisX(q,presenter);
                 }
             }
             #include "moc_qcategoriesaxis.cpp"
             #include "moc_qcategoriesaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/qvaluesaxis.cpp +4 -4

             /****************************************************************************
             **
             ** 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 "qvaluesaxis.h"
             #include "qvaluesaxis_p.h"
-            #include "chartaxisx_p.h"
+            #include "chartvaluesaxisx_p.h"
-            #include "chartaxisy_p.h"
+            #include "chartvaluesaxisy_p.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QValuesAxis
                 \brief The QValuesAxis class is used for manipulating chart's axis.
                 \mainclass
                 Axis can be setup to show axis line with tick marks, grid lines and shades.
             */
             /*!
                 \qmlclass Axis QValuesAxis
                 \brief The Axis element is used for manipulating chart's axes
                 Axis can be setup to show axis line with tick marks, grid lines and shades.
                 To access Axes you can use ChartView API. For example:
                 \code
                     ChartView {
                         axisX.min: 0
                         axisX.max: 3
                         axisX.ticksCount: 4
                         axisY.min: 0
                         axisY.max: 4
                         // Add a few series...
                     }
                 \endcode
             */
             /*!
               \property QValuesAxis::min
               Defines the minimum value on the axis.
             */
             /*!
               \qmlproperty real Axis::min
               Defines the minimum value on the axis.
             */
             /*!
               \property QValuesAxis::max
               Defines the maximum value on the axis.
             */
             /*!
               \qmlproperty real Axis::max
               Defines the maximum value on the axis.
             */
             /*!
               \fn void QValuesAxis::minChanged(qreal min)
               Axis emits signal when \a min of axis has changed.
             */
             /*!
               \fn void QValuesAxis::maxChanged(qreal max)
               Axis emits signal when \a max of axis has changed.
             */
             /*!
               \fn void QValuesAxis::rangeChanged(qreal min, qreal max)
               Axis emits signal when \a min or \a max of axis has changed.
             */
             QValuesAxis::QValuesAxis(QObject *parent) :
                 QAbstractAxis(*new QValuesAxisPrivate(this),parent)
             {
             }
             QValuesAxis::QValuesAxis(QValuesAxisPrivate &d,QObject *parent) : QAbstractAxis(d,parent)
             {
             }
             QValuesAxis::~QValuesAxis()
             {
             }
             void QValuesAxis::setMin(qreal min)
             {
                 Q_D(QValuesAxis);
                 setRange(min,d->m_max);
             }
             qreal QValuesAxis::min() const
             {
                 Q_D(const QValuesAxis);
                 return d->m_min;
             }
             void QValuesAxis::setMax(qreal max)
             {
                 Q_D(QValuesAxis);
                 setRange(d->m_min,max);
             }
             qreal QValuesAxis::max() const
             {
                 Q_D(const QValuesAxis);
                 return d->m_max;
             }
             /*!
               Sets range from \a min to \a max on the axis.
             */
             void QValuesAxis::setRange(qreal min, qreal max)
             {
                 Q_D(QValuesAxis);
                 bool changed = false;
                 if (!qFuzzyIsNull(d->m_min - min)) {
                     d->m_min = min;
                     changed = true;
                     emit minChanged(min);
                 }
                 if (!qFuzzyIsNull(d->m_max - max)) {
                     d->m_max = max;
                     changed = true;
                     emit maxChanged(max);
                 }
                 if (changed) {
                    emit rangeChanged(d->m_min,d->m_max);
                    emit d->changed(d->m_min, d->m_max, d->m_ticksCount, d->m_niceNumbers);
                 }
             }
             /*!
               Sets \a count for ticks on the axis.
             */
             void QValuesAxis::setTicksCount(int count)
             {
                 Q_D(QValuesAxis);
                 if (d->m_ticksCount != count) {
                     d->m_ticksCount = count;
                     emit d->changed(d->m_min, d->m_max, d->m_ticksCount, d->m_niceNumbers);
                 }
             }
             /*!
               \fn int QAbstractAxis::ticksCount() const
               Return number of ticks on the axis
             */
             int QValuesAxis::ticksCount() const
             {
                 Q_D(const QValuesAxis);
                 return d->m_ticksCount;
             }
             void QValuesAxis::setNiceNumbersEnabled(bool enable)
             {
                 Q_D(QValuesAxis);
                 if (d->m_niceNumbers != enable){
                     d->m_niceNumbers = enable;
                     emit d->changed(d->m_min, d->m_max, d->m_ticksCount, d->m_niceNumbers);
                 }
             }
             bool  QValuesAxis::niceNumbersEnabled() const
             {
                 Q_D(const QValuesAxis);
                 return d->m_niceNumbers;
             }
             QAbstractAxis::AxisType QValuesAxis::type() const
             {
                 return AxisTypeValues;
             }
             /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QValuesAxisPrivate::QValuesAxisPrivate(QValuesAxis* q):
                 QAbstractAxisPrivate(q),
                 m_min(0),
                 m_max(0),
                 m_niceNumbers(false),
                 m_ticksCount(5)
             {
             }
             QValuesAxisPrivate::~QValuesAxisPrivate()
             {
             }
             void QValuesAxisPrivate::handleAxisRangeChanged(qreal min, qreal max,int count)
             {
                Q_Q(QValuesAxis);
                q->setRange(min,max);
                q->setTicksCount(count);
             }
             void QValuesAxisPrivate::setMin(const QVariant& min)
             {
                 Q_Q(QValuesAxis);
                 bool ok;
                 qreal value = min.toReal(&ok);
                 if(ok) q->setMin(value);
             }
             void QValuesAxisPrivate::setMax(const QVariant& max)
             {
                 Q_Q(QValuesAxis);
                 bool ok;
                 qreal value = max.toReal(&ok);
                 if(ok) q->setMax(value);
             }
             void QValuesAxisPrivate::setRange(const QVariant& min, const QVariant& max)
             {
                 Q_Q(QValuesAxis);
                 bool ok1;
                 bool ok2;
                 qreal value1 = min.toReal(&ok1);
                 qreal value2 = max.toReal(&ok2);
                 if(ok1&&ok2) q->setRange(value1,value2);
             }
             int QValuesAxisPrivate::ticksCount() const
             {
                 return m_ticksCount;
             }
             ChartAxis* QValuesAxisPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QValuesAxis);
                 if(m_orientation == Qt::Vertical){
-                    return new ChartAxisY(q,presenter);
+                    return new ChartValuesAxisY(q,presenter);
                 }else{
-                    return new ChartAxisX(q,presenter);
+                    return new ChartValuesAxisX(q,presenter);
                 }
             }
             #include "moc_qvaluesaxis.cpp"
             #include "moc_qvaluesaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartpresenter.cpp +2 -2

             /****************************************************************************
              **
              ** 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 "chartpresenter_p.h"
             #include "qchart.h"
             #include "qchart_p.h"
             #include "qabstractaxis.h"
             #include "qabstractaxis_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             #include "chartanimation_p.h"
             #include "qabstractseries_p.h"
             #include "qareaseries.h"
             #include "chartaxis_p.h"
-            #include "chartaxisx_p.h"
+            //#include "chartaxisx_p.h"
-            #include "chartaxisy_p.h"
+            //#include "chartaxisy_p.h"
             #include "areachartitem_p.h"
             #include "chartbackground_p.h"
             #include "chartlayout_p.h"
             #include <QTimer>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartPresenter::ChartPresenter(QChart* chart,ChartDataSet* dataset):QObject(chart),
             m_chart(chart),
             m_animator(0),
             m_dataset(dataset),
             m_chartTheme(0),
             m_options(QChart::NoAnimation),
             m_state(ShowState),
             m_layout(new ChartLayout(this)),
             m_backgroundItem(0),
             m_titleItem(0)
             {
             }
             ChartPresenter::~ChartPresenter()
             {
                 delete m_chartTheme;
             }
             void ChartPresenter::setGeometry(const QRectF& rect)
             {
                 Q_ASSERT(rect.isValid());
                 if(m_rect!=rect) {
                        m_rect=rect;
                        emit geometryChanged(m_rect);
                 }
             }
             void ChartPresenter::handleAxisAdded(QAbstractAxis* axis,Domain* domain)
             {
                 ChartAxis* item = axis->d_ptr->createGraphics(this);
                 item->setDomain(domain);
                 if(m_options.testFlag(QChart::GridAxisAnimations)){
                     item->setAnimator(m_animator);
                     item->setAnimation(new AxisAnimation(item));
                 }
                 if(item->axisType()==ChartAxis::X_AXIS){
                     m_chartTheme->decorate(axis,true);
                     QObject::connect(domain,SIGNAL(rangeXChanged(qreal,qreal,int)),item,SLOT(handleRangeChanged(qreal,qreal,int)));
                     //initialize
                     item->handleRangeChanged(domain->minX(),domain->maxX(),domain->tickXCount());
                 }
                 else{
                     m_chartTheme->decorate(axis,false);
                     QObject::connect(domain,SIGNAL(rangeYChanged(qreal,qreal,int)),item,SLOT(handleRangeChanged(qreal,qreal,int)));
                     //initialize
                     item->handleRangeChanged(domain->minY(),domain->maxY(),domain->tickYCount());
                 }
                 QObject::connect(this,SIGNAL(geometryChanged(QRectF)),item,SLOT(handleGeometryChanged(QRectF)));
                 //initialize
                 if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
                 m_axisItems.insert(axis, item);
             }
             void ChartPresenter::handleAxisRemoved(QAbstractAxis* axis)
             {
                 ChartAxis* item = m_axisItems.take(axis);
                 Q_ASSERT(item);
                 if(m_animator) m_animator->removeAnimation(item);
                 delete item;
             }
             void ChartPresenter::handleSeriesAdded(QAbstractSeries* series,Domain* domain)
             {
                 Chart *item = series->d_ptr->createGraphics(this);
                 Q_ASSERT(item);
                 item->setDomain(domain);
                 QObject::connect(this,SIGNAL(geometryChanged(QRectF)),item,SLOT(handleGeometryChanged(QRectF)));
                 QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),item,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                 //initialize
                 item->handleDomainChanged(domain->minX(),domain->maxX(),domain->minY(),domain->maxY());
                 if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
                 m_chartItems.insert(series,item);
             }
             void ChartPresenter::handleSeriesRemoved(QAbstractSeries* series)
             {
                 Chart* item = m_chartItems.take(series);
                 Q_ASSERT(item);
                 if(m_animator) {
                     //small hack to handle area animations
                     if(series->type() == QAbstractSeries::SeriesTypeArea){
                         QAreaSeries* areaSeries = static_cast<QAreaSeries*>(series);
                         AreaChartItem* area = static_cast<AreaChartItem*>(item);
                         m_animator->removeAnimation(area->upperLineItem());
                         if(areaSeries->lowerSeries())  m_animator->removeAnimation(area->lowerLineItem());
                     }else
                         m_animator->removeAnimation(item);
                 }
                 delete item;
             }
             void ChartPresenter::setTheme(QChart::ChartTheme theme,bool force)
             {
                 if(m_chartTheme && m_chartTheme->id() == theme) return;
                 delete m_chartTheme;
                 m_chartTheme = ChartTheme::createTheme(theme);
                 m_chartTheme->setForced(force);
                 m_chartTheme->decorate(m_chart);
                 m_chartTheme->decorate(m_chart->legend());
                 resetAllElements();
                 // We do not want "force" to stay on.
                 // Bar/pie are calling decorate when adding/removing slices/bars which means
                 // that to preserve users colors "force" must not be on.
                 m_chartTheme->setForced(false);
             }
             QChart::ChartTheme ChartPresenter::theme()
             {
                 return m_chartTheme->id();
             }
             void ChartPresenter::setAnimationOptions(QChart::AnimationOptions options)
             {
                 if(m_options!=options) {
                     m_options=options;
                     if(m_options!=QChart::NoAnimation && !m_animator) {
                         m_animator= new ChartAnimator(this);
                     }
                     resetAllElements();
                 }
             }
             void ChartPresenter::resetAllElements()
             {
                 QMapIterator<QAbstractAxis*, ChartAxis*> i(m_axisItems);
                 while (i.hasNext()) {
                        i.next();
                        Domain* domain = i.value()->domain();
                        QAbstractAxis* axis = i.key();
                        handleAxisRemoved(axis);
                        handleAxisAdded(axis,domain);
                 }
                 QMapIterator<QAbstractSeries*, Chart*> j(m_chartItems);
                    while (j.hasNext()) {
                           j.next();
                           Domain* domain = j.value()->domain();
                           QAbstractSeries* series = j.key();
                           handleSeriesRemoved(series);
                           handleSeriesAdded(series,domain);
                    }
             }
             void ChartPresenter::zoomIn(qreal factor)
             {
                 QRectF rect = geometry();
                 rect.setWidth(rect.width()/factor);
                 rect.setHeight(rect.height()/factor);
                 rect.moveCenter(geometry().center());
                 zoomIn(rect);
             }
             void ChartPresenter::zoomIn(const QRectF& rect)
             {
                 QRectF r = rect.normalized();
                 r.translate(-geometry().topLeft());
                 if (!r.isValid())
                     return;
                 m_state = ZoomInState;
                 m_statePoint = QPointF(r.center().x()/geometry().width(),r.center().y()/geometry().height());
                 m_dataset->zoomInDomain(r,geometry().size());
                 m_state = ShowState;
             }
             void ChartPresenter::zoomOut(qreal factor)
             {
                 m_state = ZoomOutState;
                 QRectF chartRect;
                 chartRect.setSize(geometry().size());
                 QRectF rect;
                 rect.setSize(chartRect.size()/factor);
                 rect.moveCenter(chartRect.center());
                 if (!rect.isValid())
                     return;
                 m_statePoint = QPointF(rect.center().x()/geometry().width(),rect.center().y()/geometry().height());
                 m_dataset->zoomOutDomain(rect, chartRect.size());
                 m_state = ShowState;
             }
             void ChartPresenter::scroll(qreal dx,qreal dy)
             {
                 if(dx<0) m_state=ScrollLeftState;
                 if(dx>0) m_state=ScrollRightState;
                 if(dy<0) m_state=ScrollUpState;
                 if(dy>0) m_state=ScrollDownState;
                 m_dataset->scrollDomain(dx,dy,geometry().size());
                 m_state = ShowState;
             }
             QChart::AnimationOptions ChartPresenter::animationOptions() const
             {
                 return m_options;
             }
             void ChartPresenter::createBackgroundItem()
             {
                 if (!m_backgroundItem) {
                     m_backgroundItem = new ChartBackground(rootItem());
                     m_backgroundItem->setPen(Qt::NoPen);
                     m_backgroundItem->setZValue(ChartPresenter::BackgroundZValue);
                 }
             }
             void ChartPresenter::createTitleItem()
             {
                 if (!m_titleItem) {
                     m_titleItem = new QGraphicsSimpleTextItem(rootItem());
                     m_titleItem->setZValue(ChartPresenter::BackgroundZValue);
                 }
             }
             void ChartPresenter::handleAnimationFinished()
             {
                m_animations.removeAll(qobject_cast<ChartAnimation*>(sender()));
                if(m_animations.empty()) emit animationsFinished();
             }
             void ChartPresenter::startAnimation(ChartAnimation* animation)
             {
                 if (animation->state() != QAbstractAnimation::Stopped) animation->stop();
                 QObject::connect(animation, SIGNAL(finished()),this,SLOT(handleAnimationFinished()),Qt::UniqueConnection);
                 if(!m_animations.isEmpty()){
                     m_animations.append(animation);
                 }
                 QTimer::singleShot(0, animation, SLOT(start()));
             }
             QGraphicsRectItem* ChartPresenter::backgroundItem()
             {
                 return m_backgroundItem;
             }
             void ChartPresenter::setBackgroundBrush(const QBrush& brush)
             {
                 createBackgroundItem();
                 m_backgroundItem->setBrush(brush);
                 m_layout->invalidate();
             }
             QBrush ChartPresenter::backgroundBrush() const
             {
                 if (!m_backgroundItem) return QBrush();
                 return m_backgroundItem->brush();
             }
             void ChartPresenter::setBackgroundPen(const QPen& pen)
             {
                 createBackgroundItem();
                 m_backgroundItem->setPen(pen);
                 m_layout->invalidate();
             }
             QPen ChartPresenter::backgroundPen() const
             {
                 if (!m_backgroundItem) return QPen();
                 return m_backgroundItem->pen();
             }
             QGraphicsItem* ChartPresenter::titleItem()
             {
                 return m_titleItem;
             }
             void ChartPresenter::setTitle(const QString& title)
             {
                 createTitleItem();
                 m_titleItem->setText(title);
                 m_layout->invalidate();
             }
             QString ChartPresenter::title() const
             {
                 if (!m_titleItem) return QString();
                 return m_titleItem->text();
             }
             void ChartPresenter::setTitleFont(const QFont& font)
             {
                 createTitleItem();
                 m_titleItem->setFont(font);
                 m_layout->invalidate();
             }
             QFont ChartPresenter::titleFont() const
             {
                 if (!m_titleItem)  return QFont();
                 return m_titleItem->font();
             }
             void ChartPresenter::setTitleBrush(const QBrush &brush)
             {
                 createTitleItem();
                 m_titleItem->setBrush(brush);
                 m_layout->invalidate();
             }
             QBrush ChartPresenter::titleBrush() const
             {
                 if (!m_titleItem) return QBrush();
                 return m_titleItem->brush();
             }
             void ChartPresenter::setBackgroundVisible(bool visible)
             {
                 createBackgroundItem();
                 m_backgroundItem->setVisible(visible);
             }
             bool ChartPresenter::isBackgroundVisible() const
             {
                 if (!m_backgroundItem) return false;
                 return m_backgroundItem->isVisible();
             }
             void ChartPresenter::setBackgroundDropShadowEnabled(bool enabled)
             {
                 createBackgroundItem();
                 m_backgroundItem->setDropShadowEnabled(enabled);
             }
             bool ChartPresenter::isBackgroundDropShadowEnabled() const
             {
                 if (!m_backgroundItem) return false;
                 return m_backgroundItem->isDropShadowEnabled();
             }
             QGraphicsLayout* ChartPresenter::layout()
             {
                 return m_layout;
             }
             void ChartPresenter::setMarginsMinimum(const QRectF& margins)
             {
                 Q_UNUSED(margins);
               //  m_layout->setMarginsMinimum(margins);
             }
             QRectF ChartPresenter::margins() const
             {
                 return QRectF();//m_layout->margins();
             }
             QLegend* ChartPresenter::legend()
             {
                 return m_chart->legend();
             }
             QList<ChartAxis*>  ChartPresenter::axisItems() const
             {
                 return m_axisItems.values();
             }
             void ChartPresenter::setVisible(bool visible)
             {
                 m_chart->setVisible(visible);
             }
             #include "moc_chartpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/chartaxisx.cpp removed 0 -122

NO CONTENT: file was removed

src/axis/chartaxisx_p.h removed 0 -55

NO CONTENT: file was removed

src/axis/chartaxisy.cpp removed 0 -128

NO CONTENT: file was removed

src/axis/chartaxisy_p.h removed 0 -56

NO CONTENT: file was removed

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