HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1006:a8ef6d6db8bf

Changes QChartAxis -> QAxis

Michal Klocek -

r1006:a8ef6d6db8bf

parent child

Context file:

r1006:a8ef6d6db8bf

Expand all files

demos/dynamicspline/chart.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "chart.h"
-            #include <QChartAxis>
+            #include <QAxis>
             #include <QSplineSeries>
             #include <QTime>
             Chart::Chart(QGraphicsItem *parent, Qt::WindowFlags wFlags)
                 :QChart(parent, wFlags),
                 m_step(1),
                 m_x(0),
                 m_y(1)
             {
                 qsrand((uint) QTime::currentTime().msec());
                 QObject::connect(&m_timer, SIGNAL(timeout()), this, SLOT(handleTimeout()));
                 m_timer.setInterval(1000);
                 m_series = new QSplineSeries(this);
                 QPen green(Qt::red);
                 green.setWidth(3);
                 m_series->setPen(green);
                 m_series->append(m_x, m_y);
                 addSeries(m_series);
                 axisY()->setRange(-5, 5);
                 axisX()->setRange(-9, 1);
                 axisX()->setTicksCount(11);
                 m_timer.start();
             }
             Chart::~Chart()
             {
             }
             void Chart::handleTimeout()
             {
                 m_x += m_step;
                 m_y = qrand() % 5 - 2.5;
                 m_series->append(m_x, m_y);
                 if (m_x >= 10)
                     m_series->remove(m_x - 10);
                 scrollRight();
             }

examples/customchart/main.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 <QApplication>
             #include <QMainWindow>
             #include <QChartView>
             #include <QLineSeries>
             QTCOMMERCIALCHART_USE_NAMESPACE
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
             //![1]
                 QLineSeries* series = new QLineSeries();
                 *series << QPointF(0, 6) << QPointF(2, 4) << QPointF(3, 8) << QPointF(7, 4) << QPointF(10,5);
                 QChart* chart = new QChart();
                 chart->addSeries(series);
             //![1]
             //![2]
                 // Customize series
                 QPen pen(QRgb(0xfdb157));
                 pen.setWidth(5);
                 series->setPen(pen);
                 // Customize chart title
                 QFont font;
                 font.setPixelSize(18);
                 chart->setTitleFont(font);
                 chart->setTitleBrush(QBrush(Qt::white));
                 chart->setTitle("Customchart example");
                 // Customize chart background
                 QLinearGradient backgroundGradient;
                 backgroundGradient.setStart(QPointF(0,0));
                 backgroundGradient.setFinalStop(QPointF(0,1));
                 backgroundGradient.setColorAt(0.0, QRgb(0xd2d0d1));
                 backgroundGradient.setColorAt(1.0, QRgb(0x4c4547));
                 backgroundGradient.setCoordinateMode(QGradient::ObjectBoundingMode);
                 chart->setBackgroundBrush(backgroundGradient);
             //![2]
             //![3]
-                QChartAxis* axisX = chart->axisX();
+                QAxis* axisX = chart->axisX();
-                QChartAxis* axisY = chart->axisY();
+                QAxis* axisY = chart->axisY();
                 // Customize axis label font
                 QFont labelsFont;
                 labelsFont.setPixelSize(12);
                 axisX->setLabelsFont(labelsFont);
                 axisY->setLabelsFont(labelsFont);
                 // Customize axis colors
                 QPen axisPen(QRgb(0xd18952));
                 axisPen.setWidth(2);
                 axisX->setAxisPen(axisPen);
                 axisY->setAxisPen(axisPen);
                 // Customize axis label colors
                 QBrush axisBrush(Qt::white);
                 axisX->setLabelsBrush(axisBrush);
                 axisY->setLabelsBrush(axisBrush);
                 // Customize grid lines and shades
                 axisX->setGridLineVisible(false);
                 axisY->setGridLineVisible(false);
                 axisY->setShadesPen(Qt::NoPen);
                 axisY->setShadesBrush(QBrush(QRgb(0xa5a2a3)));
                 axisY->setShadesVisible(true);
             //![3]
             //![4]
                 QChartAxisCategories* categoriesX = chart->axisX()->categories();
                 categoriesX->insert(1,"low");
                 categoriesX->insert(5,"optimal");
                 categoriesX->insert(10,"high");
                 QChartAxisCategories* categoriesY = chart->axisY()->categories();
                 categoriesY->insert(1,"slow");
                 categoriesY->insert(5,"med");
                 categoriesY->insert(10,"fast");
                 axisX->setRange(0,10);
                 axisX->setTicksCount(4);
                 axisY->setRange(0,10);
                 axisY->setTicksCount(4);
             //![4]
             //![5]
                 QChartView* chartView = new QChartView(chart);
                 chartView->setRenderHint(QPainter::Antialiasing);
             //![5]
             //![6]
                 QMainWindow window;
                 window.setCentralWidget(chartView);
                 window.resize(400, 300);
                 window.show();
             //![6]
                 return a.exec();
             }

examples/stackedbarchartdrilldown/drilldownchart.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "drilldownchart.h"
-            #include <QChartAxis>
+            #include <QAxis>
             QTCOMMERCIALCHART_USE_NAMESPACE
             DrilldownChart::DrilldownChart(QGraphicsItem *parent, Qt::WindowFlags wFlags)
                 : QChart(parent, wFlags)
                 ,m_currentSeries(0)
             {
             }
             void DrilldownChart::changeSeries(QAbstractSeries *series)
             {
                 if (m_currentSeries) {
                     removeSeries(m_currentSeries);
                 }
                 m_currentSeries = series;
                 addSeries(series);
                 setTitle(series->name());
                 axisY()->setNiceNumbersEnabled(true);
             }
             void DrilldownChart::handleClicked(QBarSet *barset, QString category, Qt::MouseButtons button)
             {
                 Q_UNUSED(barset)
                 Q_UNUSED(button)
                 DrilldownBarSeries* series = static_cast<DrilldownBarSeries*> (sender());
                 changeSeries(series->drilldownSeries(category));
             }
             #include "moc_drilldownchart.cpp"

src/animations/axisanimation.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "axisanimation_p.h"
             #include <QTimer>
             Q_DECLARE_METATYPE(QVector<qreal>)
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            AxisAnimation::AxisAnimation(Axis *axis): ChartAnimation(axis),
+            AxisAnimation::AxisAnimation(ChartAxis *axis): ChartAnimation(axis),
                 m_axis(axis)
             {
             }
             AxisAnimation::~AxisAnimation()
             {
             }
             QVariant AxisAnimation::interpolated(const QVariant &start, const QVariant &end, qreal progress ) const
             {
                 QVector<qreal> startVector = qVariantValue<QVector<qreal> >(start);
                 QVector<qreal> endVecotr = qVariantValue<QVector<qreal> >(end);
                 QVector<qreal> result;
                 Q_ASSERT(startVector.count() == endVecotr.count()) ;
                 for(int i = 0; i < startVector.count(); i++){
                        qreal value = startVector[i] + ((endVecotr[i]- startVector[i]) * progress);//qBound(0.0, progress, 1.0));
                        result << value;
                 }
                 return qVariantFromValue(result);
             }
             void AxisAnimation::updateCurrentValue (const QVariant &value )
             {
                 if (state() != QAbstractAnimation::Stopped)//workaround
                 {
                     QVector<qreal> vector = qVariantValue<QVector<qreal> >(value);
                     Q_ASSERT(vector.count() != 0);
                     m_axis->setLayout(vector);
                 }
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/animations/axisanimation_p.h +3 -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$
             **
             ****************************************************************************/
             #ifndef AXISANIMATION_H
             #define AXISANIMATION_H
-            #include "axis_p.h"
+            #include "chartaxis_p.h"
             #include "chartanimation_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class AxisAnimation: public ChartAnimation
             {
             public:
-                AxisAnimation(Axis *axis);
+                AxisAnimation(ChartAxis *axis);
                 ~AxisAnimation();
             protected:
                 QVariant interpolated(const QVariant &from, const QVariant &to, qreal progress ) const;
                 void updateCurrentValue(const QVariant &value );
             private:
-                Axis *m_axis;
+                ChartAxis *m_axis;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* AXISITEM_H_ */

src/animations/chartanimator.cpp +6 -6

             /****************************************************************************
             **
             ** 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 "chartanimator_p.h"
             #include "axisanimation_p.h"
             #include "xyanimation_p.h"
             #include "splineanimation_p.h"
             #include "xychartitem_p.h"
             #include "pieanimation_p.h"
             #include "baranimation_p.h"
             #include "barchartitem_p.h"
             #include "areachartitem_p.h"
             #include "splinechartitem_p.h"
             #include "scatterchartitem_p.h"
             #include <QTimer>
             Q_DECLARE_METATYPE(QVector<QPointF>)
             Q_DECLARE_METATYPE(QVector<qreal>)
             Q_DECLARE_METATYPE(QVector<QRectF>)
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             const static int duration = 1000;
             ChartAnimator::ChartAnimator(QObject *parent):QObject(parent),
                 m_state(ShowState)
             {
             }
             ChartAnimator::~ChartAnimator()
             {
             }
-            void ChartAnimator::addAnimation(Axis *item)
+            void ChartAnimator::addAnimation(ChartAxis *item)
             {
                 ChartAnimation *animation = m_animations.value(item);
                 if (!animation) {
                     animation = new AxisAnimation(item);
                     m_animations.insert(item, animation);
                 }
                 item->setAnimator(this);
             }
             void ChartAnimator::addAnimation(SplineChartItem *item)
             {
                 ChartAnimation *animation = m_animations.value(item);
                 if (!animation) {
                     animation = new SplineAnimation(item);
                     m_animations.insert(item, animation);
                 }
                 item->setAnimator(this);
             }
             void ChartAnimator::addAnimation(ScatterChartItem *item)
             {
                 ChartAnimation *animation = m_animations.value(item);
                 if (!animation) {
                     animation = new XYAnimation(item);
                     m_animations.insert(item, animation);
                 }
                 item->setAnimator(this);
             }
             void ChartAnimator::addAnimation(LineChartItem *item)
             {
                 ChartAnimation *animation = m_animations.value(item);
                 if (!animation) {
                     animation = new XYAnimation(item);
                     m_animations.insert(item, animation);
                 }
                 item->setAnimator(this);
             }
             void ChartAnimator::addAnimation(PieChartItem *item)
             {
                 ChartAnimation *animation = m_animations.value(item);
                 if (!animation) {
                     animation = new PieAnimation(item);
                     m_animations.insert(item, animation);
                 }
                 item->setAnimator(this);
             }
             void ChartAnimator::addAnimation(BarChartItem *item)
             {
                 ChartAnimation *animation = m_animations.value(item);
                 if (!animation) {
                     animation = new BarAnimation(item);
                     m_animations.insert(item, animation);
                 }
                 item->setAnimator(this);
             }
             void ChartAnimator::removeAnimation(Chart *item)
             {
                 item->setAnimator(0);
                 m_animations.remove(item);
             }
-            void ChartAnimator::updateLayout(Axis *item , QVector<qreal> &newLayout)
+            void ChartAnimator::updateLayout(ChartAxis *item , QVector<qreal> &newLayout)
             {
                 AxisAnimation *animation = static_cast<AxisAnimation*>(m_animations.value(item));
                 Q_ASSERT(animation);
                 QVector<qreal> oldLayout = item->layout();
                 if (newLayout.count() == 0)
                     return;
                 switch (m_state) {
                 case ZoomOutState: {
                     QRectF rect = item->geometry();
                     oldLayout.resize(newLayout.count());
                     for(int i = 0, j = oldLayout.count() - 1; i < (oldLayout.count() + 1) / 2; ++i, --j) {
-                        oldLayout[i] = item->axisType() == Axis::X_AXIS ? rect.left() : rect.bottom();
+                        oldLayout[i] = item->axisType() == ChartAxis::X_AXIS ? rect.left() : rect.bottom();
-                        oldLayout[j] = item->axisType() == Axis::X_AXIS ? rect.right() : rect.top();
+                        oldLayout[j] = item->axisType() == ChartAxis::X_AXIS ? rect.right() : rect.top();
                     }
                 }
                     break;
                 case ZoomInState: {
-                    int index = qMin(oldLayout.count() * (item->axisType() == Axis::X_AXIS ? m_point.x() : (1 - m_point.y())), newLayout.count() - 1.0);
+                    int index = qMin(oldLayout.count() * (item->axisType() == ChartAxis::X_AXIS ? m_point.x() : (1 - m_point.y())), newLayout.count() - 1.0);
                     oldLayout.resize(newLayout.count());
                     for(int i = 0; i < oldLayout.count(); i++)
                         oldLayout[i]= oldLayout[index];
                 }
                     break;
                 case ScrollDownState:
                 case ScrollRightState: {
                     oldLayout.resize(newLayout.count());
                     for(int i = 0, j = i + 1; i < oldLayout.count() - 1; ++i, ++j)
                         oldLayout[i]= oldLayout[j];
                 }
                     break;
                 case ScrollUpState:
                 case ScrollLeftState: {
                     oldLayout.resize(newLayout.count());
                     for(int i = oldLayout.count() - 1, j = i - 1; i > 0; --i, --j)
                         oldLayout[i]= oldLayout[j];
                 }
                     break;
                 default: {
                     oldLayout.resize(newLayout.count());
                     QRectF rect = item->geometry();
                     for(int i = 0, j = oldLayout.count() - 1; i < oldLayout.count(); ++i, --j)
-                        oldLayout[i] = item->axisType() == Axis::X_AXIS ? rect.left() : rect.top();
+                        oldLayout[i] = item->axisType() == ChartAxis::X_AXIS ? rect.left() : rect.top();
                 }
                     break;
                 }
                 if (animation->state() != QAbstractAnimation::Stopped)
                     animation->stop();
                 animation->setDuration(duration);
                 animation->setEasingCurve(QEasingCurve::OutQuart);
                 QVariantAnimation::KeyValues value;
                 animation->setKeyValues(value); //workaround for wrong interpolation call
                 animation->setKeyValueAt(0.0, qVariantFromValue(oldLayout));
                 animation->setKeyValueAt(1.0, qVariantFromValue(newLayout));
                 QTimer::singleShot(0, animation, SLOT(start()));
             }
             void ChartAnimator::updateLayout(SplineChartItem *item, QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints, QVector<QPointF> &oldControlPoints, QVector<QPointF> &newControlPoints, int index)
             {
                 SplineAnimation *animation = static_cast<SplineAnimation *>(m_animations.value(item));
                 Q_ASSERT(animation);
                 if (newPoints.count() < 2 || newControlPoints.count() < 2)
                     return;
                 bool empty = oldPoints.count() == 0;
                 if (animation->state() != QAbstractAnimation::Stopped)
                     animation->stop();
                 animation->setDuration(duration);
                 if (!empty)
                     animation->setAnimationType(ChartAnimation::MoveDownAnimation);
                 else
                     animation->setAnimationType(ChartAnimation::LineDrawAnimation);
                 animation->setEasingCurve(QEasingCurve::OutQuart);
                 animation->setValues(oldPoints, newPoints, oldControlPoints, newControlPoints, index);
                 QTimer::singleShot(0, animation, SLOT(start()));
             }
             void ChartAnimator::updateLayout(XYChartItem *item, QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints, int index)
             {
                 XYAnimation *animation = static_cast<XYAnimation *>(m_animations.value(item));
                 Q_ASSERT(animation);
                 if (newPoints.count() == 0)
                     return;
                 bool empty = oldPoints.count() == 0;
                 if (animation->state() != QAbstractAnimation::Stopped)
                     animation->stop();
                 animation->setDuration(duration);
                 if (!empty)
                     animation->setAnimationType(ChartAnimation::MoveDownAnimation);
                 else
                     animation->setAnimationType(ChartAnimation::LineDrawAnimation);
                 animation->setEasingCurve(QEasingCurve::OutQuart);
                 animation->setValues(oldPoints, newPoints, index);
                 QTimer::singleShot(0, animation, SLOT(start()));
             }
             void ChartAnimator::addAnimation(PieChartItem *item, QPieSlice *slice, const PieSliceData &sliceData, bool isEmpty)
             {
                 PieAnimation *animation = static_cast<PieAnimation *>(m_animations.value(item));
                 Q_ASSERT(animation);
                 animation->addSlice(slice, sliceData, isEmpty);
             }
             void ChartAnimator::removeAnimation(PieChartItem *item, QPieSlice *slice)
             {
                 PieAnimation *animation = static_cast<PieAnimation *>(m_animations.value(item));
                 Q_ASSERT(animation);
                 animation->removeSlice(slice);
             }
             void ChartAnimator::updateLayout(PieChartItem *item, const PieLayout &layout)
             {
                 PieAnimation *animation = static_cast<PieAnimation *>(m_animations.value(item));
                 Q_ASSERT(animation);
                 animation->updateValues(layout);
             }
             void ChartAnimator::updateLayout(PieChartItem *item, QPieSlice *slice, const PieSliceData &sliceData)
             {
                 PieAnimation *animation = static_cast<PieAnimation *>(m_animations.value(item));
                 Q_ASSERT(animation);
                 animation->updateValue(slice, sliceData);
             }
             void ChartAnimator::updateLayout(BarChartItem *item, const QVector<QRectF> &oldLayout, const QVector<QRectF> &newLayout)
             {
                 BarAnimation *animation = static_cast<BarAnimation *>(m_animations.value(item));
                 Q_ASSERT(animation);
                 animation->setDuration(duration);
                 animation->setKeyValueAt(0.0, qVariantFromValue(oldLayout));
                 animation->setKeyValueAt(1.0, qVariantFromValue(newLayout));
                 QTimer::singleShot(0, animation, SLOT(start()));
             }
             void ChartAnimator::setState(State state, const QPointF &point)
             {
                 m_state = state;
                 m_point = point;
             }
             #include "moc_chartanimator_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/animations/chartanimator_p.h +3 -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$
             **
             ****************************************************************************/
             #ifndef CHARTANIMATOR_P_H
             #define CHARTANIMATOR_P_H
             #include "qchartglobal.h"
             #include "chartanimation_p.h"
             #include "piechartitem_p.h"
             #include "barchartitem_p.h"
             #include <QPointF>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartItem;
-            class Axis;
+            class ChartAxis;
             class AreaChartItem;
             class SplineChartItem;
             class ScatterChartItem;
             class LineChartItem;
             class XYChartItem;
             class ChartAnimator : public QObject
             {
                 Q_OBJECT
             public:
                 enum State{ShowState, ScrollUpState, ScrollDownState, ScrollLeftState, ScrollRightState, ZoomInState, ZoomOutState};
                 ChartAnimator(QObject *parent = 0);
                 virtual ~ChartAnimator();
-                void addAnimation(Axis *item);
+                void addAnimation(ChartAxis *item);
                 void addAnimation(PieChartItem *item);
                 void addAnimation(ScatterChartItem *item);
                 void addAnimation(LineChartItem *item);
                 void addAnimation(SplineChartItem *item);
                 void addAnimation(BarChartItem *item);
                 void removeAnimation(Chart *item);
                 void animationStarted();
                 void updateLayout(XYChartItem *item, QVector<QPointF> &oldLayout, QVector<QPointF> &newLayout, int index);
                 void updateLayout(SplineChartItem *item, QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints, QVector<QPointF> &oldControlPoints, QVector<QPointF> &newContorlPoints, int index);
-                void updateLayout(Axis *item, QVector<qreal> &layout);
+                void updateLayout(ChartAxis *item, QVector<qreal> &layout);
                 void addAnimation(PieChartItem *item, QPieSlice *slice, const PieSliceData &sliceData, bool isEmpty);
                 void removeAnimation(PieChartItem *item, QPieSlice *slice);
                 void updateLayout(PieChartItem *item, const PieLayout &layout);
                 void updateLayout(PieChartItem *item, QPieSlice *slice, const PieSliceData &sliceData);
                 void updateLayout(BarChartItem *item, const QVector<QRectF> &oldLayout, const QVector<QRectF> &newLayout);
                 void setState(State state,const QPointF &point = QPointF());
             private:
                  QMap<Chart *, ChartAnimation *> m_animations;
                  State m_state;
                  QPointF m_point;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/axis/axis.pri +5 -5

             INCLUDEPATH += $$PWD
             DEPENDPATH += $$PWD
             SOURCES += \
-                $$PWD/axis.cpp \
+                $$PWD/chartaxis.cpp \
-                $$PWD/qchartaxis.cpp \
+                $$PWD/qaxis.cpp \
                 $$PWD/qchartaxiscategories.cpp
             PRIVATE_HEADERS += \
-                $$PWD/axis_p.h \
+                $$PWD/chartaxis_p.h \
-                $$PWD/qchartaxis_p.h \
+                $$PWD/qaxis_p.h \
                 $$PWD/qchartaxiscategories_p.h
             PUBLIC_HEADERS += \
-                $$PWD/qchartaxis.h \
+                $$PWD/qaxis.h \
                 $$PWD/qchartaxiscategories.h

src/axis/chartaxis.cpp ~~src/axis/axis.cpp~~ renamed +34 -34

             /****************************************************************************
             **
             ** 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 "axis_p.h"
+            #include "chartaxis_p.h"
-            #include "qchartaxis.h"
+            #include "qaxis.h"
-            #include "qchartaxis_p.h"
+            #include "qaxis_p.h"
             #include "qchartaxiscategories_p.h"
             #include "chartpresenter_p.h"
             #include "chartanimator_p.h"
             #include <QPainter>
             #include <QDebug>
             #include <cmath>
             static int label_padding = 5;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            Axis::Axis(QChartAxis *axis,ChartPresenter *presenter,AxisType type) : Chart(presenter),
+            ChartAxis::ChartAxis(QAxis *axis,ChartPresenter *presenter,AxisType type) : Chart(presenter),
                 m_chartAxis(axis),
                 m_type(type),
                 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_ticksCount(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()));
                 QObject::connect(m_chartAxis->categories()->d_ptr.data(),SIGNAL(updated()),this,SLOT(handleAxisCategoriesUpdated()));
                 handleAxisUpdated();
             }
-            Axis::~Axis()
+            ChartAxis::~ChartAxis()
             {
             }
-            void Axis::createItems(int count)
+            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 Axis::deleteItems(int count)
+            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 Axis::updateLayout(QVector<qreal> &layout)
+            void ChartAxis::updateLayout(QVector<qreal> &layout)
             {
                 if (animator()) {
                     animator()->updateLayout(this,layout);
                 } else {
                     setLayout(layout);
                 }
             }
-            bool Axis::createLabels(QStringList &labels,qreal min, qreal max,int ticks) const
+            bool ChartAxis::createLabels(QStringList &labels,qreal min, qreal max,int ticks) const
             {
                 Q_ASSERT(max>=min);
                 Q_ASSERT(ticks>1);
                 QChartAxisCategories* categories = m_chartAxis->categories();
                 bool category = categories->count()>0;
                 if (!category) {
                     int n = qMax(int(-floor(log10((max-min)/(ticks-1)))),0);
                     n++;
                     for (int i=0; i< ticks; i++) {
                         qreal value = min + (i * (max - min)/ (ticks-1));
                         labels << QString::number(value,'f',n);
                     }
                 } else {
                     QList<qreal> values = categories->values();
                     for (int i=0; i< ticks; i++) {
                         qreal value = (min + (i * (max - min)/ (ticks-1)));
                         int j=0;
                         for (; j<values.count(); j++) {
                             if (values.at(j) > value) break;
                         }
                         if (j!=0) value=values.at(j-1);
                         QString label = categories->label(value);
                         labels << label;
                     }
                 }
                 return category;
             }
-            void Axis::setAxisOpacity(qreal opacity)
+            void ChartAxis::setAxisOpacity(qreal opacity)
             {
                 m_axis->setOpacity(opacity);
             }
-            qreal Axis::axisOpacity() const
+            qreal ChartAxis::axisOpacity() const
             {
                 return m_axis->opacity();
             }
-            void Axis::setGridOpacity(qreal opacity)
+            void ChartAxis::setGridOpacity(qreal opacity)
             {
                 m_grid->setOpacity(opacity);
             }
-            qreal Axis::gridOpacity() const
+            qreal ChartAxis::gridOpacity() const
             {
                 return m_grid->opacity();
             }
-            void Axis::setLabelsOpacity(qreal opacity)
+            void ChartAxis::setLabelsOpacity(qreal opacity)
             {
                 m_labels->setOpacity(opacity);
             }
-            qreal Axis::labelsOpacity() const
+            qreal ChartAxis::labelsOpacity() const
             {
                 return m_labels->opacity();
             }
-            void Axis::setShadesOpacity(qreal opacity)
+            void ChartAxis::setShadesOpacity(qreal opacity)
             {
                 m_shades->setOpacity(opacity);
             }
-            qreal Axis::shadesOpacity() const
+            qreal ChartAxis::shadesOpacity() const
             {
                 return m_shades->opacity();
             }
-            void Axis::setLabelsAngle(int angle)
+            void ChartAxis::setLabelsAngle(int angle)
             {
                 foreach(QGraphicsItem* item , m_labels->childItems()) {
                       item->setRotation(angle);
                 }
                 m_labelsAngle=angle;
             }
-            void Axis::setLabelsPen(const QPen &pen)
+            void ChartAxis::setLabelsPen(const QPen &pen)
             {
                 foreach(QGraphicsItem* item , m_labels->childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setPen(pen);
                 }
             }
-            void Axis::setLabelsBrush(const QBrush &brush)
+            void ChartAxis::setLabelsBrush(const QBrush &brush)
             {
                 foreach(QGraphicsItem* item , m_labels->childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setBrush(brush);
                 }
             }
-            void Axis::setLabelsFont(const QFont &font)
+            void ChartAxis::setLabelsFont(const QFont &font)
             {
                 foreach(QGraphicsItem* item , m_labels->childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setFont(font);
                 }
             }
-            void Axis::setShadesBrush(const QBrush &brush)
+            void ChartAxis::setShadesBrush(const QBrush &brush)
             {
                 foreach(QGraphicsItem* item , m_shades->childItems()) {
                     static_cast<QGraphicsRectItem*>(item)->setBrush(brush);
                 }
             }
-            void Axis::setShadesPen(const QPen &pen)
+            void ChartAxis::setShadesPen(const QPen &pen)
             {
                 foreach(QGraphicsItem* item , m_shades->childItems()) {
                     static_cast<QGraphicsRectItem*>(item)->setPen(pen);
                 }
             }
-            void Axis::setAxisPen(const QPen &pen)
+            void ChartAxis::setAxisPen(const QPen &pen)
             {
                 foreach(QGraphicsItem* item , m_axis->childItems()) {
                        static_cast<QGraphicsLineItem*>(item)->setPen(pen);
                 }
             }
-            void Axis::setGridPen(const QPen &pen)
+            void ChartAxis::setGridPen(const QPen &pen)
             {
                 foreach(QGraphicsItem* item , m_grid->childItems()) {
                     static_cast<QGraphicsLineItem*>(item)->setPen(pen);
                 }
             }
-            QVector<qreal> Axis::calculateLayout() const
+            QVector<qreal> ChartAxis::calculateLayout() const
             {
                 Q_ASSERT(m_ticksCount>=2);
                 QVector<qreal> points;
                 points.resize(m_ticksCount);
                 switch (m_type)
                 {
                     case X_AXIS:
                     {
                         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;
                         }
                     }
                     break;
                     case Y_AXIS:
                     {
                         const qreal deltaY = m_rect.height()/(m_ticksCount-1);
                         for (int i = 0; i < m_ticksCount; ++i) {
                              int y = i * -deltaY + m_rect.bottom();
                              points[i] = y;
                         }
                     }
                     break;
                 }
                 return points;
             }
-            void Axis::setLayout(QVector<qreal> &layout)
+            void ChartAxis::setLayout(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();
             	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());
             	qreal minWidth = 0;
             	qreal minHeight = 0;
             	switch (m_type)
             	{
             		case X_AXIS:
             		{
             			QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
             			lineItem->setLine(m_rect.left(), m_rect.bottom(), m_rect.right(), m_rect.bottom());
             			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();
             				    minWidth+=rect.width();
             				    minHeight=qMax(rect.height(),minHeight);
             				    QPointF center = rect.center();
             				    labelItem->setTransformOriginPoint(center.x(), center.y());
             				    labelItem->setPos(layout[i] - center.x(), m_rect.bottom() + label_padding);
                             } else {
             				    labelItem->setText(ticksList.at(i));
             			        const QRectF& rect = labelItem->boundingRect();
             			        minWidth+=rect.width();
             			        minHeight=qMax(rect.height()+label_padding,minHeight);
             				    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);
             				}
                             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);
             			}
             		}
             		break;
             		case Y_AXIS:
             		{
             			QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
             			lineItem->setLine(m_rect.left() , m_rect.top(), m_rect.left(), 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));
                             if (!categories || i<1) {
             				    labelItem->setText(ticksList.at(i));
             				    const QRectF& rect = labelItem->boundingRect();
             				    minWidth=qMax(rect.width()+label_padding,minWidth);
             				    minHeight+=rect.height();
             				    QPointF center = rect.center();
             				    labelItem->setTransformOriginPoint(center.x(), center.y());
             				    labelItem->setPos(m_rect.left() - rect.width() - label_padding , layout[i]-center.y());
                             } else {
             				    labelItem->setText(ticksList.at(i));
             				    const QRectF& rect = labelItem->boundingRect();
             				    minWidth=qMax(rect.width(),minWidth);
             				    minHeight+=rect.height();
             				    QPointF center = rect.center();
             				    labelItem->setTransformOriginPoint(center.x(), center.y());
             				    labelItem->setPos(m_rect.left() - rect.width() - label_padding , layout[i] - (layout[i] - layout[i-1])/2 -center.y());
             				}
                             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]);
             			}
             		}
             		break;
             		default:
             		    qWarning()<<"Unknown axis type";
             		break;
             	}
                 m_layoutVector=layout;
                 presenter()->setMinimumMarginWidth(this,minWidth);
                 presenter()->setMinimumMarginHeight(this,minHeight);
             }
-            bool Axis::isEmpty()
+            bool ChartAxis::isEmpty()
             {
                 return m_rect.isEmpty() || qFuzzyIsNull(m_min - m_max) || m_ticksCount==0;
             }
             //handlers
-            void Axis::handleAxisCategoriesUpdated()
+            void ChartAxis::handleAxisCategoriesUpdated()
             {
                 if (isEmpty()) return;
             	updateLayout(m_layoutVector);
             }
-            void Axis::handleAxisUpdated()
+            void ChartAxis::handleAxisUpdated()
             {
                 if (isEmpty()) return;
                 if (m_chartAxis->isAxisVisible()) {
                     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(m_chartAxis->shadesOpacity());
                 } 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 Axis::handleRangeChanged(qreal min, qreal max,int tickCount)
+            void ChartAxis::handleRangeChanged(qreal min, qreal max,int tickCount)
             {
                 if (qFuzzyIsNull(min - max) || tickCount < 2)
                     return;
                 m_min = min;
                 m_max = max;
                 m_ticksCount= tickCount;
                 if (isEmpty()) return;
                 QVector<qreal> layout = calculateLayout();
                 updateLayout(layout);
             }
-            void Axis::handleGeometryChanged(const QRectF &rect)
+            void ChartAxis::handleGeometryChanged(const QRectF &rect)
             {
                 if(m_rect != rect)
                 {
                     m_rect = rect;
                     if (isEmpty()) return;
                     QVector<qreal> layout = calculateLayout();
                     updateLayout(layout);
                 }
             }
-            void Axis::axisSelected()
+            void ChartAxis::axisSelected()
             {
                 qDebug()<<"TODO: axis clicked";
             }
-            #include "moc_axis_p.cpp"
+            #include "moc_chartaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/chartaxis_p.h ~~src/axis/axis_p.h~~ renamed +8 -8

             /****************************************************************************
             **
             ** 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$
             **
             ****************************************************************************/
             #ifndef AXIS_H
             #define AXIS_H
             #include "qchartglobal.h"
             #include "chart_p.h"
             #include <QGraphicsItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class QChartAxis;
+            class QAxis;
             class ChartPresenter;
-            class Axis : public Chart
+            class ChartAxis : public Chart
             {
                 Q_OBJECT
             public:
                 enum AxisType{X_AXIS,Y_AXIS};
-                Axis(QChartAxis *axis, ChartPresenter *presenter, AxisType type = X_AXIS);
+                ChartAxis(QAxis *axis, ChartPresenter *presenter, AxisType type = X_AXIS);
-                ~Axis();
+                ~ChartAxis();
                 AxisType axisType() const { return m_type; }
                 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);
                 inline QRectF geometry() const { return m_rect; }
                 inline QVector<qreal> layout() { return m_layoutVector; }
             public Q_SLOTS:
                 void handleAxisUpdated();
                 void handleAxisCategoriesUpdated();
                 void handleRangeChanged(qreal min , qreal max,int tickCount);
                 void handleGeometryChanged(const QRectF &size);
             private:
                 inline bool isEmpty();
                 void createItems(int count);
                 void deleteItems(int count);
                 QVector<qreal> calculateLayout() const;
                 void updateLayout(QVector<qreal> &layout);
                 void setLayout(QVector<qreal> &layout);
                 bool createLabels(QStringList &labels,qreal min, qreal max,int ticks) const;
                 void axisSelected();
             private:
-                QChartAxis* m_chartAxis;
+                QAxis* m_chartAxis;
                 AxisType m_type;
                 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;
                 int m_ticksCount;
                 friend class AxisAnimation;
                 friend class AxisItem;
             };
             class AxisItem: public QGraphicsLineItem
             {
             public:
-                explicit AxisItem(Axis *axis, QGraphicsItem *parent = 0) : QGraphicsLineItem(parent), m_axis(axis) {}
+                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()!=Axis::X_AXIS?8:0,m_axis->axisType()!=Axis::Y_AXIS?8:0));
+                   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:
-               Axis* m_axis;
+               ChartAxis* m_axis;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* AXISITEM_H_ */

src/axis/qaxis.cpp ~~src/axis/qchartaxis.cpp~~ renamed +69 -69

             /****************************************************************************
             **
             ** 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 "qchartaxis.h"
+            #include "qaxis.h"
-            #include "qchartaxis_p.h"
+            #include "qaxis_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QChartAxis
                 \brief The QChartAxis class is used for manipulating chart's axis
                 and for adding optional axes to the chart.
                 \mainclass
                 There is only one x Axis, however there can be multiple y axes.
                 Each chart series can be bound to exactly one Y axis and the share common X axis.
                 Axis can be setup to show axis line with ticks, gird lines and shades.
             */
             /*!
-               \fn bool QChartAxis::isAxisVisible() const
+               \fn bool QAxis::isAxisVisible() const
                \brief Returns if axis is visible
                \sa setAxisVisible()
             */
             /*!
-               \fn QPen QChartAxis::axisPen() const
+               \fn QPen QAxis::axisPen() const
                \brief  Returns pen used to draw axis and ticks.
                 \sa setAxisPen()
             */
             /*!
-               \fn bool QChartAxis::isGridLineVisible() const
+               \fn bool QAxis::isGridLineVisible() const
                \brief Returns if grid is visible
                \sa setGridLineVisible()
             */
             /*!
-               \fn QPen QChartAxis::gridLinePen() const
+               \fn QPen QAxis::gridLinePen() const
                \brief  Returns pen used to draw grid.
                 \sa setGridLinePen()
             */
             /*!
-               \fn  bool QChartAxis::labelsVisible() const
+               \fn  bool QAxis::labelsVisible() const
                \brief Returns if grid is visible
                \sa setLabelsVisible()
             */
             /*!
-               \fn QPen QChartAxis::labelsPen() const
+               \fn QPen QAxis::labelsPen() const
                \brief Returns the pen used to labels.
                 \sa setLabelsPen()
             */
             /*!
-               \fn QBrush QChartAxis::labelsBrush() const
+               \fn QBrush QAxis::labelsBrush() const
                \brief Returns brush used to draw labels.
                 \sa setLabelsBrush()
             */
             /*!
-               \fn QFont QChartAxis::labelsFont() const
+               \fn QFont QAxis::labelsFont() const
                \brief Returns font used to draw labels.
                 \sa setLabelsFont()
             */
             /*!
-               \fn QFont QChartAxis::labelsAngle() const
+               \fn QFont QAxis::labelsAngle() const
                \brief Returns angle used to draw labels.
                 \sa setLabelsAngle()
             */
             /*!
-               \fn bool QChartAxis::shadesVisible() const
+               \fn bool QAxis::shadesVisible() const
                \brief Returns if shades are visible.
                \sa setShadesVisible()
             */
             /*!
-              \fn  qreal QChartAxis::shadesOpacity() const
+              \fn  qreal QAxis::shadesOpacity() const
               \brief Returns opacity of shades.
              */
             /*!
-               \fn QPen QChartAxis::shadesPen() const
+               \fn QPen QAxis::shadesPen() const
                \brief Returns pen used to draw shades.
                 \sa setShadesPen()
             */
             /*!
-               \fn QBrush QChartAxis::shadesBrush() const
+               \fn QBrush QAxis::shadesBrush() const
                \brief Returns brush used to draw shades.
                 \sa setShadesBrush()
             */
             /*!
-               \fn qreal QChartAxis::min() const
+               \fn qreal QAxis::min() const
                \brief Returns minimum value on the axis.
                \sa setMin()
             */
             /*!
-               \fn qreal QChartAxis::max() const
+               \fn qreal QAxis::max() const
                \brief Returns maximim value on the axis.
                \sa setMax()
             */
             /*!
-               \fn void QChartAxis::minChanged(qreal min)
+               \fn void QAxis::minChanged(qreal min)
                \brief Axis emits signal when \a min of axis has changed.
             */
             /*!
-               \fn void QChartAxis::maxChanged(qreal max)
+               \fn void QAxis::maxChanged(qreal max)
                \brief Axis emits signal when \a max of axis has changed.
             */
             /*!
-               \fn void QChartAxis::rangeChanged(qreal min, qreal max)
+               \fn void QAxis::rangeChanged(qreal min, qreal max)
                \brief Axis emits signal when \a min or \a max of axis has changed.
             */
             /*!
-               \fn int QChartAxis::ticksCount() const
+               \fn int QAxis::ticksCount() const
                \brief Return number of ticks on the axis
                \sa setTicksCount()
             */
             /*!
-                \fn QChartAxisCategories* QChartAxis::categories()
+                \fn QChartAxisCategories* QAxis::categories()
                 \brief Returns pointer to the list of categories which correspond to the values on the axis.
             */
             /*!
-                \fn void QChartAxis::ticksCountChanged(int count)
+                \fn void QAxis::ticksCountChanged(int count)
                 \brief Emits the new \a count of ticks on the axis
                 Signal is emitted when the number of the ticks on the axis has been changed to a different value.
                 Parementer count\a count is the new number of ticks on the axis.
             */
             /*!
                 Constructs new axis object which is a child of \a parent. Ownership is taken by
                 QChatView or QChart when axis added.
             */
-            QChartAxis::QChartAxis(QObject *parent) : QObject(parent),
+            QAxis::QAxis(QObject *parent) : QObject(parent),
-            d_ptr(new QChartAxisPrivate(this))
+            d_ptr(new QAxisPrivate(this))
             {
             }
             /*!
                 Destructor of the axis object. When axis is added to chart, chart object takes ownership.
             */
-            QChartAxis::~QChartAxis()
+            QAxis::~QAxis()
             {
             }
             /*!
               Sets \a pen used to draw axis line and ticks.
              */
-            void QChartAxis::setAxisPen(const QPen &pen)
+            void QAxis::setAxisPen(const QPen &pen)
             {
             	if (d_ptr->m_axisPen!=pen) {
             	    d_ptr->m_axisPen = pen;
                     emit d_ptr->updated();
             	}
             }
-            QPen QChartAxis::axisPen() const
+            QPen QAxis::axisPen() const
             {
                 return d_ptr->m_axisPen;
             }
             /*!
               Sets if axis and ticks are \a visible.
              */
-            void QChartAxis::setAxisVisible(bool visible)
+            void QAxis::setAxisVisible(bool visible)
             {
                 if (d_ptr->m_axisVisible != visible) {
                     d_ptr->m_axisVisible = visible;
                     emit d_ptr->updated();
             	}
             }
-            bool QChartAxis::isAxisVisible() const
+            bool QAxis::isAxisVisible() const
             {
                 return d_ptr->m_axisVisible;
             }
             /*!
               Sets if grid line is \a visible.
              */
-            void QChartAxis::setGridLineVisible(bool visible)
+            void QAxis::setGridLineVisible(bool visible)
             {
                 if (d_ptr->m_gridLineVisible != visible) {
                     d_ptr->m_gridLineVisible = visible;
                     emit d_ptr->updated();
             	}
             }
-            bool QChartAxis::isGridLineVisible() const
+            bool QAxis::isGridLineVisible() const
             {
                 return d_ptr->m_gridLineVisible;
             }
             /*!
               Sets \a pen used to draw grid line.
              */
-            void QChartAxis::setGridLinePen(const QPen &pen)
+            void QAxis::setGridLinePen(const QPen &pen)
             {
                 if (d_ptr->m_gridLinePen != pen) {
                     d_ptr->m_gridLinePen = pen;
                     emit d_ptr->updated();
             	}
             }
-            QPen QChartAxis::gridLinePen() const
+            QPen QAxis::gridLinePen() const
             {
                 return d_ptr->m_gridLinePen;
             }
             /*!
               Sets if axis' labels are \a visible.
              */
-            void QChartAxis::setLabelsVisible(bool visible)
+            void QAxis::setLabelsVisible(bool visible)
             {
                 if (d_ptr->m_labelsVisible != visible) {
                     d_ptr->m_labelsVisible = visible;
                     emit d_ptr->updated();
             	}
             }
-            bool QChartAxis::labelsVisible() const
+            bool QAxis::labelsVisible() const
             {
                 return d_ptr->m_labelsVisible;
             }
             /*!
               Sets \a pen used to draw labels.
              */
-            void QChartAxis::setLabelsPen(const QPen &pen)
+            void QAxis::setLabelsPen(const QPen &pen)
             {
                 if (d_ptr->m_labelsPen != pen) {
                     d_ptr->m_labelsPen = pen;
                     emit d_ptr->updated();
             	}
             }
-            QPen QChartAxis::labelsPen() const
+            QPen QAxis::labelsPen() const
             {
                 return d_ptr->m_labelsPen;
             }
             /*!
               Sets \a brush used to draw labels.
              */
-            void QChartAxis::setLabelsBrush(const QBrush &brush)
+            void QAxis::setLabelsBrush(const QBrush &brush)
             {
                 if (d_ptr->m_labelsBrush != brush) {
                     d_ptr->m_labelsBrush = brush;
                     emit d_ptr->updated();
             	}
             }
-            QBrush  QChartAxis::labelsBrush() const
+            QBrush  QAxis::labelsBrush() const
             {
                 return d_ptr->m_labelsBrush;
             }
             /*!
               Sets \a font used to draw labels.
              */
-            void QChartAxis::setLabelsFont(const QFont &font)
+            void QAxis::setLabelsFont(const QFont &font)
             {
                 if (d_ptr->m_labelsFont != font) {
                     d_ptr->m_labelsFont = font;
                     emit d_ptr->updated();
             	}
             }
-            QFont QChartAxis::labelsFont() const
+            QFont QAxis::labelsFont() const
             {
                 return d_ptr->m_labelsFont;
             }
             /*!
               Sets \a angle for all the labels on given axis.
              */
-            void QChartAxis::setLabelsAngle(int angle)
+            void QAxis::setLabelsAngle(int angle)
             {
                 if (d_ptr->m_labelsAngle != angle) {
                     d_ptr->m_labelsAngle = angle;
                     emit d_ptr->updated();
             	}
             }
-            int QChartAxis::labelsAngle() const
+            int QAxis::labelsAngle() const
             {
                 return d_ptr->m_labelsAngle;
             }
             /*!
               Sets if shades are \a visible.
              */
-            void QChartAxis::setShadesVisible(bool visible)
+            void QAxis::setShadesVisible(bool visible)
             {
                 if (d_ptr->m_shadesVisible != visible) {
                     d_ptr->m_shadesVisible = visible;
                     emit d_ptr->updated();
             	}
             }
-            bool QChartAxis::shadesVisible() const
+            bool QAxis::shadesVisible() const
             {
                 return d_ptr->m_shadesVisible;
             }
             /*!
               Sets \a pen used to draw shades.
              */
-            void QChartAxis::setShadesPen(const QPen &pen)
+            void QAxis::setShadesPen(const QPen &pen)
             {
                 if (d_ptr->m_shadesPen != pen) {
                     d_ptr->m_shadesPen = pen;
                     emit d_ptr->updated();
             	}
             }
-            QPen QChartAxis::shadesPen() const
+            QPen QAxis::shadesPen() const
             {
                 return d_ptr->m_shadesPen;
             }
             /*!
               Sets \a brush used to draw shades.
              */
-            void QChartAxis::setShadesBrush(const QBrush &brush)
+            void QAxis::setShadesBrush(const QBrush &brush)
             {
                 if (d_ptr->m_shadesBrush != brush) {
                     d_ptr->m_shadesBrush = brush;
                     emit d_ptr->updated();
             	}
             }
-            QBrush QChartAxis::shadesBrush() const
+            QBrush QAxis::shadesBrush() const
             {
                 return d_ptr->m_shadesBrush;
             }
             /*!
               Sets \a opacity of the shades.
              */
-            void QChartAxis::setShadesOpacity(qreal opacity)
+            void QAxis::setShadesOpacity(qreal opacity)
             {
                 if (d_ptr->m_shadesOpacity != opacity) {
                     d_ptr->m_shadesOpacity=opacity;
                     emit d_ptr->updated();
             	}
             }
-            qreal QChartAxis::shadesOpacity() const
+            qreal QAxis::shadesOpacity() const
             {
                 return d_ptr->m_shadesOpacity;
             }
             /*!
              Sets \a min value on the axis.
              */
-            void QChartAxis::setMin(qreal min)
+            void QAxis::setMin(qreal min)
             {
             	setRange(min,d_ptr->m_max);
             }
-            qreal QChartAxis::min() const
+            qreal QAxis::min() const
             {
                 return d_ptr->m_min;
             }
             /*!
              Sets \a max value on the axis.
              */
-            void QChartAxis::setMax(qreal max)
+            void QAxis::setMax(qreal max)
             {
                 setRange(d_ptr->m_min,max);
             }
-            qreal QChartAxis::max() const
+            qreal QAxis::max() const
             {
                 return d_ptr->m_max;
             }
             /*!
               Sets range from \a min to \a max on the axis.
              */
-            void QChartAxis::setRange(qreal min, qreal max)
+            void QAxis::setRange(qreal min, qreal max)
             {
             	bool changed = false;
                 if (!qFuzzyIsNull(d_ptr->m_min - min)) {
                     d_ptr->m_min = min;
                     changed = true;
                     emit minChanged(min);
                 }
                 if (!qFuzzyIsNull(d_ptr->m_max - max)) {
                     d_ptr->m_max = max;
                     changed = true;
                     emit maxChanged(max);
                 }
                 if (changed) {
                     emit rangeChanged(d_ptr->m_min,d_ptr->m_max);
                     emit d_ptr->changed(d_ptr->m_min, d_ptr->m_max, d_ptr->m_ticksCount, d_ptr->m_niceNumbers);
                 }
             }
             /*!
               Sets \a count for ticks on the axis.
              */
-            void QChartAxis::setTicksCount(int count)
+            void QAxis::setTicksCount(int count)
             {
                 if (d_ptr->m_ticksCount != count) {
                     d_ptr->m_ticksCount = count;
             		emit ticksCountChanged(count);
             		emit d_ptr->changed(d_ptr->m_min, d_ptr->m_max, d_ptr->m_ticksCount, d_ptr->m_niceNumbers);
             	}
             }
-            int QChartAxis::ticksCount() const
+            int QAxis::ticksCount() const
             {
                 return d_ptr->m_ticksCount;
             }
             /*!
               Sets axis, shades, labels and grid lines to be visible.
              */
-            void QChartAxis::show()
+            void QAxis::show()
             {
                 d_ptr->m_axisVisible=true;
                 d_ptr->m_gridLineVisible=true;
                 d_ptr->m_labelsVisible=true;
                 d_ptr->m_shadesVisible=true;
                 emit d_ptr->updated();
             }
             /*!
               Sets axis, shades, labels and grid lines to not be visible.
              */
-            void QChartAxis::hide()
+            void QAxis::hide()
             {
                 d_ptr->m_axisVisible = false;
                 d_ptr->m_gridLineVisible = false;
                 d_ptr->m_labelsVisible = false;
                 d_ptr->m_shadesVisible = false;
                 emit d_ptr->updated();
             }
             /*!
                 Sets the nice numbers state to \a enable
             */
-            void QChartAxis::setNiceNumbersEnabled(bool enable)
+            void QAxis::setNiceNumbersEnabled(bool enable)
             {
                 if (d_ptr->m_niceNumbers != enable){
                     d_ptr->m_niceNumbers = enable;
                     emit d_ptr->changed(d_ptr->m_min, d_ptr->m_max, d_ptr->m_ticksCount, d_ptr->m_niceNumbers);
                 }
             }
             /*!
                 Returns whether nice numbers are enabled or not.
             */
-            bool  QChartAxis::niceNumbersEnabled() const
+            bool  QAxis::niceNumbersEnabled() const
             {
                 return d_ptr->m_niceNumbers;
             }
-            QChartAxisCategories* QChartAxis::categories()
+            QChartAxisCategories* QAxis::categories()
             {
                 return &d_ptr->m_category;
             }
             /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            QChartAxisPrivate::QChartAxisPrivate(QChartAxis* q):
+            QAxisPrivate::QAxisPrivate(QAxis* q):
             q_ptr(q),
             m_axisVisible(true),
             m_gridLineVisible(true),
             m_labelsVisible(true),
             m_labelsAngle(0),
             m_shadesVisible(false),
             m_shadesOpacity(1.0),
             m_min(0),
             m_max(0),
             m_ticksCount(5),
             m_niceNumbers(false)
             {
             }
-            QChartAxisPrivate::~QChartAxisPrivate()
+            QAxisPrivate::~QAxisPrivate()
             {
             }
-            void QChartAxisPrivate::handleAxisRangeChanged(qreal min, qreal max,int count)
+            void QAxisPrivate::handleAxisRangeChanged(qreal min, qreal max,int count)
             {
                q_ptr->setRange(min,max);
                q_ptr->setTicksCount(count);
             }
-            #include "moc_qchartaxis.cpp"
+            #include "moc_qaxis.cpp"
-            #include "moc_qchartaxis_p.cpp"
+            #include "moc_qaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/qaxis.h ~~src/axis/qchartaxis.h~~ renamed +9 -9

             /****************************************************************************
             **
             ** 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$
             **
             ****************************************************************************/
-            #ifndef QCHARTAXIS_H
+            #ifndef QAXIS_H
-            #define QCHARTAXIS_H
+            #define QAXIS_H
             #include <qchartglobal.h>
             #include <qchartaxiscategories.h>
             #include <QPen>
             #include <QFont>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class QChartAxisPrivate;
+            class QAxisPrivate;
-            class QTCOMMERCIALCHART_EXPORT QChartAxis : public QObject
+            class QTCOMMERCIALCHART_EXPORT QAxis : public QObject
             {
             	Q_OBJECT
             public:
-                QChartAxis(QObject *parent =0);
+                QAxis(QObject *parent =0);
-                ~QChartAxis();
+                ~QAxis();
                 //axis handling
                 bool isAxisVisible() const;
                 void setAxisVisible(bool visible = true);
                 void setAxisPen(const QPen &pen);
                 QPen axisPen() const;
                 //grid handling
                 bool isGridLineVisible() const;
                 void setGridLineVisible(bool visible = true);
                 void setGridLinePen(const QPen &pen);
                 QPen gridLinePen() const;
                 //labels handling
                 bool labelsVisible() const;
                 void setLabelsVisible(bool visible = true);
                 void setLabelsPen(const QPen &pen);
                 QPen labelsPen() const;
                 void setLabelsBrush(const QBrush &brush);
                 QBrush labelsBrush() const;
                 void setLabelsFont(const QFont &font);
                 QFont labelsFont() const;
                 void setLabelsAngle(int angle);
                 int labelsAngle() const;
                 //shades handling
                 bool shadesVisible() const;
                 void setShadesVisible(bool visible = true);
                 void setShadesPen(const QPen &pen);
                 QPen shadesPen() const;
                 void setShadesBrush(const QBrush &brush);
                 QBrush shadesBrush() const;
                 void setShadesOpacity(qreal opacity);
                 qreal shadesOpacity() const;
                 //range handling
                 void setMin(qreal min);
                 qreal min() const;
                 void setMax(qreal max);
                 qreal max() const;
                 void setRange(qreal min, qreal max);
                 //ticks handling
                 void setTicksCount(int count);
                 int ticksCount() const;
                 void setNiceNumbersEnabled(bool enable = true);
                 bool niceNumbersEnabled() const;
                 QChartAxisCategories* categories();
                 void show();
                 void hide();
             Q_SIGNALS:
             	void minChanged(qreal min);
             	void maxChanged(qreal max);
             	void rangeChanged(qreal min, qreal max);
             	void ticksCountChanged(int count);
             private:
-            	QScopedPointer<QChartAxisPrivate> d_ptr;
+            	QScopedPointer<QAxisPrivate> d_ptr;
-                Q_DISABLE_COPY(QChartAxis);
+                Q_DISABLE_COPY(QAxis);
                 friend class ChartDataSet;
-                friend class Axis;
+                friend class ChartAxis;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* QCHARTAXIS_H_ */

src/axis/qaxis_p.h ~~src/axis/qchartaxis_p.h~~ renamed +8 -8

             /****************************************************************************
             **
             ** 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 QCHARTAXIS_P_H
+            #ifndef QAXIS_P_H
-            #define QCHARTAXIS_P_H
+            #define QAXIS_P_H
-            #include "qchartaxis.h"
+            #include "qaxis.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class QChartAxisPrivate : public QObject
+            class QAxisPrivate : public QObject
             {
                 Q_OBJECT
             public:
-                QChartAxisPrivate(QChartAxis *q);
+                QAxisPrivate(QAxis *q);
-                ~QChartAxisPrivate();
+                ~QAxisPrivate();
             Q_SIGNALS:
                 void updated();
                 void changed(qreal min, qreal max, int tickCount,bool niceNumbers);
             public Q_SLOTS:
                 void handleAxisRangeChanged(qreal min, qreal max,int count);
             private:
-                QChartAxis *q_ptr;
+                QAxis *q_ptr;
                 bool m_axisVisible;
                 QPen m_axisPen;
                 QBrush m_axisBrush;
                 bool m_gridLineVisible;
                 QPen m_gridLinePen;
                 bool m_labelsVisible;
                 QPen m_labelsPen;
                 QBrush m_labelsBrush;
                 QFont m_labelsFont;
                 int m_labelsAngle;
                 bool m_shadesVisible;
                 QPen m_shadesPen;
                 QBrush m_shadesBrush;
                 qreal m_shadesOpacity;
                 qreal m_min;
                 qreal m_max;
                 int m_ticksCount;
                 QChartAxisCategories m_category;
                 bool m_niceNumbers;
-                friend class QChartAxis;
+                friend class QAxis;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/axis/qchartaxiscategories.h +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$
             **
             ****************************************************************************/
             #ifndef QCHARTAXISCATEGORIES_H
             #define QCHARTAXISCATEGORIES_H
             #include <qchartglobal.h>
             #include <qbarseries.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QChartAxisCategoriesPrivate;
             class QTCOMMERCIALCHART_EXPORT QChartAxisCategories : public QObject
             {
                 Q_OBJECT
             private:
                 QChartAxisCategories();
             public:
                 ~QChartAxisCategories();
                 void insert(const QBarCategories &category);
                 void insert(qreal value,QString label);
                 void remove(qreal value);
                 QList<qreal> values() const;
                 QString label(qreal value) const;
                 void clear();
                 int count();
             private:
                 QScopedPointer<QChartAxisCategoriesPrivate> d_ptr;
-                friend class QChartAxisPrivate;
+                friend class QAxisPrivate;
-                friend class Axis;
+                friend class ChartAxis;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* QCHARTAXISCATEGORIES_H_ */

src/barchart/barchartitem.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "barchartitem_p.h"
             #include "bar_p.h"
             #include "barlabel_p.h"
             #include "qbarset.h"
             #include "qbarset_p.h"
             #include "qbarseries.h"
             #include "qbarseries_p.h"
             #include "qchart.h"
-            #include "qchartaxis.h"
+            //#include "qchartaxis.h"
             #include "qchartaxiscategories.h"
             #include "chartpresenter_p.h"
             #include "chartanimator_p.h"
             #include "chartdataset_p.h"
             #include <QPainter>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             BarChartItem::BarChartItem(QBarSeries *series, ChartPresenter *presenter) :
                 ChartItem(presenter),
                 m_layoutSet(false),
                 m_series(series)
             {
                 setFlag(ItemClipsChildrenToShape);
                 connect(series->d_func(), SIGNAL(updatedBars()), this, SLOT(handleLayoutChanged()));
                 connect(series->d_func(), SIGNAL(restructuredBars()), this, SLOT(handleModelChanged()));
                 setZValue(ChartPresenter::BarSeriesZValue);
                 dataChanged();
             }
             BarChartItem::~BarChartItem()
             {
             }
             void BarChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(painter);
                 Q_UNUSED(option);
                 Q_UNUSED(widget);
             }
             QRectF BarChartItem::boundingRect() const
             {
                 return m_rect;
             }
             void BarChartItem::dataChanged()
             {
                 foreach(QGraphicsItem *item, childItems()) {
                     delete item;
                 }
                 m_bars.clear();
                 m_labels.clear();
                 m_layout.clear();
                 // Create new graphic items for bars
                 for (int c = 0; c < m_series->categoryCount(); c++) {
                     QString category = m_series->d_func()->categoryName(c);
                     for (int s = 0; s < m_series->barsetCount(); s++) {
                         QBarSet *set = m_series->d_func()->barsetAt(s);
                         Bar *bar = new Bar(set,category,this);
                         m_bars.append(bar);
                         connect(bar, SIGNAL(clicked(QString,Qt::MouseButtons)), set, SIGNAL(clicked(QString,Qt::MouseButtons)));
                         connect(bar, SIGNAL(clicked(QBarSet*,QString,Qt::MouseButtons)), m_series, SIGNAL(clicked(QBarSet*,QString,Qt::MouseButtons)));
                         connect(bar, SIGNAL(hovered(bool)), set, SIGNAL(hovered(bool)));
                         connect(bar, SIGNAL(hovered(QBarSet*,bool)), m_series, SIGNAL(hovered(QBarSet*,bool)));
                         m_layout.append(QRectF(0, 0, 0, 0));
                     }
                 }
                 // Create labels
                 for (int category = 0; category < m_series->categoryCount(); category++) {
                     for (int s = 0; s < m_series->barsetCount(); s++) {
                         QBarSet *set = m_series->d_func()->barsetAt(s);
                         BarLabel *value = new BarLabel(*set, this);
                         m_labels.append(value);
                         connect(set->d_ptr.data(),SIGNAL(labelsVisibleChanged(bool)),value,SLOT(labelsVisibleChanged(bool)));
                     }
                 }
             }
             QVector<QRectF> BarChartItem::calculateLayout()
             {
                 QVector<QRectF> layout;
                 // Use temporary qreals for accurancy
                 qreal categoryCount = m_series->categoryCount();
                 qreal setCount = m_series->barsetCount();
                 // Domain:
                 qreal width = geometry().width();
                 qreal height = geometry().height();
                 qreal range = m_domainMaxY - m_domainMinY;
                 qreal scale = (height / range);
                 qreal categoryWidth = width / categoryCount;
                 qreal barWidth = categoryWidth / (setCount+1);
                 int itemIndex(0);
                 for (int category = 0; category < categoryCount; category++) {
                     qreal xPos = categoryWidth * category + barWidth / 2 + geometry().topLeft().x();
                     qreal yPos = height + scale * m_domainMinY + geometry().topLeft().y();
                     for (int set = 0; set < setCount; set++) {
                         QBarSet* barSet = m_series->d_func()->barsetAt(set);
                         qreal barHeight = barSet->at(category) * scale;
                         Bar* bar = m_bars.at(itemIndex);
                         QRectF rect(xPos, yPos - barHeight, barWidth, barHeight);
                         layout.append(rect);
                         bar->setPen(barSet->pen());
                         bar->setBrush(barSet->brush());
                         BarLabel* label = m_labels.at(itemIndex);
                         if (!qFuzzyIsNull(barSet->at(category))) {
                             label->setText(QString::number(barSet->at(category)));
                         } else {
                             label->setText(QString(""));
                         }
                         label->setPos(xPos + (rect.width()/2 - label->boundingRect().width()/2)
                                       ,yPos - barHeight/2 - label->boundingRect().height()/2);
                         label->setFont(barSet->labelFont());
                         itemIndex++;
                         xPos += barWidth;
                     }
                 }
                 return layout;
             }
             void BarChartItem::applyLayout(const QVector<QRectF> &layout)
             {
                 if (animator())
                     animator()->updateLayout(this, m_layout, layout);
                 else
                     setLayout(layout);
             }
             void BarChartItem::setLayout(const QVector<QRectF> &layout)
             {
                 m_layout = layout;
                 for (int i=0; i < m_bars.count(); i++)
                     m_bars.at(i)->setRect(layout.at(i));
                 update();
             }
             //handlers
             void BarChartItem::handleModelChanged()
             {
                 dataChanged();
             }
             void BarChartItem::handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY)
             {
                 m_domainMinX = minX;
                 m_domainMaxX = maxX;
                 m_domainMinY = minY;
                 m_domainMaxY = maxY;
                 handleLayoutChanged();
             }
             void BarChartItem::handleGeometryChanged(const QRectF &rect)
             {
                 prepareGeometryChange();
                 m_rect = rect;
                 handleLayoutChanged();
                 m_layoutSet = true;
             }
             void BarChartItem::handleLayoutChanged()
             {
                 if ((m_rect.width() <= 0) || (m_rect.height() <= 0)) {
                     // rect size zero.
                     return;
                 }
                 QVector<QRectF> layout = calculateLayout();
                 applyLayout(layout);
                 update();
             }
             #include "moc_barchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartdataset.cpp +18 -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 "chartdataset_p.h"
-            #include "qchartaxis.h"
+            #include "qaxis.h"
-            #include "qchartaxis_p.h"
+            #include "qaxis_p.h"
             #include "qabstractseries_p.h"
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qpieseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartDataSet::ChartDataSet(QObject *parent):QObject(parent),
-                m_axisX(new QChartAxis(this)),
+                m_axisX(new QAxis(this)),
-                m_axisY(new QChartAxis(this)),
+                m_axisY(new QAxis(this)),
                 m_domainIndex(0),
                 m_axisXInitialized(false)
             {
             }
             ChartDataSet::~ChartDataSet()
             {
             }
-            void ChartDataSet::addSeries(QAbstractSeries* series, QChartAxis *axisY)
+            void ChartDataSet::addSeries(QAbstractSeries* series, QAxis *axisY)
             {
                 if(axisY==0) axisY = m_axisY;
-                QChartAxis* axis = m_seriesAxisMap.value(series);
+                QAxis* axis = m_seriesAxisMap.value(series);
                 if(axis) {
                     qWarning() << "Can not add series. Series already on the chart";
                     return;
                 }
                 series->setParent(this); // take ownership
                 axisY->setParent(this); // take ownership
                 Domain* domain = m_axisDomainMap.value(axisY);
                 if(!domain) {
                     domain = new Domain(axisY);
                     QObject::connect(axisY->d_ptr.data(),SIGNAL(changed(qreal,qreal,int,bool)),domain,SLOT(handleAxisYChanged(qreal,qreal,int,bool)));
                     QObject::connect(axisX()->d_ptr.data(),SIGNAL(changed(qreal,qreal,int,bool)),domain,SLOT(handleAxisXChanged(qreal,qreal,int,bool)));
                     QObject::connect(domain,SIGNAL(rangeYChanged(qreal,qreal,int)),axisY->d_ptr.data(),SLOT(handleAxisRangeChanged(qreal,qreal,int)));
                     QObject::connect(domain,SIGNAL(rangeXChanged(qreal,qreal,int)),axisX()->d_ptr.data(),SLOT(handleAxisRangeChanged(qreal,qreal,int)));
                     //initialize
                     m_axisDomainMap.insert(axisY,domain);
                     emit axisAdded(axisY,domain);
                 }
                 if(!m_axisXInitialized){
                    emit axisAdded(axisX(),domain);
                    m_axisXInitialized=true;
                 }
                 series->d_ptr->scaleDomain(*domain);
                 if(series->type() == QAbstractSeries::SeriesTypeBar
                         || series->type() == QAbstractSeries::SeriesTypeStackedBar
                         || series->type() == QAbstractSeries::SeriesTypePercentBar) {
                     QBarSeries* barSeries = static_cast<QBarSeries*>(series);
                     setupCategories(barSeries);
                 }
                 if (series->type()== QAbstractSeries::SeriesTypePie && m_seriesAxisMap.count() == 0) {
                     axisX()->hide();
                     this->axisY()->hide();
                 }
                 m_seriesAxisMap.insert(series,axisY);
                 QMapIterator<int, QAbstractSeries*> i(m_indexSeriesMap);
                 int key=0;
                 while (i.hasNext()) {
                     i.next();
                     if(i.key()!=key) {
                         break;
                     }
                     key++;
                 }
                 m_indexSeriesMap.insert(key,series);
                 emit seriesAdded(series,domain);
             }
-            QChartAxis* ChartDataSet::removeSeries(QAbstractSeries* series)
+            QAxis* ChartDataSet::removeSeries(QAbstractSeries* series)
             {
-                QChartAxis* axis = m_seriesAxisMap.value(series);
+                QAxis* axis = m_seriesAxisMap.value(series);
                 if(!axis){
                     qWarning()<<"Can not remove series. Series not found on the chart.";
                     return 0;
                 }
                 emit seriesRemoved(series);
                 m_seriesAxisMap.remove(series);
                 int key = seriesIndex(series);
                 Q_ASSERT(key!=-1);
                 m_indexSeriesMap.remove(key);
                 series->setParent(0);
-                QList<QChartAxis*> axes =  m_seriesAxisMap.values();
+                QList<QAxis*> axes =  m_seriesAxisMap.values();
                 int i = axes.indexOf(axis);
                 if(i==-1){
                     Domain* domain = m_axisDomainMap.take(axis);
                     emit axisRemoved(axis);
                     if(axis!=axisY()){
                         axis->setParent(0);
                     }
                     delete domain;
                 }
                 if(m_seriesAxisMap.values().size()==0)
                 {
                     m_axisXInitialized=false;
                     emit axisRemoved(axisX());
                 }
                 return axis;
             }
             void ChartDataSet::removeAllSeries()
             {
                 QList<QAbstractSeries*> series =  m_seriesAxisMap.keys();
-                QList<QChartAxis*> axes;
+                QList<QAxis*> axes;
                 foreach(QAbstractSeries *s , series) {
-                    QChartAxis* axis  = removeSeries(s);
+                    QAxis* axis  = removeSeries(s);
                     if(axis==axisY()) continue;
                     int i = axes.indexOf(axis);
                     if(i==-1){
                         axes<<axis;
                     }
                 }
                 Q_ASSERT(m_seriesAxisMap.count()==0);
                 Q_ASSERT(m_axisDomainMap.count()==0);
                 qDeleteAll(series);
                 qDeleteAll(axes);
             }
             void ChartDataSet::setupCategories(QBarSeries* series)
             {
                QChartAxisCategories* categories = axisX()->categories();
                categories->clear();
                categories->insert(series->categories());
             }
             void ChartDataSet::zoomInDomain(const QRectF& rect, const QSizeF& size)
             {
-                QMapIterator<QChartAxis*, Domain*> i(m_axisDomainMap);
+                QMapIterator<QAxis*, Domain*> i(m_axisDomainMap);
                 while (i.hasNext()) {
                     i.next();
                     i.value()->zoomIn(rect,size);
                 }
             }
             void ChartDataSet::zoomOutDomain(const QRectF& rect, const QSizeF& size)
             {
-                QMapIterator<QChartAxis*, Domain*> i(m_axisDomainMap);
+                QMapIterator<QAxis*, Domain*> i(m_axisDomainMap);
                 while (i.hasNext()) {
                     i.next();
                     i.value()->zoomOut(rect,size);
                 }
             }
             int ChartDataSet::seriesCount(QAbstractSeries::QSeriesType type)
             {
                 int count=0;
-                QMapIterator<QAbstractSeries*, QChartAxis*> i(m_seriesAxisMap);
+                QMapIterator<QAbstractSeries*, QAxis*> i(m_seriesAxisMap);
                 while (i.hasNext()) {
                        i.next();
                        if(i.key()->type()==type) count++;
                 }
                 return count;
             }
             int ChartDataSet::seriesIndex(QAbstractSeries *series)
             {
                 QMapIterator<int, QAbstractSeries*> i(m_indexSeriesMap);
                 while (i.hasNext()) {
                     i.next();
                     if (i.value() == series)
                         return i.key();
                 }
                 return -1;
             }
-            QChartAxis* ChartDataSet::axisY(QAbstractSeries *series) const
+            QAxis* ChartDataSet::axisY(QAbstractSeries *series) const
             {
                 if(series == 0) return m_axisY;
                 return m_seriesAxisMap.value(series);
             }
             Domain* ChartDataSet::domain(QAbstractSeries *series) const
             {
-            	QChartAxis* axis = m_seriesAxisMap.value(series);
+            	QAxis* axis = m_seriesAxisMap.value(series);
             	if(axis){
             		return m_axisDomainMap.value(axis);
             	}else
             		return 0;
             }
-            Domain* ChartDataSet::domain(QChartAxis* axis) const
+            Domain* ChartDataSet::domain(QAxis* axis) const
             {
                 if(!axis || axis==axisX()) {
                     return  m_axisDomainMap.value(axisY());
                 }
                 else {
                     return m_axisDomainMap.value(axis);
                 }
             }
             void ChartDataSet::scrollDomain(int dx,int dy,const QSizeF& size)
             {
-            	 QMapIterator<QChartAxis*, Domain*> i( m_axisDomainMap);
+            	 QMapIterator<QAxis*, Domain*> i( m_axisDomainMap);
             	 	while (i.hasNext()) {
             	        i.next();
             	        i.value()->move(dx,dy,size);
             	    }
             }
             #include "moc_chartdataset_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartdataset_p.h +13 -13

             /****************************************************************************
             **
             ** 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 CHARTDATASET_P_H
             #define CHARTDATASET_P_H
             #include "qabstractseries.h"
             #include "domain_p.h"
             #include <QVector>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class QChartAxis;
+            class QAxis;
             class QBarSeries;
             class ChartDataSet : public QObject
             {
                 Q_OBJECT
             public:
                 ChartDataSet(QObject* parent=0);
                 virtual ~ChartDataSet();
-                void addSeries(QAbstractSeries* series,QChartAxis *axisY = 0);
+                void addSeries(QAbstractSeries* series,QAxis *axisY = 0);
-                QChartAxis* removeSeries(QAbstractSeries* series);
+                QAxis* removeSeries(QAbstractSeries* series);
                 void removeAllSeries();
                 void zoomInDomain(const QRectF& rect, const QSizeF& size);
                 void zoomOutDomain(const QRectF& rect, const QSizeF& size);
                 void scrollDomain(int dx,int dy,const QSizeF& size);
                 int seriesCount(QAbstractSeries::QSeriesType type);
                 int seriesIndex(QAbstractSeries *series);
                 Domain* domain(QAbstractSeries* series) const;
-                Domain* domain(QChartAxis* axis) const;
+                Domain* domain(QAxis* axis) const;
-                QChartAxis* axisX() const { return m_axisX; }
+                QAxis* axisX() const { return m_axisX; }
-                QChartAxis* axisY(QAbstractSeries *series = 0) const;
+                QAxis* axisY(QAbstractSeries *series = 0) const;
             Q_SIGNALS:
                 void seriesAdded(QAbstractSeries* series, Domain* domain);
                 void seriesRemoved(QAbstractSeries* series);
-                void axisAdded(QChartAxis* axis,Domain* domain);
+                void axisAdded(QAxis* axis,Domain* domain);
-                void axisRemoved(QChartAxis* axis);
+                void axisRemoved(QAxis* axis);
             private:
-                QStringList createLabels(QChartAxis* axis,qreal min, qreal max);
+                QStringList createLabels(QAxis* axis,qreal min, qreal max);
                 void calculateDomain(QAbstractSeries* series,Domain* domain);
                 void setupCategories(QBarSeries* series);
             private:
-                QMap<QAbstractSeries *, QChartAxis *> m_seriesAxisMap;
+                QMap<QAbstractSeries *, QAxis *> m_seriesAxisMap;
-                QMap<QChartAxis*, Domain *> m_axisDomainMap;
+                QMap<QAxis*, Domain *> m_axisDomainMap;
                 QMap<int, QAbstractSeries *> m_indexSeriesMap;
-                QChartAxis* m_axisX;
+                QAxis* m_axisX;
-                QChartAxis* m_axisY;
+                QAxis* m_axisY;
                 int m_domainIndex;
                 bool m_axisXInitialized;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* CHARTENGINE_P_H_ */

src/chartpresenter.cpp +15 -14

             /****************************************************************************
              **
              ** 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 "qchartaxis.h"
+            #include "qaxis.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             #include "qabstractseries_p.h"
             #include "qareaseries.h"
-            #include "axis_p.h"
+            #include "chartaxis_p.h"
             #include "areachartitem_p.h"
+            #include "chartbackground_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartPresenter::ChartPresenter(QChart* chart,ChartDataSet* dataset):QObject(chart),
             m_chart(chart),
             m_animator(0),
             m_dataset(dataset),
             m_chartTheme(0),
             m_chartRect(QRectF(QPoint(0,0),m_chart->size())),
             m_options(QChart::NoAnimation),
             m_minLeftMargin(0),
             m_minBottomMargin(0),
             m_backgroundItem(0),
             m_titleItem(0),
             m_marginBig(60),
             m_marginSmall(20),
             m_marginTiny(10),
             m_chartMargins(QRect(m_marginBig,m_marginBig,0,0))
             {
             }
             ChartPresenter::~ChartPresenter()
             {
                 delete m_chartTheme;
             }
             void ChartPresenter::setGeometry(const QRectF& rect)
             {
                 m_rect = rect;
                 Q_ASSERT(m_rect.isValid());
                 updateLayout();
             }
-            void ChartPresenter::setMinimumMarginWidth(Axis* axis, qreal width)
+            void ChartPresenter::setMinimumMarginWidth(ChartAxis* axis, qreal width)
             {
                 switch(axis->axisType()){
-                case Axis::X_AXIS:
+                case ChartAxis::X_AXIS:
                 {
                     if(width>m_chartRect.width()+ m_chartMargins.left()) {
                         m_minLeftMargin= width - m_chartRect.width();
                         updateLayout();
                     }
                     break;
                 }
-                case Axis::Y_AXIS:
+                case ChartAxis::Y_AXIS:
                 {
                     if(m_minLeftMargin!=width){
                         m_minLeftMargin= width;
                         updateLayout();
                     }
                     break;
                 }
                 }
             }
-            void ChartPresenter::setMinimumMarginHeight(Axis* axis, qreal height)
+            void ChartPresenter::setMinimumMarginHeight(ChartAxis* axis, qreal height)
             {
                 switch(axis->axisType()){
-                case Axis::X_AXIS:
+                case ChartAxis::X_AXIS:
                 {
                     if(m_minBottomMargin!=height) {
                         m_minBottomMargin= height;
                         updateLayout();
                     }
                     break;
                 }
-                case Axis::Y_AXIS:
+                case ChartAxis::Y_AXIS:
                 {
                     if(height>m_chartMargins.bottom()+m_chartRect.height()){
                         m_minBottomMargin= height - m_chartRect.height();
                         updateLayout();
                     }
                     break;
                 }
                 }
             }
-            void ChartPresenter::handleAxisAdded(QChartAxis* axis,Domain* domain)
+            void ChartPresenter::handleAxisAdded(QAxis* axis,Domain* domain)
             {
-                Axis* item = new Axis(axis,this,axis==m_dataset->axisX()?Axis::X_AXIS : Axis::Y_AXIS);
+                ChartAxis* item = new ChartAxis(axis,this,axis==m_dataset->axisX()?ChartAxis::X_AXIS : ChartAxis::Y_AXIS);
                 if(m_options.testFlag(QChart::GridAxisAnimations)){
                     m_animator->addAnimation(item);
                 }
                 if(axis==m_dataset->axisX()){
                     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
                 item->handleGeometryChanged(m_chartRect);
                 m_axisItems.insert(axis, item);
             }
-            void ChartPresenter::handleAxisRemoved(QChartAxis* axis)
+            void ChartPresenter::handleAxisRemoved(QAxis* axis)
             {
-                Axis* item = m_axisItems.take(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);
                 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_chartRect.isValid()) item->handleGeometryChanged(m_chartRect);
                 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();
             }
             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()
             {
-                QList<QChartAxis *> axisList = m_axisItems.uniqueKeys();
+                QList<QAxis *> axisList = m_axisItems.uniqueKeys();
                 QList<QAbstractSeries *> seriesList = m_chartItems.uniqueKeys();
-                foreach(QChartAxis *axis, axisList) {
+                foreach(QAxis *axis, axisList) {
                     handleAxisRemoved(axis);
                     handleAxisAdded(axis,m_dataset->domain(axis));
                 }
                 foreach(QAbstractSeries *series, seriesList) {
                     handleSeriesRemoved(series);
                     handleSeriesAdded(series,m_dataset->domain(series));
                 }
             }
             void ChartPresenter::zoomIn()
             {
                 QRectF rect = chartGeometry();
                 rect.setWidth(rect.width()/2);
                 rect.setHeight(rect.height()/2);
                 rect.moveCenter(chartGeometry().center());
                 zoomIn(rect);
             }
             void ChartPresenter::zoomIn(const QRectF& rect)
             {
                 QRectF r = rect.normalized();
                 r.translate(-m_chartMargins.topLeft());
                 if(m_animator) {
                     QPointF point(r.center().x()/chartGeometry().width(),r.center().y()/chartGeometry().height());
                     m_animator->setState(ChartAnimator::ZoomInState,point);
                 }
                 m_dataset->zoomInDomain(r,chartGeometry().size());
                 if(m_animator) {
                     m_animator->setState(ChartAnimator::ShowState);
                 }
             }
             void ChartPresenter::zoomOut()
             {
                 if(m_animator)
                 {
                     m_animator->setState(ChartAnimator::ZoomOutState);
                 }
                 QSizeF size = chartGeometry().size();
                 QRectF rect = chartGeometry();
                 rect.translate(-m_chartMargins.topLeft());
                 m_dataset->zoomOutDomain(rect.adjusted(size.width()/4,size.height()/4,-size.width()/4,-size.height()/4),size);
                 //m_dataset->zoomOutDomain(m_zoomStack[m_zoomIndex-1],geometry().size());
                 if(m_animator){
                     m_animator->setState(ChartAnimator::ShowState);
                 }
             }
             void ChartPresenter::scroll(int dx,int dy)
             {
                 if(m_animator){
                     if(dx<0) m_animator->setState(ChartAnimator::ScrollLeftState,QPointF());
                     if(dx>0) m_animator->setState(ChartAnimator::ScrollRightState,QPointF());
                     if(dy<0) m_animator->setState(ChartAnimator::ScrollUpState,QPointF());
                     if(dy>0) m_animator->setState(ChartAnimator::ScrollDownState,QPointF());
                 }
                 m_dataset->scrollDomain(dx,dy,chartGeometry().size());
                 if(m_animator){
                     m_animator->setState(ChartAnimator::ShowState);
                 }
             }
             QChart::AnimationOptions ChartPresenter::animationOptions() const
             {
                 return m_options;
             }
             void ChartPresenter::updateLayout()
             {
                 if (!m_rect.isValid()) return;
                 // recalculate title size
                 QSize titleSize;
                 int titlePadding=0;
                 if (m_titleItem) {
                     titleSize= m_titleItem->boundingRect().size().toSize();
                 }
                 //defaults
                 m_chartMargins = QRect(QPoint(m_minLeftMargin>m_marginBig?m_minLeftMargin:m_marginBig,m_marginBig),QPoint(m_marginBig,m_minBottomMargin>m_marginBig?m_minBottomMargin:m_marginBig));
                 titlePadding = m_chartMargins.top()/2;
                 QLegend* legend = m_chart->d_ptr->m_legend;
                 // recalculate legend position
                 if (legend->isAttachedToChart() && legend->isEnabled()) {
                     QRect legendRect;
                     // Reserve some space for legend
                     switch (legend->alignment()) {
                     case QLegend::AlignmentTop: {
                         int ledgendSize = legend->minHeight();
                         int topPadding = 2*m_marginTiny + titleSize.height() + ledgendSize + m_marginTiny;
                         m_chartMargins = QRect(QPoint(m_chartMargins.left(),topPadding),QPoint(m_chartMargins.right(),m_chartMargins.bottom()));
                         m_legendMargins = QRect(QPoint(m_chartMargins.left(),topPadding - (ledgendSize + m_marginTiny)),QPoint(m_chartMargins.right(),m_rect.height()-topPadding + m_marginTiny));
                         titlePadding = m_marginTiny + m_marginTiny;
                         break;
                     }
                     case QLegend::AlignmentBottom: {
                         int ledgendSize = legend->minHeight();
                         int bottomPadding = m_marginTiny + m_marginSmall + ledgendSize + m_marginTiny + m_minBottomMargin;
                         m_chartMargins = QRect(QPoint(m_chartMargins.left(),m_chartMargins.top()),QPoint(m_chartMargins.right(),bottomPadding));
                         m_legendMargins = QRect(QPoint(m_chartMargins.left(),m_rect.height()-bottomPadding + m_marginTiny + m_minBottomMargin),QPoint(m_chartMargins.right(),m_marginTiny + m_marginSmall));
                         titlePadding = m_chartMargins.top()/2;
                         break;
                     }
                     case QLegend::AlignmentLeft: {
                         int ledgendSize = legend->minWidth();
                         int leftPadding = m_marginTiny + m_marginSmall + ledgendSize + m_marginTiny + m_minLeftMargin;
                         m_chartMargins = QRect(QPoint(leftPadding,m_chartMargins.top()),QPoint(m_chartMargins.right(),m_chartMargins.bottom()));
                         m_legendMargins = QRect(QPoint(m_marginTiny + m_marginSmall,m_chartMargins.top()),QPoint(m_rect.width()-leftPadding + m_marginTiny + m_minLeftMargin,m_chartMargins.bottom()));
                         titlePadding = m_chartMargins.top()/2;
                         break;
                     }
                     case QLegend::AlignmentRight: {
                         int ledgendSize = legend->minWidth();
                         int rightPadding = m_marginTiny + m_marginSmall + ledgendSize + m_marginTiny;
                         m_chartMargins = QRect(QPoint(m_chartMargins.left(),m_chartMargins.top()),QPoint(rightPadding,m_chartMargins.bottom()));
                         m_legendMargins = QRect(QPoint(m_rect.width()- rightPadding+ m_marginTiny ,m_chartMargins.top()),QPoint(m_marginTiny + m_marginSmall,m_chartMargins.bottom()));
                         titlePadding = m_chartMargins.top()/2;
                         break;
                     }
                     default: {
                         break;
                     }
                     }
                 }
                 if(m_rect.width()<2*(m_chartMargins.top()+m_chartMargins.bottom()) || m_rect.height()< 2*(m_chartMargins.top() + m_chartMargins.bottom()))
                 {
                     m_chart->setMinimumSize(2*(m_chartMargins.top()+m_chartMargins.bottom()),2*(m_chartMargins.top() + m_chartMargins.bottom()));
                     return;
                 }
                 // recalculate title position
                 if (m_titleItem) {
                     QPointF center = m_rect.center() -m_titleItem->boundingRect().center();
                     m_titleItem->setPos(center.x(),titlePadding);
                 }
                 //recalculate background gradient
                 if (m_backgroundItem) {
                     m_backgroundItem->setRect(m_rect.adjusted(m_marginTiny,m_marginTiny, -m_marginTiny, -m_marginTiny));
                 }
                 QRectF chartRect = m_rect.adjusted(m_chartMargins.left(),m_chartMargins.top(),-m_chartMargins.right(),-m_chartMargins.bottom());
                 legend->setGeometry(m_rect.adjusted(m_legendMargins.left(),m_legendMargins.top(),-m_legendMargins.right(),-m_legendMargins.bottom()));
                 if(m_chartRect!=chartRect){
                     m_chartRect=chartRect;
                     emit geometryChanged(m_chartRect);
                 }
             }
             void ChartPresenter::createChartBackgroundItem()
             {
                 if (!m_backgroundItem) {
                     m_backgroundItem = new ChartBackground(rootItem());
                     m_backgroundItem->setPen(Qt::NoPen);
                     m_backgroundItem->setZValue(ChartPresenter::BackgroundZValue);
                 }
             }
             void ChartPresenter::createChartTitleItem()
             {
                 if (!m_titleItem) {
                     m_titleItem = new QGraphicsSimpleTextItem(rootItem());
                     m_titleItem->setZValue(ChartPresenter::BackgroundZValue);
                 }
             }
             #include "moc_chartpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartpresenter_p.h +7 -8

             /****************************************************************************
             **
             ** 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$
             **
             ****************************************************************************/
             #ifndef CHARTPRESENTER_H
             #define CHARTPRESENTER_H
             #include "qchartglobal.h"
-            #include "chartbackground_p.h" //TODO fix me
             #include "qchart.h" //becouse of QChart::ChartThemeId //TODO
-            #include "qchartaxis.h"
             #include <QRectF>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class Chart;
             class QAbstractSeries;
             class ChartDataSet;
             class Domain;
-            class Axis;
+            class ChartAxis;
             class ChartTheme;
             class ChartAnimator;
+            class ChartBackground;
             class ChartPresenter: public QObject
             {
                 Q_OBJECT
             public:
                 enum ZValues {
                     BackgroundZValue = -1,
                     ShadesZValue,
                     GridZValue,
                     LineChartZValue,
                     BarSeriesZValue,
                     ScatterSeriesZValue,
                     PieSeriesZValue,
                     AxisZValue,
                     LegendZValue
                 };
                 ChartPresenter(QChart* chart,ChartDataSet *dataset);
                 virtual ~ChartPresenter();
                 ChartAnimator* animator() const { return m_animator; }
                 ChartTheme *chartTheme() const { return m_chartTheme; }
                 ChartDataSet *dataSet() const { return m_dataset; }
                 QGraphicsItem* rootItem() const { return m_chart; }
                 void setTheme(QChart::ChartTheme theme,bool force = true);
                 QChart::ChartTheme theme();
                 void setAnimationOptions(QChart::AnimationOptions options);
                 QChart::AnimationOptions animationOptions() const;
                 void zoomIn();
                 void zoomIn(const QRectF& rect);
                 void zoomOut();
                 void scroll(int dx,int dy);
                 void setGeometry(const QRectF& rect);
                 QRectF chartGeometry() const { return m_chartRect; }
-                void setMinimumMarginHeight(Axis* axis, qreal height);
+                void setMinimumMarginHeight(ChartAxis* axis, qreal height);
-                void setMinimumMarginWidth(Axis* axis, qreal width);
+                void setMinimumMarginWidth(ChartAxis* axis, qreal width);
                 qreal minimumLeftMargin() const { return m_minLeftMargin; }
                 qreal minimumBottomMargin() const { return m_minBottomMargin; }
             public: //TODO: fix me
                 void resetAllElements();
                 void createChartBackgroundItem();
                 void createChartTitleItem();
                 QRectF margins() const { return m_chartMargins;}
             public Q_SLOTS:
                 void handleSeriesAdded(QAbstractSeries* series,Domain* domain);
                 void handleSeriesRemoved(QAbstractSeries* series);
-                void handleAxisAdded(QChartAxis* axis,Domain* domain);
+                void handleAxisAdded(QAxis* axis,Domain* domain);
-                void handleAxisRemoved(QChartAxis* axis);
+                void handleAxisRemoved(QAxis* axis);
                 void updateLayout();
             Q_SIGNALS:
                 void geometryChanged(const QRectF& rect);
             private:
                 QChart* m_chart;
                 ChartAnimator* m_animator;
                 ChartDataSet* m_dataset;
                 ChartTheme *m_chartTheme;
                 QMap<QAbstractSeries *, Chart *> m_chartItems;
-                QMap<QChartAxis *, Axis *> m_axisItems;
+                QMap<QAxis *, ChartAxis *> m_axisItems;
                 QRectF m_rect;
                 QRectF m_chartRect;
                 QChart::AnimationOptions m_options;
                 qreal m_minLeftMargin;
                 qreal m_minBottomMargin;
             public: //TODO: fixme
                 ChartBackground* m_backgroundItem;
                 QGraphicsSimpleTextItem* m_titleItem;
                 int m_marginBig;
                 int m_marginSmall;
                 int m_marginTiny;
                 QRectF m_chartMargins;
                 QRectF m_legendMargins;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* CHARTPRESENTER_H_ */

src/charttheme.cpp +3 -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 "charttheme_p.h"
             #include "qchart.h"
             #include "qchart_p.h"
             #include "qchartview.h"
             #include "qlegend.h"
-            #include "qchartaxis.h"
+            #include "qaxis.h"
             #include <QTime>
             //series
             #include "qbarset.h"
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qlineseries.h"
             #include "qareaseries.h"
             #include "qscatterseries.h"
             #include "qpieseries.h"
             #include "qpieslice.h"
             #include "qsplineseries.h"
             //items
-            #include "axis_p.h"
+            #include "chartaxis_p.h"
             #include "barchartitem_p.h"
             #include "stackedbarchartitem_p.h"
             #include "percentbarchartitem_p.h"
             #include "linechartitem_p.h"
             #include "areachartitem_p.h"
             #include "scatterchartitem_p.h"
             #include "piechartitem_p.h"
             #include "splinechartitem_p.h"
             //themes
             #include "chartthemesystem_p.h"
             #include "chartthemelight_p.h"
             #include "chartthemebluecerulean_p.h"
             #include "chartthemedark_p.h"
             #include "chartthemebrownsand_p.h"
             #include "chartthemebluencs_p.h"
             #include "chartthemehighcontrast_p.h"
             #include "chartthemeblueicy_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartTheme::ChartTheme(QChart::ChartTheme id) :
                 m_masterFont(QFont("arial", 14)),
                 m_labelFont(QFont("arial", 10)),
                 m_titleBrush(QColor(QRgb(0x000000))),
                 m_axisLinePen(QPen(QRgb(0x000000))),
                 m_axisLabelBrush(QColor(QRgb(0x000000))),
                 m_backgroundShadesPen(Qt::NoPen),
                 m_backgroundShadesBrush(Qt::NoBrush),
                 m_backgroundShades(BackgroundShadesNone),
                 m_backgroundDropShadowEnabled(false),
                 m_gridLinePen(QPen(QRgb(0x000000))),
                 m_force(false)
             {
                 m_id = id;
                 qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));
             }
             ChartTheme* ChartTheme::createTheme(QChart::ChartTheme theme)
             {
                 switch(theme) {
                     case QChart::ChartThemeLight:
                         return new ChartThemeLight();
                     case QChart::ChartThemeBlueCerulean:
                         return new ChartThemeBlueCerulean();
                     case QChart::ChartThemeDark:
                         return new ChartThemeDark();
                     case QChart::ChartThemeBrownSand:
                         return new ChartThemeBrownSand();
                     case QChart::ChartThemeBlueNcs:
                         return new ChartThemeBlueNcs();
                     case QChart::ChartThemeHighContrast:
                         return new ChartThemeHighContrast();
                     case QChart::ChartThemeBlueIcy:
                         return new ChartThemeBlueIcy();
                     default:
                         return new ChartThemeSystem();
                 }
             }
             void ChartTheme::decorate(QChart *chart)
             {
                 QBrush brush;
                 if(brush == chart->backgroundBrush() ||  m_force)
                     chart->setBackgroundBrush(m_chartBackgroundGradient);
                 chart->setTitleFont(m_masterFont);
                 chart->setTitleBrush(m_titleBrush);
                 chart->setBackgroundDropShadowEnabled(m_backgroundDropShadowEnabled);
             }
             void ChartTheme::decorate(QLegend *legend)
             {
                 QPen pen;
                 QBrush brush;
                 if (pen == legend->pen() ||  m_force){
                     legend->setPen(Qt::NoPen);
                 }
                 if (brush == legend->brush() ||  m_force) {
                     legend->setBrush(m_chartBackgroundGradient);
                 }
             }
             void ChartTheme::decorate(QAreaSeries *series, int index)
             {
                 QPen pen;
                 QBrush brush;
                 if (pen == series->pen() ||  m_force){
                     pen.setColor(colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0.0));
                     pen.setWidthF(2);
                     series->setPen(pen);
                 }
                 if (brush == series->brush() ||  m_force) {
                    QBrush brush(m_seriesColors.at(index % m_seriesColors.size()));
                    series->setBrush(brush);
                 }
             }
             void ChartTheme::decorate(QLineSeries *series,int index)
             {
                 QPen pen;
                 if(pen == series->pen() ||  m_force ){
                     pen.setColor(m_seriesColors.at(index%m_seriesColors.size()));
                     pen.setWidthF(2);
                     series->setPen(pen);
                 }
             }
             void ChartTheme::decorate(QBarSeries *series, int index)
             {
                 QBrush brush;
                 QPen pen;
                 QList<QBarSet *> sets = series->barSets();
                 qreal takeAtPos = 0.5;
                 qreal step = 0.2;
                 if (sets.count() > 1 ) {
                     step = 1.0 / (qreal) sets.count();
                     if (sets.count() % m_seriesGradients.count())
                         step *= m_seriesGradients.count();
                     else
                         step *= (m_seriesGradients.count() - 1);
                 }
                 for (int i(0); i < sets.count(); i++) {
                     int colorIndex = (index + i) % m_seriesGradients.count();
                     if (i > 0 && i % m_seriesGradients.count() == 0) {
                         // There is no dedicated base color for each sets, generate more colors
                         takeAtPos += step;
                         if (takeAtPos == 1.0)
                             takeAtPos += step;
                         takeAtPos -= (int) takeAtPos;
                     }
                     if (brush == sets.at(i)->brush() ||  m_force )
                         sets.at(i)->setBrush(colorAt(m_seriesGradients.at(colorIndex), takeAtPos));
                     // Pick label color from the opposite end of the gradient.
                     // 0.3 as a boundary seems to work well.
                     if (takeAtPos < 0.3)
                         sets.at(i)->setLabelBrush(colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 1));
                     else
                         sets.at(i)->setLabelBrush(colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0));
                     if (pen == sets.at(i)->pen() ||  m_force) {
                         QColor c = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0.0);
                         sets.at(i)->setPen(c);
                     }
                 }
             }
             void ChartTheme::decorate(QScatterSeries *series, int index)
             {
                 QPen pen;
                 QBrush brush;
                 if (pen == series->pen() ||  m_force) {
                     pen.setColor(colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0.0));
                     pen.setWidthF(2);
                     series->setPen(pen);
                 }
                 if (brush == series->brush() ||  m_force) {
                     QBrush brush(m_seriesColors.at(index % m_seriesColors.size()));
                     series->setBrush(brush);
                 }
             }
             void ChartTheme::decorate(QPieSeries *series, int index)
             {
                 for (int i(0); i < series->slices().count(); i++) {
                     QColor penColor = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0.0);
                     // Get color for a slice from a gradient linearly, beginning from the start of the gradient
                     qreal pos = (qreal) (i + 1) / (qreal) series->count();
                     QColor brushColor = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), pos);
                     QPieSlice *s = series->slices().at(i);
                     PieSliceData data = PieSliceData::data(s);
                     if (data.m_slicePen.isThemed() ||  m_force) {
                         data.m_slicePen = penColor;
                         data.m_slicePen.setThemed(true);
                     }
                     if (data.m_sliceBrush.isThemed() ||  m_force) {
                         data.m_sliceBrush = brushColor;
                         data.m_sliceBrush.setThemed(true);
                     }
                     if (data.m_labelPen.isThemed() ||  m_force) {
                         data.m_labelPen = QPen(m_titleBrush.color());
                         data.m_labelPen.setThemed(true);
                     }
                     if (data.m_labelFont.isThemed() ||  m_force) {
                         data.m_labelFont = m_labelFont;
                         data.m_labelFont.setThemed(true);
                     }
                     if (PieSliceData::data(s) != data) {
                         PieSliceData::data(s) = data;
                         emit PieSliceData::data(s).emitChangedSignal(s);
                     }
                 }
             }
             void ChartTheme::decorate(QSplineSeries *series, int index)
             {
                 QPen pen;
                 if(pen == series->pen() ||  m_force){
                     pen.setColor(m_seriesColors.at(index%m_seriesColors.size()));
                     pen.setWidthF(2);
                     series->setPen(pen);
                 }
             }
-            void ChartTheme::decorate(QChartAxis *axis,bool axisX)
+            void ChartTheme::decorate(QAxis *axis,bool axisX)
             {
                 QPen pen;
                 QBrush brush;
                 QFont font;
                 if (axis->isAxisVisible()) {
                     if(brush == axis->labelsBrush() ||  m_force){
                         axis->setLabelsBrush(m_axisLabelBrush);
                     }
                     if(pen == axis->labelsPen() ||  m_force){
                         axis->setLabelsPen(Qt::NoPen); // NoPen for performance reasons
                     }
                    if (axis->shadesVisible() ||  m_force) {
                      if(brush == axis->shadesBrush() ||  m_force){
                          axis->setShadesBrush(m_backgroundShadesBrush);
                      }
                      if(pen == axis->shadesPen() ||  m_force){
                          axis->setShadesPen(m_backgroundShadesPen);
                      }
                      if( m_force && (m_backgroundShades == BackgroundShadesBoth
                                      || (m_backgroundShades == BackgroundShadesVertical && axisX)
                                      || (m_backgroundShades == BackgroundShadesHorizontal && !axisX))){
                          axis->setShadesVisible(true);
                      }
                    }
                     if(pen == axis->axisPen() ||  m_force){
                         axis->setAxisPen(m_axisLinePen);
                     }
                     if(pen == axis->gridLinePen() ||  m_force){
                         axis->setGridLinePen(m_gridLinePen);
                     }
                     if(font == axis->labelsFont() || m_force){
                         axis->setLabelsFont(m_labelFont);
                     }
                 }
             }
             void ChartTheme::generateSeriesGradients()
             {
                 // Generate gradients in HSV color space
                 foreach (const QColor& color, m_seriesColors) {
                     QLinearGradient g;
                     qreal h = color.hsvHueF();
                     qreal s = color.hsvSaturationF();
                     // TODO: tune the algorithm to give nice results with most base colors defined in
                     // most themes. The rest of the gradients we can define manually in theme specific
                     // implementation.
                     QColor start = color;
                     start.setHsvF(h, 0.0, 1.0);
                     g.setColorAt(0.0, start);
                     g.setColorAt(0.5, color);
                     QColor end = color;
                     end.setHsvF(h, s, 0.25);
                     g.setColorAt(1.0, end);
                     m_seriesGradients << g;
                 }
             }
             QColor ChartTheme::colorAt(const QColor &start, const QColor &end, qreal pos)
             {
                 Q_ASSERT(pos >= 0.0 && pos <= 1.0);
                 qreal r = start.redF() + ((end.redF() - start.redF()) * pos);
                 qreal g = start.greenF() + ((end.greenF() - start.greenF()) * pos);
                 qreal b = start.blueF() + ((end.blueF() - start.blueF()) * pos);
                 QColor c;
                 c.setRgbF(r, g, b);
                 return c;
             }
             QColor ChartTheme::colorAt(const QGradient &gradient, qreal pos)
             {
                 Q_ASSERT(pos >= 0 && pos <= 1.0);
                 // another possibility:
                 // http://stackoverflow.com/questions/3306786/get-intermediate-color-from-a-gradient
                 QGradientStops stops = gradient.stops();
                 int count = stops.count();
                 // find previous stop relative to position
                 QGradientStop prev = stops.first();
                 for (int i = 0; i < count; i++) {
                     QGradientStop stop = stops.at(i);
                     if (pos > stop.first)
                         prev = stop;
                     // given position is actually a stop position?
                     if (pos == stop.first) {
                         //qDebug() << "stop color" << pos;
                         return stop.second;
                     }
                 }
                 // find next stop relative to position
                 QGradientStop next = stops.last();
                 for (int i = count - 1; i >= 0; i--) {
                     QGradientStop stop = stops.at(i);
                     if (pos < stop.first)
                         next = stop;
                 }
                 //qDebug() << "prev" << prev.first << "pos" << pos << "next" << next.first;
                 qreal range = next.first - prev.first;
                 qreal posDelta = pos - prev.first;
                 qreal relativePos = posDelta / range;
                 //qDebug() << "range" << range << "posDelta" << posDelta << "relativePos" << relativePos;
                 return colorAt(prev.second, next.second, relativePos);
             }
             void ChartTheme::setForced(bool enabled)
             {
                 m_force=enabled;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/charttheme_p.h +1 -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$
             **
             ****************************************************************************/
             #ifndef CHARTTHEME_H
             #define CHARTTHEME_H
             #include "qchartglobal.h"
             #include "qchart.h"
             #include <QColor>
             #include <QGradientStops>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartItem;
             class LineChartItem;
             class QLineSeries;
             class BarChartItem;
             class QBarSeries;
             class StackedBarChartItem;
             class QStackedBarSeries;
             class QPercentBarSeries;
             class PercentBarChartItem;
             class QScatterSeries;
             class ScatterChartItem;
             class PieChartItem;
             class QPieSeries;
             class SplineChartItem;
             class QSplineSeries;
             class AreaChartItem;
             class QAreaSeries;
             class ChartTheme
             {
             public:
                 enum BackgroundShadesMode {
                     BackgroundShadesNone = 0,
                     BackgroundShadesVertical,
                     BackgroundShadesHorizontal,
                     BackgroundShadesBoth
                 };
             protected:
                 explicit ChartTheme(QChart::ChartTheme id = QChart::ChartThemeLight);
             public:
                 static ChartTheme *createTheme(QChart::ChartTheme theme);
                 QChart::ChartTheme id() const {return m_id;}
                 void decorate(QChart *chart);
                 void decorate(QLegend *legend);
                 void decorate(QBarSeries *series, int index);
                 void decorate(QLineSeries *series, int index);
                 void decorate(QAreaSeries *series, int index);
                 void decorate(QScatterSeries *series, int index);
                 void decorate(QPieSeries *series, int index);
                 void decorate(QSplineSeries *series, int index);
-                void decorate(QChartAxis *axis, bool axisX);
+                void decorate(QAxis *axis, bool axisX);
                 void setForced(bool enabled);
                 bool isForced() { return m_force; }
             public: // utils
                 void generateSeriesGradients();
                 static QColor colorAt(const QColor &start, const QColor &end, qreal pos);
                 static QColor colorAt(const QGradient &gradient, qreal pos);
             protected:
                 QChart::ChartTheme m_id;
                 QList<QColor> m_seriesColors;
                 QList<QGradient> m_seriesGradients;
                 QLinearGradient m_chartBackgroundGradient;
                 QFont m_masterFont;
                 QFont m_labelFont;
                 QBrush m_titleBrush;
                 QPen m_axisLinePen;
                 QBrush m_axisLabelBrush;
                 QPen m_backgroundShadesPen;
                 QBrush m_backgroundShadesBrush;
                 BackgroundShadesMode m_backgroundShades;
                 bool m_backgroundDropShadowEnabled;
                 QPen m_gridLinePen;
                 bool m_force;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // CHARTTHEME_H

src/qchart.cpp +7 -5

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qchart.h"
             #include "qchart_p.h"
             #include "legendscroller_p.h"
             #include "qlegend_p.h"
+            #include "chartbackground_p.h"
+            #include "qaxis.h"
             #include <QGraphicsScene>
             #include <QGraphicsSceneResizeEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
              \enum QChart::ChartTheme
              This enum describes the theme used by the chart.
              \value ChartThemeLight The default theme
              \value ChartThemeBlueCerulean
              \value ChartThemeDark
              \value ChartThemeBrownSand
              \value ChartThemeBlueNcs
              \value ChartThemeHighContrast
              \value ChartThemeBlueIcy
              */
             /*!
              \enum QChart::AnimationOption
              For enabling/disabling animations. Defaults to NoAnimation.
              \value NoAnimation
              \value GridAxisAnimations
              \value SeriesAnimations
              \value AllAnimations
              */
             /*!
              \class QChart
              \brief QtCommercial chart API.
              QChart is a QGraphicsWidget that you can show in a QGraphicsScene. It manages the graphical
              representation of different types of QChartSeries and other chart related objects like
              QChartAxis and QChartLegend. If you simply want to show a chart in a layout, you can use the
              convenience class QChartView instead of QChart.
              \sa QChartView
              */
             /*!
              Constructs a chart object which is a child of a\a parent. Parameter \a wFlags is passed to the QGraphicsWidget constructor.
              */
             QChart::QChart(QGraphicsItem *parent, Qt::WindowFlags wFlags) : QGraphicsWidget(parent,wFlags),
                 d_ptr(new QChartPrivate())
             {
                 d_ptr->m_dataset = new ChartDataSet(this);
                 d_ptr->m_presenter = new ChartPresenter(this,d_ptr->m_dataset);
                 d_ptr->createConnections();
                 d_ptr->m_legend = new LegendScroller(this);
                 d_ptr->m_presenter->setTheme(QChart::ChartThemeLight, false);
             }
             /*!
              Destroys the object and it's children, like QChartSeries and QChartAxis object added to it.
              */
             QChart::~QChart()
             {
                 //delete first presenter , since this is a root of all the graphical items
                 delete d_ptr->m_presenter;
                 d_ptr->m_presenter=0;
             }
             /*!
              Adds the \a series and optional \a axisY onto the chart and takes the ownership of the objects.
              If auto scaling is enabled, re-scales the axes the series is bound to (both the x axis and
              the y axis).
              */
-            void QChart::addSeries(QAbstractSeries *series, QChartAxis *axisY)
+            void QChart::addSeries(QAbstractSeries *series, QAxis *axisY)
             {
                 Q_ASSERT(series);
                 d_ptr->m_dataset->addSeries(series, axisY);
             }
             /*!
              Removes the \a series specified in a perameter from the QChartView.
              It releses its ownership of the specified QChartSeries object.
              It does not delete the pointed QChartSeries data object
              \sa addSeries(), removeAllSeries()
              */
             void QChart::removeSeries(QAbstractSeries *series)
             {
                 Q_ASSERT(series);
                 d_ptr->m_dataset->removeSeries(series);
             }
             /*!
              Removes all the QChartSeries that have been added to the QChartView
              It also deletes the pointed QChartSeries data objects
              \sa addSeries(), removeSeries()
              */
             void QChart::removeAllSeries()
             {
                 d_ptr->m_dataset->removeAllSeries();
             }
             /*!
              Sets the \a brush that is used for painting the background of the chart area.
              */
             void QChart::setBackgroundBrush(const QBrush& brush)
             {
                 //TODO: refactor me
                 d_ptr->m_presenter->createChartBackgroundItem();
                 d_ptr->m_presenter->m_backgroundItem->setBrush(brush);
                 d_ptr->m_presenter->m_backgroundItem->update();
             }
             /*!
                 Gets the brush that is used for painting the background of the chart area.
              */
             QBrush QChart::backgroundBrush() const
             {
                 //TODO: refactor me
                 if (!d_ptr->m_presenter->m_backgroundItem) return QBrush();
                 return (d_ptr->m_presenter->m_backgroundItem)->brush();
             }
             /*!
              Sets the \a pen that is used for painting the background of the chart area.
              */
             void QChart::setBackgroundPen(const QPen& pen)
             {
                 //TODO: refactor me
                 d_ptr->m_presenter->createChartBackgroundItem();
                 d_ptr->m_presenter->m_backgroundItem->setPen(pen);
                 d_ptr->m_presenter->m_backgroundItem->update();
             }
             /*!
                 Gets the pen that is used for painting the background of the chart area.
              */
             QPen QChart::backgroundPen() const
             {
                 //TODO: refactor me
                 if (!d_ptr->m_presenter->m_backgroundItem) return QPen();
                 return d_ptr->m_presenter->m_backgroundItem->pen();
             }
             /*!
              Sets the chart \a title. The description text that is drawn above the chart.
              */
             void QChart::setTitle(const QString& title)
             {
                 //TODO: refactor me
                 d_ptr->m_presenter->createChartTitleItem();
                 d_ptr->m_presenter->m_titleItem->setText(title);
                 d_ptr->m_presenter->updateLayout();
             }
             /*!
              Returns the chart title. The description text that is drawn above the chart.
              */
             QString QChart::title() const
             {
                 //TODO: refactor me
                 if (d_ptr->m_presenter->m_titleItem)
                     return d_ptr->m_presenter->m_titleItem->text();
                 else
                     return QString();
             }
             /*!
              Sets the \a font that is used for drawing the chart description text that is rendered above the chart.
              */
             void QChart::setTitleFont(const QFont& font)
             {
                 //TODO: refactor me
                 d_ptr->m_presenter->createChartTitleItem();
                 d_ptr->m_presenter->m_titleItem->setFont(font);
                 d_ptr->m_presenter->updateLayout();
             }
             /*!
                 Gets the font that is used for drawing the chart description text that is rendered above the chart.
              */
             QFont QChart::titleFont() const
             {
                 if (d_ptr->m_presenter->m_titleItem)
                     return d_ptr->m_presenter->m_titleItem->font();
                 else
                     return QFont();
             }
             /*!
              Sets the \a brush used for rendering the title text.
              */
             void QChart::setTitleBrush(const QBrush &brush)
             {
                 //TODO: refactor me
                 d_ptr->m_presenter->createChartTitleItem();
                 d_ptr->m_presenter->m_titleItem->setBrush(brush);
                 d_ptr->m_presenter->updateLayout();
             }
             /*!
              Returns the brush used for rendering the title text.
              */
             QBrush QChart::titleBrush() const
             {
                 //TODO: refactor me
                 if (!d_ptr->m_presenter->m_titleItem) return QBrush();
                 return d_ptr->m_presenter->m_titleItem->brush();
             }
             /*!
              Sets the \a theme used by the chart for rendering the graphical representation of the data
              \sa theme()
              */
             void QChart::setTheme(QChart::ChartTheme theme)
             {
                 d_ptr->m_presenter->setTheme(theme);
             }
             /*!
              Returns the theme enum used by the chart.
              \sa ChartTheme, setTheme()
              */
             QChart::ChartTheme QChart::theme() const
             {
                 return d_ptr->m_presenter->theme();
             }
             /*!
              Zooms in the view by a factor of 2
              */
             void QChart::zoomIn()
             {
                 d_ptr->m_presenter->zoomIn();
             }
             /*!
              Zooms in the view to a maximum level at which \a rect is still fully visible.
              */
             void QChart::zoomIn(const QRectF& rect)
             {
                 if (!rect.isValid()) return;
                 d_ptr->m_presenter->zoomIn(rect);
             }
             /*!
              Restores the view zoom level to the previous one.
              */
             void QChart::zoomOut()
             {
                 d_ptr->m_presenter->zoomOut();
             }
             /*!
              Returns the pointer to the x axis object of the chart
              */
-            QChartAxis* QChart::axisX() const
+            QAxis* QChart::axisX() const
             {
                 return d_ptr->m_dataset->axisX();
             }
             /*!
              Returns the pointer to the y axis object of the \a series
              If no \a series is provided then default Y axis of the chart is returned.
              */
-            QChartAxis* QChart::axisY(QAbstractSeries *series) const
+            QAxis* QChart::axisY(QAbstractSeries *series) const
             {
                 return d_ptr->m_dataset->axisY(series);
             }
             /*!
              Returns the legend object of the chart. Ownership stays in chart.
              */
             QLegend* QChart::legend() const
             {
                 return d_ptr->m_legend;
             }
             /*!
                 Returns the rect that contains information about margins (distance between chart widget edge and axes).
                 Individual margins can be obtained by calling left, top, right, bottom on the returned rect.
              */
             QRectF QChart::margins() const
             {
                 return d_ptr->m_presenter->margins();
             }
             /*!
              Resizes and updates the chart area using the \a event data
              */
             void QChart::resizeEvent(QGraphicsSceneResizeEvent *event)
             {
                 d_ptr->m_rect = QRectF(QPoint(0,0),event->newSize());
                 QGraphicsWidget::resizeEvent(event);
                 d_ptr->m_presenter->setGeometry(d_ptr->m_rect);
             }
             /*!
              Sets animation \a options for the chart
              */
             void QChart::setAnimationOptions(AnimationOptions options)
             {
                 d_ptr->m_presenter->setAnimationOptions(options);
             }
             /*!
              Returns animation options for the chart
              */
             QChart::AnimationOptions QChart::animationOptions() const
             {
                 return d_ptr->m_presenter->animationOptions();
             }
             /*!
                 Scrolls the visible area of the chart to the left by the distance between two x axis ticks
              */
             void QChart::scrollLeft()
             {
                 d_ptr->m_presenter->scroll(-d_ptr->m_presenter->chartGeometry().width()/(axisX()->ticksCount()-1),0);
             }
             /*!
                 Scrolls the visible area of the chart to the right by the distance between two x axis ticks
              */
             void QChart::scrollRight()
             {
                 d_ptr->m_presenter->scroll(d_ptr->m_presenter->chartGeometry().width()/(axisX()->ticksCount()-1),0);
             }
             /*!
                 Scrolls the visible area of the chart up by the distance between two y axis ticks
              */
             void QChart::scrollUp()
             {
                 d_ptr->m_presenter->scroll(0,d_ptr->m_presenter->chartGeometry().width()/(axisY()->ticksCount()-1));
             }
             /*!
                 Scrolls the visible area of the chart down by the distance between two y axis ticks
              */
             void QChart::scrollDown()
             {
                 d_ptr->m_presenter->scroll(0,-d_ptr->m_presenter->chartGeometry().width()/(axisY()->ticksCount()-1));
             }
             /*!
                 Sets the chart background visibility state to \a visible
              */
             void QChart::setBackgroundVisible(bool visible)
             {
                 //TODO: refactor me
                 d_ptr->m_presenter->createChartBackgroundItem();
                 d_ptr->m_presenter->m_backgroundItem->setVisible(visible);
             }
             /*!
                 Returns the chart's background visibility state
              */
             bool QChart::isBackgroundVisible() const
             {
                 //TODO: refactor me
                 if (!d_ptr->m_presenter->m_backgroundItem)
                     return false;
                 return d_ptr->m_presenter->m_backgroundItem->isVisible();
             }
             /*!
                 Sets the background drop shadow effect state to \a enabled.
             */
             void QChart::setBackgroundDropShadowEnabled(bool enabled)
             {
                 d_ptr->m_presenter->createChartBackgroundItem();
                 d_ptr->m_presenter->m_backgroundItem->setDropShadowEnabled(enabled);
             }
             /*!
                 Returns true if the drop shadow effect is enabled for the chart background.
             */
             bool QChart::isBackgroundDropShadowEnabled() const
             {
                 if (!d_ptr->m_presenter->m_backgroundItem)
                     return false;
                 return d_ptr->m_presenter->m_backgroundItem->isDropShadowEnabled();
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QChartPrivate::QChartPrivate():
                 m_legend(0),
                 m_dataset(0),
                 m_presenter(0)
             {
             }
             QChartPrivate::~QChartPrivate()
             {
             }
             void QChartPrivate::createConnections()
             {
                 QObject::connect(m_dataset,SIGNAL(seriesAdded(QAbstractSeries *, Domain *)),m_presenter,SLOT(handleSeriesAdded(QAbstractSeries *, Domain *)));
                 QObject::connect(m_dataset,SIGNAL(seriesRemoved(QAbstractSeries *)),m_presenter,SLOT(handleSeriesRemoved(QAbstractSeries *)));
-                QObject::connect(m_dataset,SIGNAL(axisAdded(QChartAxis*,Domain*)),m_presenter,SLOT(handleAxisAdded(QChartAxis*,Domain*)));
+                QObject::connect(m_dataset,SIGNAL(axisAdded(QAxis*,Domain*)),m_presenter,SLOT(handleAxisAdded(QAxis*,Domain*)));
-                QObject::connect(m_dataset,SIGNAL(axisRemoved(QChartAxis*)),m_presenter,SLOT(handleAxisRemoved(QChartAxis*)));
+                QObject::connect(m_dataset,SIGNAL(axisRemoved(QAxis*)),m_presenter,SLOT(handleAxisRemoved(QAxis*)));
             }
             #include "moc_qchart.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchart.h +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$
             **
             ****************************************************************************/
             #ifndef QCHART_H
             #define QCHART_H
             #include <QAbstractSeries>
             #include <QLegend>
             #include <QGraphicsWidget>
             class QGraphicsSceneResizeEvent;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QAbstractSeries;
-            class QChartAxis;
+            class QAxis;
             class QLegend;
             struct QChartPrivate;
             class QTCOMMERCIALCHART_EXPORT QChart : public QGraphicsWidget
             {
                 Q_OBJECT
                 Q_ENUMS(ChartTheme)
             public:
                 enum ChartTheme {
                     ChartThemeLight = 0,
                     ChartThemeBlueCerulean,
                     ChartThemeDark,
                     ChartThemeBrownSand,
                     ChartThemeBlueNcs,
                     ChartThemeHighContrast,
                     ChartThemeBlueIcy
                 };
                 enum AnimationOption {
                     NoAnimation = 0x0,
                     GridAxisAnimations = 0x1,
                     SeriesAnimations =0x2,
                     AllAnimations = 0x3
                 };
                 Q_DECLARE_FLAGS(AnimationOptions, AnimationOption)
             public:
                 explicit QChart(QGraphicsItem *parent = 0, Qt::WindowFlags wFlags = 0);
                 ~QChart();
-                void addSeries(QAbstractSeries *series, QChartAxis *axisY = 0);
+                void addSeries(QAbstractSeries *series, QAxis *axisY = 0);
                 void removeSeries(QAbstractSeries *series);
                 void removeAllSeries();
                 void setTheme(QChart::ChartTheme theme);
                 QChart::ChartTheme theme() const;
                 void setTitle(const QString& title);
                 QString title() const;
                 void setTitleFont(const QFont& font);
                 QFont titleFont() const;
                 void setTitleBrush(const QBrush &brush);
                 QBrush titleBrush() const;
                 void setBackgroundBrush(const QBrush &brush);
                 QBrush backgroundBrush() const;
                 void setBackgroundPen(const QPen &pen);
                 QPen backgroundPen() const;
                 void setBackgroundVisible(bool visible = true);
                 bool isBackgroundVisible() const;
                 void setBackgroundDropShadowEnabled(bool enabled = true);
                 bool isBackgroundDropShadowEnabled() const;
                 void setAnimationOptions(AnimationOptions options);
                 AnimationOptions animationOptions() const;
                 void zoomIn();
                 void zoomIn(const QRectF &rect);
                 void zoomOut();
                 void scrollLeft();
                 void scrollRight();
                 void scrollUp();
                 void scrollDown();
-                QChartAxis* axisX() const;
+                QAxis* axisX() const;
-                QChartAxis* axisY(QAbstractSeries* series = 0) const;
+                QAxis* axisY(QAbstractSeries* series = 0) const;
                 QLegend* legend() const;
                 QRectF margins() const;
             protected:
                 void resizeEvent(QGraphicsSceneResizeEvent *event);
             protected:
                 QScopedPointer<QChartPrivate> d_ptr;
                 friend class QLegend;
                 friend class ChartPresenter;
                 Q_DISABLE_COPY(QChart)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             Q_DECLARE_OPERATORS_FOR_FLAGS(QTCOMMERCIALCHART_NAMESPACE::QChart::AnimationOptions)
             #endif

src/qchartview.h +1 -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$
             **
             ****************************************************************************/
             #ifndef QCHARTVIEW_H
             #define QCHARTVIEW_H
-            #include <QChartAxis>
+            #include <QAxis>
             #include <QAbstractSeries>
             #include <QChart>
             #include <QGraphicsView>
             class QGraphicsScene;
             class QRubberBand;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             struct QChartViewPrivate;
             class QTCOMMERCIALCHART_EXPORT QChartView : public QGraphicsView
             {
                 Q_OBJECT
             public:
                 enum  RubberBand{
                     NoRubberBand = 0x0,
                     VerticalRubberBand = 0x1,
                     HorizonalRubberBand = 0x2,
                     RectangleRubberBand = 0x3
                 };
                 Q_DECLARE_FLAGS(RubberBands, RubberBand)
                 explicit QChartView(QChart *chart,QWidget *parent = 0);
                 ~QChartView();
                 void setRubberBand(const RubberBands& rubberBands);
                 RubberBands rubberBand() const;
                 QChart* chart() const;
             protected:
                 void resizeEvent(QResizeEvent *event);
                 void mousePressEvent(QMouseEvent *event);
                 void mouseMoveEvent(QMouseEvent *event);
                 void mouseReleaseEvent(QMouseEvent *event);
             protected:
                 QScopedPointer<QChartViewPrivate> d_ptr;
                 Q_DISABLE_COPY(QChartView)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QCHARTWIDGET_H

test/auto/chartdataset/tst_chartdataset.cpp +59 -59

             /****************************************************************************
             **
             ** 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 <QtTest/QtTest>
-            #include <qchartaxis.h>
+            #include <qaxis.h>
             #include <qlineseries.h>
             #include <private/chartdataset_p.h>
             #include <private/domain_p.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             Q_DECLARE_METATYPE(Domain *)
-            Q_DECLARE_METATYPE(QChartAxis *)
+            Q_DECLARE_METATYPE(QAxis *)
             Q_DECLARE_METATYPE(QAbstractSeries *)
             Q_DECLARE_METATYPE(QLineSeries *)
             class tst_ChartDataSet: public QObject {
                 Q_OBJECT
             public Q_SLOTS:
             	void initTestCase();
             	void cleanupTestCase();
             	void init();
             	void cleanup();
             private Q_SLOTS:
             	void chartdataset_data();
             	void chartdataset();
             	void addSeries_data();
             	void addSeries();
             	void removeSeries_data();
             	void removeSeries();
             	void removeAllSeries_data();
             	void removeAllSeries();
             	void axisY_data();
             	void axisY();
                 void seriesCount_data();
             	void seriesCount();
                 void seriesIndex_data();
             	void seriesIndex();
             	void domain_data();
             	void domain();
                 void zoomInDomain_data();
             	void zoomInDomain();
                 void zoomOutDomain_data();
                 void zoomOutDomain();
                 void scrollDomain_data();
                 void scrollDomain();
             };
             void tst_ChartDataSet::initTestCase()
             {
                 qRegisterMetaType<Domain*>();
-            	qRegisterMetaType<QChartAxis*>();
+            	qRegisterMetaType<QAxis*>();
                 qRegisterMetaType<QAbstractSeries*>();
             }
             void tst_ChartDataSet::cleanupTestCase()
             {
             }
             void tst_ChartDataSet::init()
             {
             }
             void tst_ChartDataSet::cleanup()
             {
             }
             void tst_ChartDataSet::chartdataset_data()
             {
             }
             void tst_ChartDataSet::chartdataset()
             {
             	ChartDataSet dataSet;
             	QVERIFY2(dataSet.axisX(), "Missing axisX.");
             	QVERIFY2(dataSet.axisY(), "Missing axisY.");
             	//check if not dangling pointer
             	dataSet.axisX()->objectName();
             	dataSet.axisY()->objectName();
             	QLineSeries* series = new QLineSeries(this);
             	QCOMPARE(dataSet.seriesIndex(series),-1);
             }
             void tst_ChartDataSet::addSeries_data()
             {
             	QTest::addColumn<QLineSeries*>("series0");
-                QTest::addColumn<QChartAxis*>("axis0");
+                QTest::addColumn<QAxis*>("axis0");
                 QTest::addColumn<QLineSeries*>("series1");
-                QTest::addColumn<QChartAxis*>("axis1");
+                QTest::addColumn<QAxis*>("axis1");
                 QTest::addColumn<QLineSeries*>("series2");
-                QTest::addColumn<QChartAxis*>("axis2");
+                QTest::addColumn<QAxis*>("axis2");
                 QTest::addColumn<int>("axisCount");
                 QLineSeries* series0 = new QLineSeries(this);
                 QLineSeries* series1 = new QLineSeries(this);
                 QLineSeries* series2 = new QLineSeries(this);
-                QChartAxis* axis0 = new QChartAxis(this);
+                QAxis* axis0 = new QAxis(this);
-                QChartAxis* axis1 = new QChartAxis(this);
+                QAxis* axis1 = new QAxis(this);
-                QChartAxis* axis2 = new QChartAxis(this);
+                QAxis* axis2 = new QAxis(this);
-            	QTest::newRow("default axis Y: series0,series1,series2") << series0 << (QChartAxis*)0 << series1 << (QChartAxis*)0  << series2 << (QChartAxis*)0 << 2;
+            	QTest::newRow("default axis Y: series0,series1,series2") << series0 << (QAxis*)0 << series1 << (QAxis*)0  << series2 << (QAxis*)0 << 2;
-            	QTest::newRow("default axis Y: series0, axis 0: series1,series2") << series0 << (QChartAxis*)0 << series1 << axis0 << series2 << axis0 << 3;
+            	QTest::newRow("default axis Y: series0, axis 0: series1,series2") << series0 << (QAxis*)0 << series1 << axis0 << series2 << axis0 << 3;
             	QTest::newRow("axis0: series0, axis1: series1, axis2: series2") << series0 << axis0 << series1 << axis1 << series2 << axis2 << 4;
             }
             void tst_ChartDataSet::addSeries()
             {
                 QFETCH(QLineSeries*, series0);
-                QFETCH(QChartAxis*, axis0);
+                QFETCH(QAxis*, axis0);
                 QFETCH(QLineSeries*, series1);
-                QFETCH(QChartAxis*, axis1);
+                QFETCH(QAxis*, axis1);
                 QFETCH(QLineSeries*, series2);
-                QFETCH(QChartAxis*, axis2);
+                QFETCH(QAxis*, axis2);
                 QFETCH(int, axisCount);
                 ChartDataSet dataSet;
-                QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis*,Domain*)));
+                QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QAxis*,Domain*)));
-                QSignalSpy spy1(&dataSet, SIGNAL(axisRemoved(QChartAxis*)));
+                QSignalSpy spy1(&dataSet, SIGNAL(axisRemoved(QAxis*)));
                 QSignalSpy spy2(&dataSet, SIGNAL(seriesAdded(QAbstractSeries *,Domain*)));
                 QSignalSpy spy3(&dataSet, SIGNAL(seriesRemoved(QAbstractSeries *)));
                 dataSet.addSeries(series0,axis0);
                 dataSet.addSeries(series1,axis1);
                 dataSet.addSeries(series2,axis2);
                 QCOMPARE(spy0.count(), axisCount);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 3);
                 QCOMPARE(spy3.count(), 0);
                 if(axis0==0) axis0 = dataSet.axisY();
                 if(axis1==0) axis1 = dataSet.axisY();
                 if(axis2==0) axis2 = dataSet.axisY();
                 QVERIFY(axis0 == dataSet.removeSeries(series0));
                 QVERIFY(axis1 == dataSet.removeSeries(series1));
                 QVERIFY(axis2 == dataSet.removeSeries(series2));
             }
             void tst_ChartDataSet::removeSeries_data()
             {
                 addSeries_data();
             }
             void tst_ChartDataSet::removeSeries()
             {
                 QFETCH(QLineSeries*, series0);
-                QFETCH(QChartAxis*, axis0);
+                QFETCH(QAxis*, axis0);
                 QFETCH(QLineSeries*, series1);
-                QFETCH(QChartAxis*, axis1);
+                QFETCH(QAxis*, axis1);
                 QFETCH(QLineSeries*, series2);
-                QFETCH(QChartAxis*, axis2);
+                QFETCH(QAxis*, axis2);
                 QFETCH(int, axisCount);
                 ChartDataSet dataSet;
                 dataSet.addSeries(series0,axis0);
                 dataSet.addSeries(series1,axis1);
                 dataSet.addSeries(series2,axis2);
-                QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis *, Domain *)));
+                QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QAxis *, Domain *)));
-                QSignalSpy spy1(&dataSet, SIGNAL(axisRemoved(QChartAxis *)));
+                QSignalSpy spy1(&dataSet, SIGNAL(axisRemoved(QAxis *)));
                 QSignalSpy spy2(&dataSet, SIGNAL(seriesAdded(QAbstractSeries *, Domain *)));
                 QSignalSpy spy3(&dataSet, SIGNAL(seriesRemoved(QAbstractSeries *)));
                 dataSet.removeSeries(series0);
                 dataSet.removeSeries(series1);
                 dataSet.removeSeries(series2);
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), axisCount);
                 QCOMPARE(spy2.count(), 0);
                 QCOMPARE(spy3.count(), 3);
             }
             void tst_ChartDataSet::removeAllSeries_data()
             {
             }
             void tst_ChartDataSet::removeAllSeries()
             {
                 QLineSeries* series0 = new QLineSeries(this);
                 QLineSeries* series1 = new QLineSeries(this);
                 QLineSeries* series2 = new QLineSeries(this);
-                QChartAxis* axis0 = new QChartAxis(this);
+                QAxis* axis0 = new QAxis(this);
-                QChartAxis* axis1 = new QChartAxis(this);
+                QAxis* axis1 = new QAxis(this);
-                QChartAxis* axis2 = new QChartAxis(this);
+                QAxis* axis2 = new QAxis(this);
                 ChartDataSet dataSet;
                 dataSet.addSeries(series0, axis0);
                 dataSet.addSeries(series1, axis1);
                 dataSet.addSeries(series2, axis2);
-                QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis *, Domain *)));
+                QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QAxis *, Domain *)));
-                QSignalSpy spy1(&dataSet, SIGNAL(axisRemoved(QChartAxis *)));
+                QSignalSpy spy1(&dataSet, SIGNAL(axisRemoved(QAxis *)));
                 QSignalSpy spy2(&dataSet, SIGNAL(seriesAdded(QAbstractSeries *, Domain *)));
                 QSignalSpy spy3(&dataSet, SIGNAL(seriesRemoved(QAbstractSeries *)));
                 dataSet.removeAllSeries();
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 4);
                 QCOMPARE(spy2.count(), 0);
                 QCOMPARE(spy3.count(), 3);
             }
             void tst_ChartDataSet::axisY_data()
             {
-                QTest::addColumn<QChartAxis*>("axis0");
+                QTest::addColumn<QAxis*>("axis0");
-                QTest::addColumn<QChartAxis*>("axis1");
+                QTest::addColumn<QAxis*>("axis1");
-                QTest::addColumn<QChartAxis*>("axis2");
+                QTest::addColumn<QAxis*>("axis2");
-                QTest::newRow("1 defualt, 2 optional") << (QChartAxis*)0 << new QChartAxis() << new QChartAxis();
+                QTest::newRow("1 defualt, 2 optional") << (QAxis*)0 << new QAxis() << new QAxis();
-                QTest::newRow("3 optional") << new QChartAxis() << new QChartAxis() << new QChartAxis();
+                QTest::newRow("3 optional") << new QAxis() << new QAxis() << new QAxis();
             }
             void tst_ChartDataSet::axisY()
             {
-                QFETCH(QChartAxis*, axis0);
+                QFETCH(QAxis*, axis0);
-                QFETCH(QChartAxis*, axis1);
+                QFETCH(QAxis*, axis1);
-                QFETCH(QChartAxis*, axis2);
+                QFETCH(QAxis*, axis2);
                 ChartDataSet dataSet;
-                QChartAxis* defaultAxisY = dataSet.axisY();
+                QAxis* defaultAxisY = dataSet.axisY();
                 QVERIFY2(defaultAxisY, "Missing axisY.");
                 QLineSeries* series0 = new QLineSeries();
                 dataSet.addSeries(series0,axis0);
                 QLineSeries* series1 = new QLineSeries();
                 dataSet.addSeries(series1,axis1);
                 QLineSeries* series2 = new QLineSeries();
                 dataSet.addSeries(series2,axis2);
                 if(!axis0) axis0=defaultAxisY ;
                 if(!axis1) axis1=defaultAxisY ;
                 if(!axis2) axis2=defaultAxisY ;
                 QVERIFY(dataSet.axisY(series0) == axis0);
                 QVERIFY(dataSet.axisY(series1) == axis1);
                 QVERIFY(dataSet.axisY(series2) == axis2);
             }
             void tst_ChartDataSet::seriesCount_data()
             {
                 addSeries_data();
             }
             void tst_ChartDataSet::seriesCount()
             {
                 QFETCH(QLineSeries*, series0);
-                QFETCH(QChartAxis*, axis0);
+                QFETCH(QAxis*, axis0);
                 QFETCH(QLineSeries*, series1);
-                QFETCH(QChartAxis*, axis1);
+                QFETCH(QAxis*, axis1);
                 QFETCH(QLineSeries*, series2);
-                QFETCH(QChartAxis*, axis2);
+                QFETCH(QAxis*, axis2);
                 QFETCH(int, axisCount);
                 Q_UNUSED(axisCount);
                 ChartDataSet dataSet;
                 dataSet.addSeries(series0, axis0);
                 dataSet.addSeries(series1, axis1);
                 dataSet.addSeries(series2, axis2);
-                QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis *, Domain *)));
+                QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QAxis *, Domain *)));
-                QSignalSpy spy1(&dataSet, SIGNAL(axisRemoved(QChartAxis *)));
+                QSignalSpy spy1(&dataSet, SIGNAL(axisRemoved(QAxis *)));
                 QSignalSpy spy2(&dataSet, SIGNAL(seriesAdded(QAbstractSeries *, Domain *)));
                 QSignalSpy spy3(&dataSet, SIGNAL(seriesRemoved(QAbstractSeries *)));
                 QCOMPARE(dataSet.seriesCount(series0->type()),3);
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
                 QCOMPARE(spy3.count(), 0);
                 dataSet.removeSeries(series0);
                 dataSet.removeSeries(series1);
                 dataSet.removeSeries(series2);
             }
             void tst_ChartDataSet::seriesIndex_data()
             {
                 addSeries_data();
             }
             void tst_ChartDataSet::seriesIndex()
             {
                 //TODO: rewrite this series_index_data to match better
                 QFETCH(QLineSeries*, series0);
-                QFETCH(QChartAxis*, axis0);
+                QFETCH(QAxis*, axis0);
                 QFETCH(QLineSeries*, series1);
-                QFETCH(QChartAxis*, axis1);
+                QFETCH(QAxis*, axis1);
                 QFETCH(QLineSeries*, series2);
-                QFETCH(QChartAxis*, axis2);
+                QFETCH(QAxis*, axis2);
                 QFETCH(int, axisCount);
                 Q_UNUSED(axisCount);
                 ChartDataSet dataSet;
                 dataSet.addSeries(series0, axis0);
                 dataSet.addSeries(series1, axis1);
                 dataSet.addSeries(series2, axis2);
-                QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis*,Domain*)));
+                QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QAxis*,Domain*)));
-                QSignalSpy spy1(&dataSet, SIGNAL(axisRemoved(QChartAxis*)));
+                QSignalSpy spy1(&dataSet, SIGNAL(axisRemoved(QAxis*)));
                 QSignalSpy spy2(&dataSet, SIGNAL(seriesAdded(QSeries*,Domain*)));
                 QSignalSpy spy3(&dataSet, SIGNAL(seriesRemoved(QSeries*)));
                 QCOMPARE(dataSet.seriesIndex(series0),0);
                 QCOMPARE(dataSet.seriesIndex(series1),1);
                 QCOMPARE(dataSet.seriesIndex(series2),2);
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
                 QCOMPARE(spy3.count(), 0);
                 dataSet.removeSeries(series0);
                 dataSet.removeSeries(series1);
                 dataSet.removeSeries(series2);
                 QCOMPARE(dataSet.seriesIndex(series0),-1);
                 QCOMPARE(dataSet.seriesIndex(series1),-1);
                 QCOMPARE(dataSet.seriesIndex(series2),-1);
                 dataSet.addSeries(series0, axis0);
                 dataSet.addSeries(series1, axis1);
                 dataSet.addSeries(series2, axis2);
                 QCOMPARE(dataSet.seriesIndex(series0),0);
                 QCOMPARE(dataSet.seriesIndex(series1),1);
                 QCOMPARE(dataSet.seriesIndex(series2),2);
                 dataSet.removeSeries(series1);
                 QCOMPARE(dataSet.seriesIndex(series0),0);
                 QCOMPARE(dataSet.seriesIndex(series1),-1);
                 QCOMPARE(dataSet.seriesIndex(series2),2);
                 dataSet.addSeries(series1, axis1);
                 QCOMPARE(dataSet.seriesIndex(series0),0);
                 QCOMPARE(dataSet.seriesIndex(series1),1);
                 QCOMPARE(dataSet.seriesIndex(series2),2);
                 dataSet.removeSeries(series2);
                 QCOMPARE(dataSet.seriesIndex(series0),0);
                 QCOMPARE(dataSet.seriesIndex(series1),1);
                 QCOMPARE(dataSet.seriesIndex(series2),-1);
                 dataSet.removeSeries(series0);
                 QCOMPARE(dataSet.seriesIndex(series0),-1);
                 QCOMPARE(dataSet.seriesIndex(series1),1);
                 QCOMPARE(dataSet.seriesIndex(series2),-1);
                 dataSet.addSeries(series2);
                 QCOMPARE(dataSet.seriesIndex(series0),-1);
                 QCOMPARE(dataSet.seriesIndex(series1),1);
                 QCOMPARE(dataSet.seriesIndex(series2),0);
                 dataSet.addSeries(series0);
                 QCOMPARE(dataSet.seriesIndex(series0),2);
                 QCOMPARE(dataSet.seriesIndex(series1),1);
                 QCOMPARE(dataSet.seriesIndex(series2),0);
                 dataSet.removeSeries(series0);
                 dataSet.removeSeries(series1);
                 dataSet.removeSeries(series2);
             }
             void tst_ChartDataSet::domain_data()
             {
                 addSeries_data();
             }
             void tst_ChartDataSet::domain()
             {
                 QFETCH(QLineSeries*, series0);
-                QFETCH(QChartAxis*, axis0);
+                QFETCH(QAxis*, axis0);
                 QFETCH(QLineSeries*, series1);
-                QFETCH(QChartAxis*, axis1);
+                QFETCH(QAxis*, axis1);
                 QFETCH(QLineSeries*, series2);
-                QFETCH(QChartAxis*, axis2);
+                QFETCH(QAxis*, axis2);
                 QFETCH(int, axisCount);
                 Q_UNUSED(axisCount);
                 ChartDataSet dataSet;
                 dataSet.addSeries(series0, axis0);
                 dataSet.addSeries(series1, axis1);
                 dataSet.addSeries(series2, axis2);
-                QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QChartAxis *, Domain *)));
+                QSignalSpy spy0(&dataSet, SIGNAL(axisAdded(QAxis *, Domain *)));
-                QSignalSpy spy1(&dataSet, SIGNAL(axisRemoved(QChartAxis *)));
+                QSignalSpy spy1(&dataSet, SIGNAL(axisRemoved(QAxis *)));
                 QSignalSpy spy2(&dataSet, SIGNAL(seriesAdded(QAbstractSeries *, Domain *)));
                 QSignalSpy spy3(&dataSet, SIGNAL(seriesRemoved(QAbstractSeries *)));
                 QVERIFY(dataSet.domain(axis0)==dataSet.domain(series0));
                 QVERIFY(dataSet.domain(axis1)==dataSet.domain(series1));
                 QVERIFY(dataSet.domain(axis2)==dataSet.domain(series2));
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
                 QCOMPARE(spy3.count(), 0);
                 dataSet.removeSeries(series0);
                 dataSet.removeSeries(series1);
                 dataSet.removeSeries(series2);
             }
             void tst_ChartDataSet::zoomInDomain_data()
             {
                 addSeries_data();
             }
             void tst_ChartDataSet::zoomInDomain()
             {
                 QFETCH(QLineSeries*, series0);
-                QFETCH(QChartAxis*, axis0);
+                QFETCH(QAxis*, axis0);
                 QFETCH(QLineSeries*, series1);
-                QFETCH(QChartAxis*, axis1);
+                QFETCH(QAxis*, axis1);
                 QFETCH(QLineSeries*, series2);
-                QFETCH(QChartAxis*, axis2);
+                QFETCH(QAxis*, axis2);
                 QFETCH(int, axisCount);
                 Q_UNUSED(axisCount);
                 ChartDataSet dataSet;
                 dataSet.addSeries(series0, axis0);
                 dataSet.addSeries(series1, axis1);
                 dataSet.addSeries(series2, axis2);
                 Domain* domain0 = dataSet.domain(series0);
                 Domain* domain1 = dataSet.domain(series1);
                 Domain* domain2 = dataSet.domain(series2);
                 QSignalSpy spy0(domain0, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
                 QSignalSpy spy1(domain1, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
                 QSignalSpy spy2(domain2, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
                 dataSet.zoomInDomain(QRect(0,0,100,100),QSize(1000,1000));
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 1);
                 QCOMPARE(spy2.count(), 1);
                 dataSet.removeSeries(series0);
                 dataSet.removeSeries(series1);
                 dataSet.removeSeries(series2);
             }
             void tst_ChartDataSet::zoomOutDomain_data()
             {
                 addSeries_data();
             }
             void tst_ChartDataSet::zoomOutDomain()
             {
                 QFETCH(QLineSeries*, series0);
-                QFETCH(QChartAxis*, axis0);
+                QFETCH(QAxis*, axis0);
                 QFETCH(QLineSeries*, series1);
-                QFETCH(QChartAxis*, axis1);
+                QFETCH(QAxis*, axis1);
                 QFETCH(QLineSeries*, series2);
-                QFETCH(QChartAxis*, axis2);
+                QFETCH(QAxis*, axis2);
                 QFETCH(int, axisCount);
                 Q_UNUSED(axisCount);
                 ChartDataSet dataSet;
                 dataSet.addSeries(series0, axis0);
                 dataSet.addSeries(series1, axis1);
                 dataSet.addSeries(series2, axis2);
                 Domain* domain0 = dataSet.domain(series0);
                 Domain* domain1 = dataSet.domain(series1);
                 Domain* domain2 = dataSet.domain(series2);
                 QSignalSpy spy0(domain0, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
                 QSignalSpy spy1(domain1, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
                 QSignalSpy spy2(domain2, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
                 dataSet.zoomOutDomain(QRect(0,0,100,100),QSize(1000,1000));
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 1);
                 QCOMPARE(spy2.count(), 1);
                 dataSet.removeSeries(series0);
                 dataSet.removeSeries(series1);
                 dataSet.removeSeries(series2);
             }
             void tst_ChartDataSet::scrollDomain_data()
             {
                 addSeries_data();
             }
             void tst_ChartDataSet::scrollDomain()
             {
                 QFETCH(QLineSeries*, series0);
-                QFETCH(QChartAxis*, axis0);
+                QFETCH(QAxis*, axis0);
                 QFETCH(QLineSeries*, series1);
-                QFETCH(QChartAxis*, axis1);
+                QFETCH(QAxis*, axis1);
                 QFETCH(QLineSeries*, series2);
-                QFETCH(QChartAxis*, axis2);
+                QFETCH(QAxis*, axis2);
                 QFETCH(int, axisCount);
                 Q_UNUSED(axisCount);
                 ChartDataSet dataSet;
                 dataSet.addSeries(series0, axis0);
                 dataSet.addSeries(series1, axis1);
                 dataSet.addSeries(series2, axis2);
                 Domain* domain0 = dataSet.domain(series0);
                 Domain* domain1 = dataSet.domain(series1);
                 Domain* domain2 = dataSet.domain(series2);
                 QSignalSpy spy0(domain0, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
                 QSignalSpy spy1(domain1, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
                 QSignalSpy spy2(domain2, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
                 dataSet.scrollDomain(10,10,QSize(1000,1000));
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 1);
                 QCOMPARE(spy2.count(), 1);
                 dataSet.removeSeries(series0);
                 dataSet.removeSeries(series1);
                 dataSet.removeSeries(series2);
             }
             QTEST_MAIN(tst_ChartDataSet)
             #include "tst_chartdataset.moc"

test/auto/domain/tst_domain.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include <QtTest/QtTest>
             #include <private/domain_p.h>
-            #include <qchartaxis.h>
+            #include <qaxis.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             Q_DECLARE_METATYPE(Domain*)
             Q_DECLARE_METATYPE(QSizeF)
             class tst_Domain: public QObject
             {
             Q_OBJECT
             public Q_SLOTS:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private Q_SLOTS:
                 void domain();
                 void handleAxisRangeXChanged_data();
                 void handleAxisRangeXChanged();
                 void handleAxisRangeYChanged_data();
                 void handleAxisRangeYChanged();
                 void isEmpty_data();
                 void isEmpty();
                 void maxX_data();
                 void maxX();
                 void maxY_data();
                 void maxY();
                 void minX_data();
                 void minX();
                 void minY_data();
                 void minY();
                 void operatorEquals_data();
                 void operatorEquals();
                 void setRange_data();
                 void setRange();
                 void setRangeX_data();
                 void setRangeX();
                 void setRangeY_data();
                 void setRangeY();
                 void spanX_data();
                 void spanX();
                 void spanY_data();
                 void spanY();
                 void zoom_data();
                 void zoom();
                 void move_data();
                 void move();
                 void handleAxisXChanged_data();
                 void handleAxisXChanged();
                 void handleAxisYChanged_data();
                 void handleAxisYChanged();
             };
             void tst_Domain::initTestCase()
             {
             }
             void tst_Domain::cleanupTestCase()
             {
             }
             void tst_Domain::init()
             {
             }
             void tst_Domain::cleanup()
             {
             }
             void tst_Domain::domain()
             {
                 Domain domain;
                 QCOMPARE(domain.isEmpty(), true);
                 QCOMPARE(domain.maxX(), 0.0);
                 QCOMPARE(domain.maxY(), 0.0);
                 QCOMPARE(domain.minX(), 0.0);
                 QCOMPARE(domain.minY(), 0.0);
             }
             void tst_Domain::handleAxisRangeXChanged_data()
             {
                 QTest::addColumn<qreal>("min");
                 QTest::addColumn<qreal>("max");
                 QTest::newRow("-1 1") << -1.0 << 1.0;
                 QTest::newRow("0 1") << 0.0 << 1.0;
                 QTest::newRow("-1 0") << -1.0 << 0.0;
             }
             void tst_Domain::handleAxisRangeXChanged()
             {
                 QFETCH(qreal, min);
                 QFETCH(qreal, max);
                 Domain domain;
                 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
                 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal,int)));
                 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal,int)));
                 domain.handleAxisXChanged(min, max);
                 QList<QVariant> arg0 = spy0.first();
                 QVERIFY(qFuzzyIsNull(arg0.at(0).toReal() - min));
                 QVERIFY(qFuzzyIsNull(arg0.at(1).toReal() - max));
                 QList<QVariant> arg1 = spy1.first();
                 QVERIFY(qFuzzyIsNull(arg1.at(0).toReal() - min));
                 QVERIFY(qFuzzyIsNull(arg1.at(1).toReal() - max));
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 1);
                 QCOMPARE(spy2.count(), 0);
             }
             void tst_Domain::handleAxisRangeYChanged_data()
             {
                 QTest::addColumn<qreal>("min");
                 QTest::addColumn<qreal>("max");
                 QTest::newRow("-1 1") << -1.0 << 1.0;
                 QTest::newRow("0 1") << 0.0 << 1.0;
                 QTest::newRow("-1 0") << -1.0 << 0.0;
             }
             void tst_Domain::handleAxisRangeYChanged()
             {
                 QFETCH(qreal, min);
                 QFETCH(qreal, max);
                 Domain domain;
                 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
                 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal,int)));
                 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal,int)));
                 domain.handleAxisYChanged(min, max, 5);
                 QList<QVariant> arg0 = spy0.first();
                 QVERIFY(qFuzzyIsNull(arg0.at(2).toReal() - min));
                 QVERIFY(qFuzzyIsNull(arg0.at(3).toReal() - max));
                 QList<QVariant> arg1 = spy2.first();
                 QVERIFY(qFuzzyIsNull(arg1.at(0).toReal() - min));
                 QVERIFY(qFuzzyIsNull(arg1.at(1).toReal() - max));
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 1);
             }
             void tst_Domain::isEmpty_data()
             {
                 QTest::addColumn<qreal>("minX");
                 QTest::addColumn<qreal>("maxX");
                 QTest::addColumn<qreal>("minY");
                 QTest::addColumn<qreal>("maxY");
                 QTest::addColumn<bool>("isEmpty");
                 QTest::newRow("0 0 0 0") << 0.0 << 0.0 << 0.0 << 0.0 << true;
                 QTest::newRow("0 1 0 0") << 0.0 << 1.0 << 0.0 << 0.0 << true;
                 QTest::newRow("0 0 0 1") << 0.0 << 1.0 << 0.0 << 0.0 << true;
                 QTest::newRow("0 1 0 1") << 0.0 << 1.0 << 0.0 << 1.0 << false;
             }
             void tst_Domain::isEmpty()
             {
                 QFETCH(qreal, minX);
                 QFETCH(qreal, maxX);
                 QFETCH(qreal, minY);
                 QFETCH(qreal, maxY);
                 QFETCH(bool, isEmpty);
                 Domain domain;
                 domain.setRange(minX, maxX, minY, maxY);
                 QCOMPARE(domain.isEmpty(), isEmpty);
             }
             void tst_Domain::maxX_data()
             {
                 QTest::addColumn<qreal>("maxX1");
                 QTest::addColumn<qreal>("maxX2");
                 QTest::addColumn<int>("count");
                 QTest::newRow("1") << 0.0 << 1.0 << 1;
                 QTest::newRow("1.0") << 1.0 << 1.0 << 1;
                 QTest::newRow("2.0") << 1.0 << 0.0 << 2;
             }
             void tst_Domain::maxX()
             {
                 QFETCH(qreal, maxX1);
                 QFETCH(qreal, maxX2);
                 QFETCH(int, count);
                 Domain domain;
                 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
                 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal,int)));
                 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal,int)));
                 domain.setMaxX(maxX1);
                 QCOMPARE(domain.maxX(), maxX1);
                 domain.setMaxX(maxX2);
                 QCOMPARE(domain.maxX(), maxX2);
                 QCOMPARE(spy0.count(), count);
                 QCOMPARE(spy1.count(), count);
                 QCOMPARE(spy2.count(), 0);
             }
             void tst_Domain::maxY_data()
             {
                 QTest::addColumn<qreal>("maxY1");
                 QTest::addColumn<qreal>("maxY2");
                 QTest::addColumn<int>("count");
                 QTest::newRow("1") << 0.0 << 1.0 << 1;
                 QTest::newRow("1.0") << 1.0 << 1.0 << 1;
                 QTest::newRow("2.0") << 1.0 << 0.0 << 2;
             }
             void tst_Domain::maxY()
             {
                 QFETCH(qreal, maxY1);
                 QFETCH(qreal, maxY2);
                 QFETCH(int, count);
                 Domain domain;
                 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
                 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal,int)));
                 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal,int)));
                 domain.setMaxY(maxY1);
                 QCOMPARE(domain.maxY(), maxY1);
                 domain.setMaxY(maxY2);
                 QCOMPARE(domain.maxY(), maxY2);
                 QCOMPARE(spy0.count(), count);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), count);
             }
             void tst_Domain::minX_data()
             {
                 QTest::addColumn<qreal>("minX1");
                 QTest::addColumn<qreal>("minX2");
                 QTest::addColumn<int>("count");
                 QTest::newRow("1") << 0.0 << 1.0 << 1;
                 QTest::newRow("1.0") << 1.0 << 1.0 << 1;
                 QTest::newRow("2.0") << 1.0 << 0.0 << 2;
             }
             void tst_Domain::minX()
             {
                 QFETCH(qreal, minX1);
                 QFETCH(qreal, minX2);
                 QFETCH(int, count);
                 Domain domain;
                 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
                 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal,int)));
                 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal,int)));
                 domain.setMinX(minX1);
                 QCOMPARE(domain.minX(), minX1);
                 domain.setMinX(minX2);
                 QCOMPARE(domain.minX(), minX2);
                 QCOMPARE(spy0.count(), count);
                 QCOMPARE(spy1.count(), count);
                 QCOMPARE(spy2.count(), 0);
             }
             void tst_Domain::minY_data()
             {
                 QTest::addColumn<qreal>("minY1");
                 QTest::addColumn<qreal>("minY2");
                 QTest::addColumn<int>("count");
                 QTest::newRow("1") << 0.0 << 1.0 << 1;
                 QTest::newRow("1.0") << 1.0 << 1.0 << 1;
                 QTest::newRow("2.0") << 1.0 << 0.0 << 2;
             }
             void tst_Domain::minY()
             {
                 QFETCH(qreal, minY1);
                 QFETCH(qreal, minY2);
                 QFETCH(int, count);
                 Domain domain;
                 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
                 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal,int)));
                 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal,int)));
                 domain.setMinY(minY1);
                 QCOMPARE(domain.minY(), minY1);
                 domain.setMinY(minY2);
                 QCOMPARE(domain.minY(), minY2);
                 QCOMPARE(spy0.count(), count);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), count);
             }
             void tst_Domain::operatorEquals_data()
             {
                 QTest::addColumn<Domain*>("domain1");
                 QTest::addColumn<Domain*>("domain2");
                 QTest::addColumn<bool>("equals");
                 QTest::addColumn<bool>("notEquals");
                 Domain* a;
                 Domain* b;
                 a = new Domain();
                 a->setRange(0, 100, 0, 100);
                 b = new Domain();
                 b->setRange(0, 100, 0, 100);
                 QTest::newRow("equals") << a << b << true << false;
                 a = new Domain();
                 a->setRange(0, 100, 0, 100);
                 b = new Domain();
                 b->setRange(0, 100, 0, 1);
                 QTest::newRow("equals") << a << b << false << true;
                 a = new Domain();
                 a->setRange(0, 100, 0, 100);
                 b = new Domain();
                 b->setRange(0, 1, 0, 100);
                 QTest::newRow("equals") << a << b << false << true;
             }
             void tst_Domain::operatorEquals()
             {
                 QFETCH(Domain*, domain1);
                 QFETCH(Domain*, domain2);
                 QFETCH(bool, equals);
                 QFETCH(bool, notEquals);
                 Domain domain;
                 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
                 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal,int)));
                 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal,int)));
                 QCOMPARE(*domain1==*domain2, equals);
                 QCOMPARE(*domain1!=*domain2, notEquals);
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
             }
             void tst_Domain::setRange_data()
             {
                 QTest::addColumn<qreal>("minX");
                 QTest::addColumn<qreal>("maxX");
                 QTest::addColumn<qreal>("minY");
                 QTest::addColumn<qreal>("maxY");
                 QTest::newRow("1,2,1,2") << 1.0 << 2.0 << 1.0 << 2.0;
                 QTest::newRow("1,3,1,3") << 1.0 << 3.0 << 1.0 << 3.0;
                 QTest::newRow("-1,5,-2,-1") << -1.0 << 5.0 << -2.0 << -1.0;
             }
             void tst_Domain::setRange()
             {
                 QFETCH(qreal, minX);
                 QFETCH(qreal, maxX);
                 QFETCH(qreal, minY);
                 QFETCH(qreal, maxY);
                 Domain domain;
                 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
                 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal,int)));
                 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal,int)));
                 domain.setRange(minX, maxX, minY, maxY);
                 QCOMPARE(domain.minX(), minX);
                 QCOMPARE(domain.maxX(), maxX);
                 QCOMPARE(domain.minY(), minY);
                 QCOMPARE(domain.maxY(), maxY);
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 1);
                 QCOMPARE(spy2.count(), 1);
             }
             void tst_Domain::setRangeX_data()
             {
                 QTest::addColumn<qreal>("min");
                 QTest::addColumn<qreal>("max");
                 QTest::newRow("-1 1") << -1.0 << 1.0;
                 QTest::newRow("0 1") << 0.0 << 1.0;
                 QTest::newRow("-1 0") << -1.0 << 0.0;
             }
             void tst_Domain::setRangeX()
             {
                 QFETCH(qreal, min);
                 QFETCH(qreal, max);
                 Domain domain;
                 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
                 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal,int)));
                 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal,int)));
                 domain.setRangeX(min, max);
                 QList<QVariant> arg0 = spy0.first();
                 QVERIFY(qFuzzyIsNull(arg0.at(0).toReal() - min));
                 QVERIFY(qFuzzyIsNull(arg0.at(1).toReal() - max));
                 QList<QVariant> arg1 = spy1.first();
                 QVERIFY(qFuzzyIsNull(arg1.at(0).toReal() - min));
                 QVERIFY(qFuzzyIsNull(arg1.at(1).toReal() - max));
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 1);
                 QCOMPARE(spy2.count(), 0);
             }
             void tst_Domain::setRangeY_data()
             {
                 QTest::addColumn<qreal>("min");
                 QTest::addColumn<qreal>("max");
                 QTest::newRow("-1 1") << -1.0 << 1.0;
                 QTest::newRow("0 1") << 0.0 << 1.0;
                 QTest::newRow("-1 0") << -1.0 << 0.0;
             }
             void tst_Domain::setRangeY()
             {
                 QFETCH(qreal, min);
                 QFETCH(qreal, max);
                 Domain domain;
                 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
                 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal,int)));
                 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal,int)));
                 domain.setRangeY(min, max);
                 QList<QVariant> arg0 = spy0.first();
                 QVERIFY(qFuzzyIsNull(arg0.at(2).toReal() - min));
                 QVERIFY(qFuzzyIsNull(arg0.at(3).toReal() - max));
                 QList<QVariant> arg1 = spy2.first();
                 QVERIFY(qFuzzyIsNull(arg1.at(0).toReal() - min));
                 QVERIFY(qFuzzyIsNull(arg1.at(1).toReal() - max));
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 1);
             }
             void tst_Domain::spanX_data()
             {
                 QTest::addColumn<qreal>("minX");
                 QTest::addColumn<qreal>("maxX");
                 QTest::addColumn<qreal>("spanX");
                 QTest::newRow("1 2 1") << 1.0 << 2.0 << 1.0;
                 QTest::newRow("0 2 2") << 1.0 << 2.0 << 1.0;
             }
             void tst_Domain::spanX()
             {
                 QFETCH(qreal, minX);
                 QFETCH(qreal, maxX);
                 QFETCH(qreal, spanX);
                 Domain domain;
                 domain.setRangeX(minX, maxX);
                 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
                 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal,int)));
                 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal,int)));
                 QCOMPARE(domain.spanX(), spanX);
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
             }
             void tst_Domain::spanY_data()
             {
                 QTest::addColumn<qreal>("minY");
                 QTest::addColumn<qreal>("maxY");
                 QTest::addColumn<qreal>("spanY");
                 QTest::newRow("1 2 1") << 1.0 << 2.0 << 1.0;
                 QTest::newRow("0 2 2") << 1.0 << 2.0 << 1.0;
             }
             void tst_Domain::spanY()
             {
                 QFETCH(qreal, minY);
                 QFETCH(qreal, maxY);
                 QFETCH(qreal, spanY);
                 Domain domain;
                 domain.setRangeY(minY, maxY);
                 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
                 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal,int)));
                 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal,int)));
                 QCOMPARE(domain.spanY(), spanY);
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 0);
             }
             void tst_Domain::zoom_data()
             {
                 QTest::addColumn<QRectF>("rect0");
                 QTest::addColumn<QSizeF>("size0");
                 QTest::addColumn<QRectF>("rect1");
                 QTest::addColumn<QSizeF>("size1");
                 QTest::addColumn<QRectF>("rect2");
                 QTest::addColumn<QSizeF>("size2");
                 QTest::newRow("first") << QRectF(10, 10, 100, 100) << QSizeF(1000, 1000)
                     << QRectF(20, 20, 100, 100) << QSizeF(1000, 1000) << QRectF(50, 50, 100, 100)
                     << QSizeF(1000, 1000);
                 QTest::newRow("scound") << QRectF(10, 10, 50, 50) << QSizeF(1000, 1000)
                     << QRectF(20, 20, 100, 100) << QSizeF(1000, 1000) << QRectF(50, 50, 100, 100)
                     << QSizeF(1000, 1000);
                 QTest::newRow("third") << QRectF(10, 10, 10, 10) << QSizeF(100, 100) << QRectF(20, 20, 20, 20)
                     << QSizeF(100, 100) << QRectF(50, 50, 50, 50) << QSizeF(100, 100);
             }
             void tst_Domain::zoom()
             {
                 QFETCH(QRectF, rect0);
                 QFETCH(QSizeF, size0);
                 QFETCH(QRectF, rect1);
                 QFETCH(QSizeF, size1);
                 QFETCH(QRectF, rect2);
                 QFETCH(QSizeF, size2);
                 Domain domain;
                 domain.setRange(0, 1000, 0, 1000);
                 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
                 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal,int)));
                 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal,int)));
                 Domain domain0;
                 domain0.setRange(domain.minX(), domain.maxX(), domain.minY(), domain.maxY());
                 domain.zoomIn(rect0, size0);
                 Domain domain1;
                 domain1.setRange(domain.minX(), domain.maxX(), domain.minY(), domain.maxY());
                 domain.zoomIn(rect1, size1);
                 Domain domain2;
                 domain2.setRange(domain.minX(), domain.maxX(), domain.minY(), domain.maxY());
                 domain.zoomIn(rect2, size2);
                 domain.zoomOut(rect2, size2);
                 QCOMPARE(domain == domain2, true);
                 domain.zoomOut(rect1, size1);
                 QCOMPARE(domain == domain1, true);
                 domain.zoomOut(rect0, size0);
                 QCOMPARE(domain == domain0, true);
                 QCOMPARE(spy0.count(), 6);
                 QCOMPARE(spy1.count(), 6);
                 QCOMPARE(spy2.count(), 6);
             }
             void tst_Domain::move_data()
             {
                 QTest::addColumn<int>("dx");
                 QTest::addColumn<int>("dy");
                 QTest::addColumn<QSizeF>("size");
                 QTest::newRow("dx 100, dy 0, size 1000x1000") << 100 << 0 << QSizeF(1000, 1000);
                 QTest::newRow("dx 0,  dy 100, size 1000x1000") << 0 << 100 << QSizeF(1000, 1000);
                 QTest::newRow("dx -100, dy 0, size 1000x1000") << -100 << 0 << QSizeF(1000, 1000);
                 QTest::newRow("dx 0, dy -100, size 1000x1000") << 0 << -100 << QSizeF(1000, 1000);
                 QTest::newRow("dx 100, dy 100, size 1000x1000") << 100 << 100 << QSizeF(1000, 1000);
                 QTest::newRow("dx 100, dy 50, size 1000x1000") << 100 << 50 << QSizeF(1000, 1000);
             }
             void tst_Domain::move()
             {
                 QFETCH(int, dx);
                 QFETCH(int, dy);
                 QFETCH(QSizeF, size);
                 Domain domain;
                 domain.setRange(0, size.width(), 0, size.height());
                 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
                 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal,int)));
                 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal,int)));
                 domain.move(dx, dy, size);
                 Domain result;
                 result.setRange(dx, size.width() + dx, dy, size.height() + dy);
                 QCOMPARE(domain == result, true);
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), dx!=0?1:0);
                 QCOMPARE(spy2.count(), dy!=0?1:0);
             }
             void tst_Domain::handleAxisXChanged_data()
             {
                 QTest::addColumn<qreal>("min");
                 QTest::addColumn<qreal>("max");
                 QTest::addColumn<int>("tickCount");
                 QTest::addColumn<bool>("niceNumbers");
                 QTest::addColumn<qreal>("resultMin");
                 QTest::addColumn<qreal>("resultMax");
                 QTest::addColumn<int>("resultTickCount");
                 QTest::newRow("0,100,5,false") << 0.0 << 100.0 << 5 << false << 0.0 << 100.0 << 5;
                 QTest::newRow("0,100,5,true") << 0.0 << 100.0 << 5 << true << 0.0 << 100.0 << 6;
                 QTest::newRow("0.1,99,5,true") << 0.1 << 99.0 << 5 << true << 0.0 << 100.0 << 6;
                 QTest::newRow("5,93.5,true") << 5.0 << 93.5 << 5 << true << 0.0 << 100.0 << 6;
             }
             void tst_Domain::handleAxisXChanged()
             {
                 QFETCH(qreal, min);
                 QFETCH(qreal, max);
                 QFETCH(int, tickCount);
                 QFETCH(bool, niceNumbers);
                 QFETCH(qreal, resultMin);
                 QFETCH(qreal, resultMax);
                 QFETCH(int, resultTickCount);
                 Domain domain;
                 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
                 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal,int)));
                 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal,int)));
                 domain.handleAxisXChanged(min, max, tickCount, niceNumbers);
                 QCOMPARE(resultMin, domain.minX());
                 QCOMPARE(resultMax, domain.maxX());
                 QCOMPARE(resultTickCount, domain.tickXCount());
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 1);
                 QCOMPARE(spy2.count(), 0);
             }
             void tst_Domain::handleAxisYChanged_data()
             {
                 handleAxisXChanged_data();
             }
             void tst_Domain::handleAxisYChanged()
             {
                 QFETCH(qreal, min);
                 QFETCH(qreal, max);
                 QFETCH(int, tickCount);
                 QFETCH(bool, niceNumbers);
                 QFETCH(qreal, resultMin);
                 QFETCH(qreal, resultMax);
                 QFETCH(int, resultTickCount);
                 Domain domain;
                 QSignalSpy spy0(&domain, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)));
                 QSignalSpy spy1(&domain, SIGNAL(rangeXChanged(qreal,qreal,int)));
                 QSignalSpy spy2(&domain, SIGNAL(rangeYChanged(qreal,qreal,int)));
                 domain.handleAxisYChanged(min, max, tickCount, niceNumbers);
                 QCOMPARE(resultMin, domain.minY());
                 QCOMPARE(resultMax, domain.maxY());
                 QCOMPARE(resultTickCount, domain.tickYCount());
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 0);
                 QCOMPARE(spy2.count(), 1);
             }
             QTEST_MAIN(tst_Domain)
             #include "tst_domain.moc"

test/auto/qchart/tst_qchart.cpp +23 -23

             #include <QtTest/QtTest>
             #include <qchartview.h>
             #include <qlineseries.h>
             #include <qareaseries.h>
             #include <qscatterseries.h>
             #include <qsplineseries.h>
             #include <qpieseries.h>
             #include <qbarseries.h>
             #include <qpercentbarseries.h>
             #include <qstackedbarseries.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
-            Q_DECLARE_METATYPE(QChartAxis *)
+            Q_DECLARE_METATYPE(QAxis *)
             Q_DECLARE_METATYPE(QAbstractSeries *)
             Q_DECLARE_METATYPE(QChart::AnimationOption)
             Q_DECLARE_METATYPE(QBrush)
             Q_DECLARE_METATYPE(QPen)
             Q_DECLARE_METATYPE(QChart::ChartTheme)
             class tst_QChart : public QObject
             {
                 Q_OBJECT
             public slots:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private slots:
                 void qchart_data();
                 void qchart();
                 void addSeries_data();
                 void addSeries();
                 void animationOptions_data();
                 void animationOptions();
                 void axisX_data();
                 void axisX();
                 void axisY_data();
                 void axisY();
                 void backgroundBrush_data();
                 void backgroundBrush();
                 void backgroundPen_data();
                 void backgroundPen();
                 void isBackgroundVisible_data();
                 void isBackgroundVisible();
                 void legend_data();
                 void legend();
                 void margins_data();
                 void margins();
                 void removeAllSeries_data();
                 void removeAllSeries();
                 void removeSeries_data();
                 void removeSeries();
                 void scrollDown_data();
                 void scrollDown();
                 void scrollLeft_data();
                 void scrollLeft();
                 void scrollRight_data();
                 void scrollRight();
                 void scrollUp_data();
                 void scrollUp();
                 void theme_data();
                 void theme();
                 void title_data();
                 void title();
                 void titleBrush_data();
                 void titleBrush();
                 void titleFont_data();
                 void titleFont();
                 void zoomIn_data();
                 void zoomIn();
                 void zoomOut_data();
                 void zoomOut();
             private:
                 void createTestData();
             private:
                 QChartView* m_view;
                 QChart* m_chart;
             };
             void tst_QChart::initTestCase()
             {
             }
             void tst_QChart::cleanupTestCase()
             {
             }
             void tst_QChart::init()
             {
                 m_view = new QChartView(new QChart());
                 m_chart = m_view->chart();
             }
             void tst_QChart::createTestData()
             {
                 QLineSeries* series0 = new QLineSeries(this);
                 *series0 << QPointF(0, 0) << QPointF(100, 100);
                 m_chart->addSeries(series0);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
             }
             void tst_QChart::cleanup()
             {
                 delete m_view;
                 m_view = 0;
                 m_chart = 0;
             }
             void tst_QChart::qchart_data()
             {
             }
             void tst_QChart::qchart()
             {
                 QVERIFY(m_chart);
                 QVERIFY(m_chart->legend());
                 QVERIFY(!m_chart->legend()->isVisible());
                 QCOMPARE(m_chart->animationOptions(), QChart::NoAnimation);
                 QVERIFY(m_chart->axisX());
                 QVERIFY(m_chart->axisY());
                 QVERIFY(m_chart->backgroundBrush()!=QBrush());
                 QVERIFY(m_chart->backgroundPen()!=QPen());
                 QCOMPARE(m_chart->isBackgroundVisible(), true);
                 QVERIFY(m_chart->margins().top()>0);
                 QVERIFY(m_chart->margins().left()>0);
                 QVERIFY(m_chart->margins().right()>0);
                 QVERIFY(m_chart->margins().bottom()>0);
                 QCOMPARE(m_chart->theme(), QChart::ChartThemeLight);
                 QCOMPARE(m_chart->title(), QString());
                 //QCOMPARE(m_chart->titleBrush(),QBrush());
                 //QCOMPARE(m_chart->titleFont(),QFont());
                 m_chart->removeAllSeries();
                 m_chart->scrollDown();
                 m_chart->scrollLeft();
                 m_chart->scrollRight();
                 m_chart->scrollUp();
                 m_chart->zoomIn();
                 m_chart->zoomIn(QRectF());
                 m_chart->zoomOut();
             }
             void tst_QChart::addSeries_data()
             {
                 QTest::addColumn<QAbstractSeries *>("series");
-                QTest::addColumn<QChartAxis *>("axis");
+                QTest::addColumn<QAxis *>("axis");
                 QAbstractSeries* series0 = new QLineSeries(this);
                 QAbstractSeries* series1 = new QAreaSeries(static_cast<QLineSeries*>(series0));
                 QAbstractSeries* series2 = new QScatterSeries(this);
                 QAbstractSeries* series3 = new QSplineSeries(this);
                 QAbstractSeries* series4 = new QPieSeries(this);
                 QAbstractSeries* series5 = new QBarSeries(QBarCategories(),this);
                 QAbstractSeries* series6 = new QPercentBarSeries(QBarCategories(),this);
                 QAbstractSeries* series7 = new QStackedBarSeries(QBarCategories(),this);
-                QChartAxis* axis = new QChartAxis(this);
+                QAxis* axis = new QAxis(this);
-                QTest::newRow("default axis: lineSeries") << series0 << (QChartAxis*) 0;
+                QTest::newRow("default axis: lineSeries") << series0 << (QAxis*) 0;
                 QTest::newRow("axis0: lineSeries") << series0 << axis;
-                QTest::newRow("default axis: areaSeries") << series1 << (QChartAxis*) 0;
+                QTest::newRow("default axis: areaSeries") << series1 << (QAxis*) 0;
                 QTest::newRow("axis: areaSeries") << series1 << axis;
-                QTest::newRow("default axis: scatterSeries") << series2 << (QChartAxis*) 0;
+                QTest::newRow("default axis: scatterSeries") << series2 << (QAxis*) 0;
                 QTest::newRow("axis1: scatterSeries") << series2 << axis;
-                QTest::newRow("default axis: splineSeries") << series3 << (QChartAxis*) 0;
+                QTest::newRow("default axis: splineSeries") << series3 << (QAxis*) 0;
                 QTest::newRow("axis: splineSeries") << series3 << axis;
-                QTest::newRow("default axis: pieSeries") << series4 << (QChartAxis*) 0;
+                QTest::newRow("default axis: pieSeries") << series4 << (QAxis*) 0;
                 QTest::newRow("axis: pieSeries") << series4 << axis;
-                QTest::newRow("default axis: barSeries") << series5 << (QChartAxis*) 0;
+                QTest::newRow("default axis: barSeries") << series5 << (QAxis*) 0;
                 QTest::newRow("axis: barSeries") << series5 << axis;
-                QTest::newRow("default axis: percentBarSeries") << series6 << (QChartAxis*) 0;
+                QTest::newRow("default axis: percentBarSeries") << series6 << (QAxis*) 0;
                 QTest::newRow("axis: barSeries") << series6 << axis;
-                QTest::newRow("default axis: stackedBarSeries") << series7 << (QChartAxis*) 0;
+                QTest::newRow("default axis: stackedBarSeries") << series7 << (QAxis*) 0;
                 QTest::newRow("axis: barSeries") << series7 << axis;
             }
             void tst_QChart::addSeries()
             {
                 QFETCH(QAbstractSeries *, series);
-                QFETCH(QChartAxis *, axis);
+                QFETCH(QAxis *, axis);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 if(!axis) axis = m_chart->axisY();
                 m_chart->addSeries(series,axis);
                 QCOMPARE(m_chart->axisY(series),axis);
                 m_chart->removeSeries(series);
             }
             void tst_QChart::animationOptions_data()
             {
                 QTest::addColumn<QChart::AnimationOption>("animationOptions");
                 QTest::newRow("AllAnimations") << QChart::AllAnimations;
                 QTest::newRow("NoAnimation") << QChart::NoAnimation;
                 QTest::newRow("GridAxisAnimations") << QChart::GridAxisAnimations;
                 QTest::newRow("SeriesAnimations") << QChart::SeriesAnimations;
             }
             void tst_QChart::animationOptions()
             {
                 createTestData();
                 QFETCH(QChart::AnimationOption, animationOptions);
                 m_chart->setAnimationOptions(animationOptions);
                 QCOMPARE(m_chart->animationOptions(), animationOptions);
             }
             void tst_QChart::axisX_data()
             {
             }
             void tst_QChart::axisX()
             {
                 QVERIFY(m_chart->axisX());
-                QChartAxis* axis = m_chart->axisX();
+                QAxis* axis = m_chart->axisX();
                 createTestData();
                 //it should be the same axis
                 QCOMPARE(axis,m_chart->axisX());
             }
             void tst_QChart::axisY_data()
             {
-                QTest::addColumn<QChartAxis*>("axis0");
+                QTest::addColumn<QAxis*>("axis0");
-                QTest::addColumn<QChartAxis*>("axis1");
+                QTest::addColumn<QAxis*>("axis1");
-                QTest::addColumn<QChartAxis*>("axis2");
+                QTest::addColumn<QAxis*>("axis2");
-                QTest::newRow("1 defualt, 2 optional") << (QChartAxis*)0 << new QChartAxis() << new QChartAxis();
+                QTest::newRow("1 defualt, 2 optional") << (QAxis*)0 << new QAxis() << new QAxis();
-                QTest::newRow("3 optional") << new QChartAxis() << new QChartAxis() << new QChartAxis();
+                QTest::newRow("3 optional") << new QAxis() << new QAxis() << new QAxis();
             }
             void tst_QChart::axisY()
             {
-                QFETCH(QChartAxis*, axis0);
+                QFETCH(QAxis*, axis0);
-                QFETCH(QChartAxis*, axis1);
+                QFETCH(QAxis*, axis1);
-                QFETCH(QChartAxis*, axis2);
+                QFETCH(QAxis*, axis2);
-                QChartAxis* defaultAxisY = m_chart->axisY();
+                QAxis* defaultAxisY = m_chart->axisY();
                 QVERIFY2(defaultAxisY, "Missing axisY.");
                 QLineSeries* series0 = new QLineSeries();
                 m_chart->addSeries(series0, axis0);
                 QLineSeries* series1 = new QLineSeries();
                 m_chart->addSeries(series1, axis1);
                 QLineSeries* series2 = new QLineSeries();
                 m_chart->addSeries(series2, axis2);
                 if (!axis0)
                     axis0 = defaultAxisY;
                 if (!axis1)
                     axis1 = defaultAxisY;
                 if (!axis2)
                     axis2 = defaultAxisY;
                 QVERIFY(m_chart->axisY(series0) == axis0);
                 QVERIFY(m_chart->axisY(series1) == axis1);
                 QVERIFY(m_chart->axisY(series2) == axis2);
             }
             void tst_QChart::backgroundBrush_data()
             {
                 QTest::addColumn<QBrush>("backgroundBrush");
                 QTest::newRow("null") << QBrush();
                 QTest::newRow("blue") << QBrush(Qt::blue);
                 QTest::newRow("white") << QBrush(Qt::white);
                 QTest::newRow("black") << QBrush(Qt::black);
             }
             void tst_QChart::backgroundBrush()
             {
                 QFETCH(QBrush, backgroundBrush);
                 m_chart->setBackgroundBrush(backgroundBrush);
                 QCOMPARE(m_chart->backgroundBrush(), backgroundBrush);
             }
             void tst_QChart::backgroundPen_data()
             {
                 QTest::addColumn<QPen>("backgroundPen");
                 QTest::newRow("null") << QPen();
                 QTest::newRow("blue") << QPen(Qt::blue);
                 QTest::newRow("white") << QPen(Qt::white);
                 QTest::newRow("black") << QPen(Qt::black);
             }
             void tst_QChart::backgroundPen()
             {
                 QFETCH(QPen, backgroundPen);
                 m_chart->setBackgroundPen(backgroundPen);
                 QCOMPARE(m_chart->backgroundPen(), backgroundPen);
             }
             void tst_QChart::isBackgroundVisible_data()
             {
                 QTest::addColumn<bool>("isBackgroundVisible");
                 QTest::newRow("true") << true;
                 QTest::newRow("false") << false;
             }
             void tst_QChart::isBackgroundVisible()
             {
                 QFETCH(bool, isBackgroundVisible);
                 m_chart->setBackgroundVisible(isBackgroundVisible);
                 QCOMPARE(m_chart->isBackgroundVisible(), isBackgroundVisible);
             }
             void tst_QChart::legend_data()
             {
             }
             void tst_QChart::legend()
             {
                 QVERIFY(m_chart->legend());
             }
             void tst_QChart::margins_data()
             {
             }
             void tst_QChart::margins()
             {QTest::addColumn<int>("seriesCount");
             QTest::newRow("0") << 0;
             QTest::newRow("-1") << -1;
                 createTestData();
                 QRectF rect = m_chart->geometry();
                 QVERIFY(m_chart->margins().top()+m_chart->margins().bottom() < rect.height());
                 QVERIFY(m_chart->margins().left()+m_chart->margins().right() < rect.width());
             }
             void tst_QChart::removeAllSeries_data()
             {
             }
             void tst_QChart::removeAllSeries()
             {
                 QLineSeries* series0 = new QLineSeries(this);
                 QLineSeries* series1 = new QLineSeries(this);
                 QLineSeries* series2 = new QLineSeries(this);
                 m_chart->addSeries(series0);
                 m_chart->addSeries(series1);
                 m_chart->addSeries(series2);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 QVERIFY(m_chart->axisY(series0)!=0);
                 QVERIFY(m_chart->axisY(series1)!=0);
                 QVERIFY(m_chart->axisY(series2)!=0);
                 m_chart->removeAllSeries();
                 QVERIFY(m_chart->axisY(series0)==0);
                 QVERIFY(m_chart->axisY(series1)==0);
                 QVERIFY(m_chart->axisY(series2)==0);
             }
             void tst_QChart::removeSeries_data()
             {
                 addSeries_data();
             }
             void tst_QChart::removeSeries()
             {
                 QFETCH(QAbstractSeries *, series);
-                QFETCH(QChartAxis *, axis);
+                QFETCH(QAxis *, axis);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
                 if(!axis) axis = m_chart->axisY();
                 m_chart->addSeries(series,axis);
                 QCOMPARE(m_chart->axisY(series),axis);
                 m_chart->removeSeries(series);
                 QVERIFY(m_chart->axisY(series)==0);
             }
             void tst_QChart::scrollDown_data()
             {
             }
             void tst_QChart::scrollDown()
             {
                 createTestData();
                 qreal min = m_chart->axisY()->min();
                 m_chart->scrollDown();
                 QVERIFY(m_chart->axisY()->min()<min);
             }
             void tst_QChart::scrollLeft_data()
             {
             }
             void tst_QChart::scrollLeft()
             {
                 createTestData();
                 qreal min = m_chart->axisX()->min();
                 m_chart->scrollLeft();
                 QVERIFY(m_chart->axisX()->min()<min);
             }
             void tst_QChart::scrollRight_data()
             {
             }
             void tst_QChart::scrollRight()
             {
                 createTestData();
                 qreal min = m_chart->axisX()->min();
                 m_chart->scrollRight();
                 QVERIFY(m_chart->axisX()->min()>min);
             }
             void tst_QChart::scrollUp_data()
             {
             }
             void tst_QChart::scrollUp()
             {
                 createTestData();
                 qreal min = m_chart->axisY()->min();
                 m_chart->scrollUp();
                 QVERIFY(m_chart->axisY()->min()>min);
             }
             void tst_QChart::theme_data()
             {
                 QTest::addColumn<QChart::ChartTheme>("theme");
                 QTest::newRow("ChartThemeBlueCerulean") << QChart::ChartThemeBlueCerulean;
                 QTest::newRow("ChartThemeBlueIcy") << QChart::ChartThemeBlueIcy;
                 QTest::newRow("ChartThemeBlueNcs") << QChart::ChartThemeBlueNcs;
                 QTest::newRow("ChartThemeBrownSand") << QChart::ChartThemeBrownSand;
                 QTest::newRow("ChartThemeDark") << QChart::ChartThemeDark;
                 QTest::newRow("hartThemeHighContrast") << QChart::ChartThemeHighContrast;
                 QTest::newRow("ChartThemeLight") << QChart::ChartThemeLight;
             }
             void tst_QChart::theme()
             {
                 QFETCH(QChart::ChartTheme, theme);
                 createTestData();
                 m_chart->setTheme(theme);
                 QVERIFY(m_chart->theme()==theme);
             }
             void tst_QChart::title_data()
             {
                 QTest::addColumn<QString>("title");
                 QTest::newRow("null") << QString();
                 QTest::newRow("foo") << QString("foo");
             }
             void tst_QChart::title()
             {
                 QFETCH(QString, title);
                 m_chart->setTitle(title);
                 QCOMPARE(m_chart->title(), title);
             }
             void tst_QChart::titleBrush_data()
             {
                 QTest::addColumn<QBrush>("titleBrush");
                 QTest::newRow("null") << QBrush();
                 QTest::newRow("blue") << QBrush(Qt::blue);
                 QTest::newRow("white") << QBrush(Qt::white);
                 QTest::newRow("black") << QBrush(Qt::black);
             }
             void tst_QChart::titleBrush()
             {
                 QFETCH(QBrush, titleBrush);
                 m_chart->setTitleBrush(titleBrush);
                 QCOMPARE(m_chart->titleBrush(), titleBrush);
             }
             void tst_QChart::titleFont_data()
             {
                 QTest::addColumn<QFont>("titleFont");
                 QTest::newRow("null") << QFont();
                 QTest::newRow("courier") << QFont("Courier", 8, QFont::Bold, true);
             }
             void tst_QChart::titleFont()
             {
                 QFETCH(QFont, titleFont);
                 m_chart->setTitleFont(titleFont);
                 QCOMPARE(m_chart->titleFont(), titleFont);
             }
             void tst_QChart::zoomIn_data()
             {
                 QTest::addColumn<QRectF>("rect");
                 QTest::newRow("null") << QRectF();
                 QTest::newRow("100x100") << QRectF(10,10,100,100);
                 QTest::newRow("200x200") << QRectF(10,10,200,200);
             }
             void tst_QChart::zoomIn()
             {
                 QFETCH(QRectF, rect);
                 createTestData();
                 QRectF marigns = m_chart->margins();
                 rect.adjust(marigns.left(),marigns.top(),-marigns.right(),-marigns.bottom());
                 qreal minX = m_chart->axisX()->min();
                 qreal minY = m_chart->axisY()->min();
                 qreal maxX = m_chart->axisX()->max();
                 qreal maxY = m_chart->axisY()->max();
                 m_chart->zoomIn(rect);
                 if(rect.isValid()){
                     QVERIFY(minX<m_chart->axisX()->min());
                     QVERIFY(maxX>m_chart->axisX()->max());
                     QVERIFY(minY<m_chart->axisY()->min());
                     QVERIFY(maxY>m_chart->axisY()->max());
                 }
             }
             void tst_QChart::zoomOut_data()
             {
             }
             void tst_QChart::zoomOut()
             {
                 createTestData();
                 qreal minX = m_chart->axisX()->min();
                 qreal minY = m_chart->axisY()->min();
                 qreal maxX = m_chart->axisX()->max();
                 qreal maxY = m_chart->axisY()->max();
                 m_chart->zoomIn();
                 QVERIFY(minX<m_chart->axisX()->min());
                 QVERIFY(maxX>m_chart->axisX()->max());
                 QVERIFY(minY<m_chart->axisY()->min());
                 QVERIFY(maxY>m_chart->axisY()->max());
                 m_chart->zoomOut();
                 QVERIFY(minX==m_chart->axisX()->min());
                 QVERIFY(maxX==m_chart->axisX()->max());
                 QVERIFY(minY==m_chart->axisY()->min());
                 QVERIFY(maxY==m_chart->axisY()->max());
             }
             QTEST_MAIN(tst_QChart)
             #include "tst_qchart.moc"

test/auto/qchartview/tst_qchartview.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 <QtTest/QtTest>
             #include <qchartview.h>
             #include <qlineseries.h>
             #include <cmath>
             QTCOMMERCIALCHART_USE_NAMESPACE
             Q_DECLARE_METATYPE(QChart*)
             Q_DECLARE_METATYPE(QChartView::RubberBands)
             Q_DECLARE_METATYPE(Qt::Key)
             class tst_QChartView : public QObject
             {
                 Q_OBJECT
             public Q_SLOTS:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private Q_SLOTS:
                 void qchartview_data();
                 void qchartview();
                 void chart_data();
                 void chart();
                 void rubberBand_data();
                 void rubberBand();
                 void keys_data();
                 void keys();
             private:
                 QChartView* m_view;
             };
             void tst_QChartView::initTestCase()
             {
                 //test tracks mouse, give a while to user to relese it
                 QTest::qWait(1000);
             }
             void tst_QChartView::cleanupTestCase()
             {
             }
             void tst_QChartView::init()
             {
                 m_view = new QChartView(new QChart());
                 m_view->chart()->legend()->setVisible(false);
             }
             void tst_QChartView::cleanup()
             {
                 delete m_view;
                 m_view =0;
             }
             void tst_QChartView::qchartview_data()
             {
             }
             void tst_QChartView::qchartview()
             {
                 QVERIFY(m_view->chart());
                 QCOMPARE(m_view->rubberBand(), QChartView::NoRubberBand);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
             }
             void tst_QChartView::chart_data()
             {
                 QTest::addColumn<QChart*>("chart");
                 QTest::newRow("qchart") << new QChart();
             }
             void tst_QChartView::chart()
             {
                 QFETCH(QChart*, chart);
                 QChartView* view = new QChartView(chart);
                 QCOMPARE(view->chart(), chart);
                 delete view;
             }
             void tst_QChartView::rubberBand_data()
             {
                 QTest::addColumn<QChartView::RubberBands>("rubberBand");
                 QTest::addColumn<int>("Xcount");
                 QTest::addColumn<int>("Ycount");
                 QTest::addColumn<int>("minX");
                 QTest::addColumn<int>("maxX");
                 QTest::addColumn<int>("minY");
                 QTest::addColumn<int>("maxY");
                 QTest::newRow("HorizonalRubberBand") << QChartView::RubberBands(QChartView::HorizonalRubberBand) << 0 << 1 << 20 << 180 << 0<< 200;
                 QTest::newRow("VerticalRubberBand") <<  QChartView::RubberBands(QChartView::VerticalRubberBand) << 1 << 0 << 0 << 200 << 20<< 180;
                 QTest::newRow("RectangleRubberBand") <<  QChartView::RubberBands(QChartView::RectangleRubberBand) << 1 << 1 <<20 << 180 << 20<< 180;
             }
             void tst_QChartView::rubberBand()
             {
                 QFETCH(QChartView::RubberBands, rubberBand);
                 QFETCH(int, Xcount);
                 QFETCH(int, Ycount);
                 QFETCH(int, minX);
                 QFETCH(int, maxX);
                 QFETCH(int, minY);
                 QFETCH(int, maxY);
                 m_view->setRubberBand(rubberBand);
                 QRectF padding = m_view->chart()->margins();
                 QCOMPARE(m_view->rubberBand(), rubberBand);
                 QLineSeries* line = new QLineSeries();
                 *line << QPointF(0, 0) << QPointF(200, 200);
                 m_view->chart()->addSeries(line);
                 m_view->resize(200 + padding.left() + padding.right(), 200 +  padding.top()+ padding.bottom());
                 m_view->show();
                 //this is hack since view does not get events otherwise
                 m_view->setMouseTracking(true);
-                QChartAxis* axisY = m_view->chart()->axisY();
+                QAxis* axisY = m_view->chart()->axisY();
                 QSignalSpy spy0(axisY, SIGNAL(rangeChanged(qreal,qreal)));
-                QChartAxis* axisX = m_view->chart()->axisX();
+                QAxis* axisX = m_view->chart()->axisX();
                 QSignalSpy spy1(axisX, SIGNAL(rangeChanged(qreal,qreal)));
                 QTest::qWaitForWindowShown(m_view);
                 QTest::qWait(500);
                 QTest::mouseMove(m_view->viewport(),  QPoint(minX, minY) + padding.topLeft().toPoint());
                 QTest::mousePress(m_view->viewport(), Qt::LeftButton, 0,  QPoint(minX, minY) + padding.topLeft().toPoint());
                 QTest::mouseMove(m_view->viewport(), QPoint(maxX, maxY) + padding.topLeft().toPoint());
                 QTest::mouseRelease(m_view->viewport(), Qt::LeftButton, 0, QPoint(maxX, maxY)+ padding.topLeft().toPoint());
                 QCOMPARE(spy0.count(), Xcount);
                 QCOMPARE(spy1.count(), Ycount);
                 //this is hack since view does not get events otherwise
                 m_view->setMouseTracking(false);
                 QVERIFY(axisX->min() - minX < 1);
                 QVERIFY(axisX->max() - maxX < 1);
                 QVERIFY(axisY->min() - minY < 1);
                 QVERIFY(axisY->max() - maxY < 1);
             }
             void tst_QChartView::keys_data()
             {
                 QTest::addColumn<Qt::Key>("key");
                 QTest::addColumn<int>("Xcount");
                 QTest::addColumn<int>("Ycount");
                 QTest::newRow("Qt::Key_Plus") << Qt::Key_Plus << 1 << 1;
                 QTest::newRow("Qt::Key_Minus") << Qt::Key_Minus << 1 << 1;
                 QTest::newRow("Qt::Key_Up") << Qt::Key_Up << 0 << 1;
                 QTest::newRow("Qt::Key_Down") << Qt::Key_Down << 0 << 1;
                 QTest::newRow("Qt::Key_Left") << Qt::Key_Left << 1 << 0;
                 QTest::newRow("Qt::Key_Right") << Qt::Key_Right << 1 << 0;
             }
             void tst_QChartView::keys()
             {
                 QFETCH(Qt::Key,key);
                 QFETCH(int, Xcount);
                 QFETCH(int, Ycount);
                 QRectF padding = m_view->chart()->margins();
                 QLineSeries* line = new QLineSeries();
                 *line << QPointF(0, 0) << QPointF(100, 100);
                 m_view->chart()->addSeries(line);
                 m_view->resize(100 + padding.left() + padding.right(), 100 +  padding.top()+ padding.bottom());
                 m_view->show();
-                QChartAxis* axisY = m_view->chart()->axisY();
+                QAxis* axisY = m_view->chart()->axisY();
                 QSignalSpy spy0(axisY, SIGNAL(rangeChanged(qreal,qreal)));
-                QChartAxis* axisX = m_view->chart()->axisX();
+                QAxis* axisX = m_view->chart()->axisX();
                 QSignalSpy spy1(axisX, SIGNAL(rangeChanged(qreal,qreal)));
                 QTest::keyPress(m_view, key);
                 QTest::keyRelease(m_view, key);
                 QCOMPARE(spy0.count(), Ycount);
                 QCOMPARE(spy1.count(), Xcount);
             }
             QTEST_MAIN(tst_QChartView)
             #include "tst_qchartview.moc"

test/gdpbarchart/widget.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "widget.h"
             #include <QChart>
             #include <QScatterSeries>
-            #include <QChartAxis>
+            #include <QAxis>
             #include <QBarSet>
             #include <QBarSeries>
             #include <QLegend>
             #include <QGridLayout>
             #include <QPushButton>
             #include <QLabel>
             #include <QListWidget>
             #include <QPrinter>
             #include <QPrintDialog>
             #include <QRadioButton>
             #include <QStringList>
             #include <QSqlQuery>
             #include <QDebug>
             QTCOMMERCIALCHART_USE_NAMESPACE
             Widget::Widget(QWidget *parent)
                 : QWidget(parent)
             {
                 setGeometry(100, 100, 1000, 600);
                 // right panel layout
                 barChartRadioButton = new QRadioButton(tr("Bar chart"));
                 barChartRadioButton->setChecked(true);
                 scatterChartRadioButton = new QRadioButton(tr("Scatter chart"));
                 scatterChartRadioButton->setChecked(false);
                 countrieslist = new QListWidget;
                 countrieslist->setSelectionMode(QAbstractItemView::MultiSelection);
                 //list of years widget
                 yearslist = new QListWidget;
                 yearslist->setSelectionMode(QAbstractItemView::ExtendedSelection);
                 for (int i = 1990; i < 2011; i++)
                     yearslist->addItem(QString("%1").arg(i));
                 QPushButton* refreshButton = new QPushButton(tr("Refresh"));
                 connect(refreshButton, SIGNAL(clicked()), this, SLOT(refreshChart()));
                 QPushButton* printButton = new QPushButton(tr("Print to pdf"));
                 connect(printButton, SIGNAL(clicked()), this, SLOT(printChart()));
                 QVBoxLayout* rightPanelLayout = new QVBoxLayout;
                 rightPanelLayout->addWidget(barChartRadioButton);
                 rightPanelLayout->addWidget(scatterChartRadioButton);
                 rightPanelLayout->addWidget(countrieslist);
                 rightPanelLayout->addWidget(yearslist);
                 rightPanelLayout->addWidget(refreshButton);
                 rightPanelLayout->addWidget(printButton);
                 rightPanelLayout->setStretch(0, 1);
                 rightPanelLayout->setStretch(1, 0);
                 QChart *chart = new QChart();
                 chart->setTitle("GDP by country");
                 chart->legend()->setVisible(true);
                 // main layout
                 chartView = new QChartView(chart);
                 QGridLayout* mainLayout = new QGridLayout;
                 mainLayout->addWidget(chartView, 0, 0);
                 mainLayout->addLayout(rightPanelLayout, 0, 1);
                 mainLayout->setColumnStretch(0,1);
                 setLayout(mainLayout);
                 // connect to the database
                 db = QSqlDatabase::addDatabase("QSQLITE");
                 db.setDatabaseName("gdpData");
                 if(!db.open())
                 {
                     qDebug() << "could not open database. SQLite db file missing (?)";
                     return;
                 }
                 // get the list of all countires and regions.
                 QSqlQuery query;
                 query.exec("SELECT DISTINCT country FROM gdp2");
                 // add the countries to the country filter
                 while (query.next()) {
                     countrieslist->addItem(query.value(0).toString());
                 }
             }
             Widget::~Widget()
             {
                 //
                 db.close();
             }
             /*!
                 refreshes the chart
             */
             void Widget::refreshChart()
             {
                 chartView->chart()->removeAllSeries();
                 // selected countries items list is not sorted. copy the values to QStringlist and sort them.
                 QStringList selectedCountriesStrings;
                 QList<QListWidgetItem*> selectedCountriesItems = countrieslist->selectedItems();
                 for (int i = 0; i < selectedCountriesItems.size(); i++)
                     selectedCountriesStrings.append(selectedCountriesItems[i]->text());
                 selectedCountriesStrings.sort();
                 QSqlQuery query;
                 // selected years items list is not sorted. copy the values to QList<int> and sort them.
                 QList<int> selectedYearsInts;
                 QList<QListWidgetItem*> selectedYearsItems = yearslist->selectedItems();
                 for (int i = 0; i < selectedYearsItems.size(); i++)
                     selectedYearsInts.append(selectedYearsItems[i]->text().toInt());
                 qSort(selectedYearsInts.begin(), selectedYearsInts.end());
                 if (barChartRadioButton->isChecked())
                 {
                     // use the sorted selected coutries list to initialize BarCategory
                     QStringList category;
                     for (int i = 0; i < selectedCountriesStrings.size(); i++)
                         category << selectedCountriesStrings[i];
                     QBarSeries* series0 = new QBarSeries(category);
                     series0 = new QBarSeries(category);
                     // prepare the selected counries SQL query
                     QString countriesQuery = "country IN (";
                     for (int i = 0; i < selectedCountriesStrings.size(); i++)
                     {
                         countriesQuery.append("'" + selectedCountriesStrings[i] + "'");
                         if ( i < selectedCountriesStrings.size() - 1)
                             countriesQuery.append(",");
                         else
                             countriesQuery.append(")");
                     }
                     // perform a query for each selected year
                     for (int i = 0; i < selectedYearsInts.size(); i++)
                     {
                         query.exec("SELECT country,gdpvalue FROM gdp2 where year=" + QString("%1").arg(selectedYearsInts[i]) + " AND " + countriesQuery);
                         QBarSet* barSet = new QBarSet(QString::number(selectedYearsInts[i]));
                         //        while (query.next()) {
                         //            qDebug() << query.value(0).toString() << " : " << query.value(1).toString();
                         //        }
                         query.first();
                         // the data for some of the coutries for some years might be missing.
                         // QBarChart needs bars to have same size
                         for (int k = 0; k < selectedCountriesStrings.size(); k++)
                         {
                             if (selectedCountriesStrings[k] == query.value(0).toString())
                             {
                                 *barSet << query.value(1).toReal();
                                 qDebug() << query.value(0).toString() << query.value(1).toReal() << " : " << QString("%1").arg(selectedYearsInts[i]);
                                 query.next();
                             }
                             else
                             {
                                 // data missing, put 0
                                 *barSet << 0.0f;
                                 qDebug() << "Putting 0 for the missing data" << " : " << QString("%1").arg(selectedYearsInts[i]);
                             }
                         }
                         series0->appendBarSet(barSet);
                     }
                     // add the serie to the chart
                     chartView->chart()->addSeries(series0);
                 }
                 else if (scatterChartRadioButton->isChecked())
                 {
                     QString yearsQuery = "year IN (";
                     for (int i = 0; i < selectedYearsInts.size(); i++)
                     {
                         yearsQuery.append("'" + QString("%1").arg(selectedYearsInts[i]) + "'");
                         if ( i < selectedYearsInts.size() - 1)
                             yearsQuery.append(",");
                         else
                             yearsQuery.append(")");
                     }
                     // perform a query for each selected country
                     for (int i = 0; i < selectedCountriesStrings.size(); i++)
                     {
                         query.exec("SELECT year,gdpvalue FROM gdp2 where country='" + selectedCountriesStrings[i] + "' AND " + yearsQuery);
                         query.first();
                         QScatterSeries* series = new QScatterSeries;
                         series->setName(selectedCountriesStrings[i]);
                         // the data for some of the coutries for some years might be missing.
                         for (int k = 0; k < selectedYearsInts.size(); k++)
                         {
                             if (selectedYearsInts[k] == query.value(0).toInt())
                             {
                                 *series << QPointF(query.value(0).toInt() , query.value(1).toReal());
                                 qDebug() << query.value(0).toString() << query.value(1).toReal() << " : " << QString("%1").arg(selectedYearsInts[k]);
                                 query.next();
                             }
                             else
                             {
                                 // data missing, put 0
                                 *series << QPointF(selectedYearsInts[k] , 0.0f);
                                 qDebug() << "Putting 0 for the missing data" << " : " << QString("%1").arg(selectedYearsInts[i]) << " " << query.value(0).toInt();
                             }
                         }
                         //            chartArea->axisX()->setRange(selectedYearsInts[selectedYearsInts.size() - 1] + 1, selectedYearsInts[0] - 1);
                         chartView->chart()->addSeries(series);
                     }
                     chartView->chart()->axisX()->setRange(selectedYearsInts[selectedYearsInts.size() - 1] - 1, selectedYearsInts[0] + 1);
                 }
             }
             void Widget::printChart()
             {
                 QPrinter printer;
                 //    QPrinter printer(QPrinter::HighResolution);
                 printer.setOutputFormat(QPrinter::PdfFormat);
                 printer.setOrientation(QPrinter::Landscape);
                 printer.setOutputFileName("print.pdf");
                 QPainter painter;
                 painter.begin(&printer);
                 chartView->render(&painter);
             }

test/tablemodelchart/tablewidget.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 "tablewidget.h"
             #include <QGridLayout>
             #include <QTableView>
             #include <QStyledItemDelegate>
             #include <QLineSeries>
             #include <QSplineSeries>
             #include <QScatterSeries>
             #include "customtablemodel.h"
             #include <QPieSeries>
             #include <QPieSlice>
             #include <QAreaSeries>
             #include <QBarSeries>
             #include <QBarSet>
             #include <QPushButton>
             #include <QRadioButton>
             #include <QLabel>
             #include <QSpinBox>
             #include <QTime>
             TableWidget::TableWidget(QWidget *parent)
                 : QWidget(parent)
             {
                 setGeometry(100, 100, 1000, 600);
                 qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));
                 // create simple model for storing data
                 // user's table data model
                 m_model = new CustomTableModel;
                 m_tableView = new QTableView;
                 m_tableView->setModel(m_model);
                 m_tableView->setMinimumHeight(300);
                 //    tableView->setMinimumSize(340, 480);
                 //    tableView->setItemDelegate(new QStyledItemDelegate);
                 m_chart = new QChart;
                 m_chartView = new QChartView(m_chart);
                 m_chartView->setRenderHint(QPainter::Antialiasing);
                 m_chartView->setMinimumSize(640, 480);
                 // add, remove data buttons
                 QPushButton* addRowAboveButton = new QPushButton("Add row above");
                 connect(addRowAboveButton, SIGNAL(clicked()), this, SLOT(addRowAbove()));
                 QPushButton* addRowBelowButton = new QPushButton("Add row below");
                 connect(addRowBelowButton, SIGNAL(clicked()), this, SLOT(addRowBelow()));
                 QPushButton* removeRowButton = new QPushButton("Remove row");
                 connect(removeRowButton, SIGNAL(clicked()), this, SLOT(removeRow()));
                 QLabel *spinBoxLabel = new QLabel("Rows affected:");
                 // spin box for setting number of affected items (add, remove)
                 m_linesCountSpinBox = new QSpinBox;
                 m_linesCountSpinBox->setRange(1, 10);
                 m_linesCountSpinBox->setValue(1);
                 // buttons layout
                 QVBoxLayout* buttonsLayout = new QVBoxLayout;
                 buttonsLayout->addWidget(spinBoxLabel);
                 buttonsLayout->addWidget(m_linesCountSpinBox);
                 buttonsLayout->addWidget(addRowAboveButton);
                 buttonsLayout->addWidget(addRowBelowButton);
                 buttonsLayout->addWidget(removeRowButton);
                 buttonsLayout->addStretch();
                 // chart type radio buttons
                 m_lineRadioButton = new QRadioButton("Line");
                 m_splineRadioButton = new QRadioButton("Spline");
                 m_scatterRadioButton = new QRadioButton("Scatter");
                 m_pieRadioButton = new QRadioButton("Pie");
                 m_areaRadioButton = new QRadioButton("Area");
                 m_barRadioButton = new QRadioButton("Bar");
                 connect(m_lineRadioButton, SIGNAL(toggled(bool)), this, SLOT(updateChartType(bool)));
                 connect(m_splineRadioButton, SIGNAL(toggled(bool)), this, SLOT(updateChartType(bool)));
                 connect(m_scatterRadioButton, SIGNAL(toggled(bool)), this, SLOT(updateChartType(bool)));
                 connect(m_pieRadioButton, SIGNAL(toggled(bool)), this, SLOT(updateChartType(bool)));
                 connect(m_areaRadioButton, SIGNAL(toggled(bool)), this, SLOT(updateChartType(bool)));
                 connect(m_barRadioButton, SIGNAL(toggled(bool)), this, SLOT(updateChartType(bool)));
                 m_lineRadioButton->setChecked(true);
                 // radio buttons layout
                 QVBoxLayout* radioLayout = new QVBoxLayout;
                 radioLayout->addWidget(m_lineRadioButton);
                 radioLayout->addWidget(m_splineRadioButton);
                 radioLayout->addWidget(m_scatterRadioButton);
                 radioLayout->addWidget(m_pieRadioButton);
                 radioLayout->addWidget(m_areaRadioButton);
                 radioLayout->addWidget(m_barRadioButton);
                 radioLayout->addStretch();
                 // create main layout
                 QGridLayout* mainLayout = new QGridLayout;
                 mainLayout->addLayout(buttonsLayout, 1, 1);
                 mainLayout->addLayout(radioLayout, 2, 1);
                 mainLayout->addWidget(m_tableView, 1, 0);
                 mainLayout->addWidget(m_chartView, 2, 0);
                 setLayout(mainLayout);
                 m_lineRadioButton->setFocus();
             }
             void TableWidget::addRowAbove()
             {
                 m_model->insertRows(m_tableView->currentIndex().row(), m_linesCountSpinBox->value());
             }
             void TableWidget::addRowBelow()
             {
                 m_model->insertRows(m_tableView->currentIndex().row() + 1, m_linesCountSpinBox->value());
             }
             void TableWidget::removeRow()
             {
                 m_model->removeRows(m_tableView->currentIndex().row(), qMin(m_model->rowCount() - m_tableView->currentIndex().row(), m_linesCountSpinBox->value()));
             }
             void TableWidget::updateChartType(bool toggle)
             {
                 // this if is needed, so that the function is only called once.
                 // For the radioButton that was enabled.
                 if (toggle) {
                     m_chart->removeAllSeries();
                     // renable axes of the chart (pie hides them)
                     // x axis
-                    QChartAxis *axis = m_chart->axisX();
+                    QAxis *axis = m_chart->axisX();
                     axis->setAxisVisible(true);
                     axis->setGridLineVisible(true);
                     axis->setLabelsVisible(true);
                     // y axis
                     axis = m_chart->axisY();
                     axis->setAxisVisible(true);
                     axis->setGridLineVisible(true);
                     axis->setLabelsVisible(true);
                     m_model->clearMapping();
                     QString seriesColorHex = "#000000";
                     QPen pen;
                     pen.setWidth(2);
                     if (m_lineRadioButton->isChecked())
                     {
                         // series 1
                         m_series = new QLineSeries;
                         m_series->setModel(m_model);
                         m_series->setModelMapping(0,1, Qt::Vertical);
             //            m_series->setModelMappingRange(1, 4);
                         m_chart->addSeries(m_series);
                         seriesColorHex = "#" + QString::number(m_series->pen().color().rgb(), 16).right(6).toUpper();
                         m_model->addMapping(seriesColorHex, QRect(0, 1, 2, 4));
                         // series 2
                         m_series = new QLineSeries;
                         m_series->setModel(m_model);
                         m_series->setModelMapping(2,3, Qt::Vertical);
                         m_chart->addSeries(m_series);
                         seriesColorHex = "#" + QString::number(m_series->pen().color().rgb(), 16).right(6).toUpper();
                         m_model->addMapping(seriesColorHex, QRect(2, 0, 2, 1000));
                         // series 3
                         m_series = new QLineSeries;
                         m_series->setModel(m_model);
                         m_series->setModelMapping(4,5, Qt::Vertical);
             //            m_series->setModelMappingRange(2, 0);
                         m_chart->addSeries(m_series);
                         seriesColorHex = "#" + QString::number(m_series->pen().color().rgb(), 16).right(6).toUpper();
                         m_model->addMapping(seriesColorHex, QRect(4, 2, 2, 1000));
                     }
                     else if (m_splineRadioButton->isChecked())
                     {
                         // series 1
                         m_series = new QSplineSeries;
                         m_series->setModel(m_model);
                         m_series->setModelMapping(0,1, Qt::Vertical);
             //            m_series->setModelMappingRange(1, 4);
                         //        series->setModelMapping(0,1, Qt::Horizontal);
                         m_chart->addSeries(m_series);
                         seriesColorHex = "#" + QString::number(m_series->pen().color().rgb(), 16).right(6).toUpper();
                         m_model->addMapping(seriesColorHex, QRect(0, 1, 2, 4));
                         // series 2
                         m_series = new QSplineSeries;
                         m_series->setModel(m_model);
                         m_series->setModelMapping(2,3, Qt::Vertical);
             //            m_series->setModelMappingRange(0, 0);
                         //        series->setModelMapping(2,3, Qt::Horizontal);
                         m_chart->addSeries(m_series);
                         seriesColorHex = "#" + QString::number(m_series->pen().color().rgb(), 16).right(6).toUpper();
                         m_model->addMapping(seriesColorHex, QRect(2, 0, 2, 1000));
                         // series 3
                         m_series = new QSplineSeries;
                         m_series->setModel(m_model);
                         m_series->setModelMapping(4,5, Qt::Vertical);
             //            m_series->setModelMappingRange(2, 0);
                         //        series->setModelMapping(4,5, Qt::Horizontal);
                         m_chart->addSeries(m_series);
                         seriesColorHex = "#" + QString::number(m_series->pen().color().rgb(), 16).right(6).toUpper();
                         m_model->addMapping(seriesColorHex, QRect(4, 2, 2, 1000));
                     }
                     else if (m_scatterRadioButton->isChecked())
                     {
                         // series 1
                         m_series = new QScatterSeries;
                         m_series->setModel(m_model);
                         m_series->setModelMapping(0,1, Qt::Vertical);
             //            m_series->setModelMappingRange(2, 0);
                         //        series->setModelMapping(0,1, Qt::Horizontal);
                         m_chart->addSeries(m_series);
                         seriesColorHex = "#" + QString::number(m_series->brush().color().rgb(), 16).right(6).toUpper();
                         m_model->addMapping(seriesColorHex, QRect(0, 2, 2, 1000));
                         // series 2
                         m_series = new QScatterSeries;
                         m_series->setModel(m_model);
                         m_series->setModelMapping(2,3, Qt::Vertical);
             //            m_series->setModelMappingRange(1, 6);
                         //        series->setModelMapping(2,3, Qt::Horizontal);
                         m_chart->addSeries(m_series);
                         seriesColorHex = "#" + QString::number(m_series->brush().color().rgb(), 16).right(6).toUpper();
                         m_model->addMapping(seriesColorHex, QRect(2, 1, 2, 6));
                         // series 3
                         m_series = new QScatterSeries;
                         m_series->setModel(m_model);
                         m_series->setModelMapping(4,5, Qt::Vertical);
                         //        series->setModelMapping(4,5, Qt::Horizontal);
                         m_chart->addSeries(m_series);
                         seriesColorHex = "#" + QString::number(m_series->brush().color().rgb(), 16).right(6).toUpper();
                         m_model->addMapping(seriesColorHex, QRect(4, 0, 2, 1000));
                     }
                     else if (m_pieRadioButton->isChecked())
                     {
                         // pie 1
                         QPieSeries* pieSeries = new QPieSeries;
                         pieSeries->setModel(m_model);
                         pieSeries->setModelMapping(0,0, Qt::Vertical);
                         pieSeries->setLabelsVisible(true);
                         pieSeries->setPieSize(0.4);
                         pieSeries->setHorizontalPosition(0.2);
                         pieSeries->setVerticalPosition(0.35);
                         m_chart->addSeries(pieSeries);
                         seriesColorHex = "#" + QString::number(pieSeries->slices().at(pieSeries->slices().count()/2)->brush().color().rgb(), 16).right(6).toUpper();
                         m_model->addMapping(seriesColorHex, QRect(0, 0, 1, 1000));
                         // pie 2
                         pieSeries = new QPieSeries;
                         pieSeries->setModel(m_model);
                         pieSeries->setModelMapping(1,1, Qt::Vertical);
                         pieSeries->setLabelsVisible(true);
                         pieSeries->setPieSize(0.4);
                         pieSeries->setHorizontalPosition(0.8);
                         pieSeries->setVerticalPosition(0.35);
                         m_chart->addSeries(pieSeries);
                         seriesColorHex = "#" + QString::number(pieSeries->slices().at(pieSeries->slices().count()/2)->brush().color().rgb(), 16).right(6).toUpper();
                         m_model->addMapping(seriesColorHex, QRect(1, 0, 1, 1000));
                         // pie 3
                         pieSeries = new QPieSeries;
                         pieSeries->setModel(m_model);
                         pieSeries->setModelMapping(2,2, Qt::Vertical);
                         pieSeries->setLabelsVisible(true);
                         pieSeries->setPieSize(0.4);
                         pieSeries->setHorizontalPosition(0.5);
                         pieSeries->setVerticalPosition(0.65);
                         m_chart->addSeries(pieSeries);
                         seriesColorHex = "#" + QString::number(pieSeries->slices().at(pieSeries->slices().count()/2)->brush().color().rgb(), 16).right(6).toUpper();
                         m_model->addMapping(seriesColorHex, QRect(2, 0, 1, 1000));
                     }
                     else if (m_areaRadioButton->isChecked())
                     {
                         QLineSeries* upperLineSeries = new QLineSeries;
                         upperLineSeries->setModel(m_model);
                         upperLineSeries->setModelMapping(0, 1, Qt::Vertical);
             //            upperLineSeries->setModelMappingRange(1, 5);
                         QLineSeries* lowerLineSeries = new QLineSeries;
                         lowerLineSeries->setModel(m_model);
                         lowerLineSeries->setModelMapping(2, 3, Qt::Vertical);
                         QAreaSeries* areaSeries = new QAreaSeries(upperLineSeries, lowerLineSeries);
                         m_chart->addSeries(areaSeries);
                         seriesColorHex = "#" + QString::number(areaSeries->brush().color().rgb(), 16).right(6).toUpper();
                         m_model->addMapping(seriesColorHex, QRect(0, 1, 2, 5));
                         m_model->addMapping(seriesColorHex, QRect(2, 0, 2, 1000));
                     }
                     else if (m_barRadioButton->isChecked())
                     {
                         QBarSeries* barSeries = new QBarSeries(QStringList());
                         barSeries->setModel(m_model);
                         barSeries->setModelMapping(5, 2, 4, Qt::Vertical);
                         m_chart->addSeries(barSeries);
                         QList<QBarSet*> barsets = barSeries->barSets();
                         for (int i = 0; i < barsets.count(); i++) {
                             seriesColorHex = "#" + QString::number(barsets.at(i)->brush().color().rgb(), 16).right(6).toUpper();
                             m_model->addMapping(seriesColorHex, QRect(2 + i, 0, 1, 1000));
                         }
                     }
                     m_chart->axisX()->setRange(0, 500);
                     m_chart->axisY()->setRange(0, 120);
                     // repaint table view colors
                     m_tableView->repaint();
                     m_tableView->setFocus();
                 }
             }
             TableWidget::~TableWidget()
             {
             }

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