HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1578:18a3503b3b2c

QAbstractAxis: variants strike back.

sauimone -

r1578:18a3503b3b2c

parent child

Context file:

r1578:18a3503b3b2c

Collapse all files

src/axis/qabstractaxis.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 "qabstractaxis.h"
             #include "qabstractaxis_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QAbstractAxis
                 \brief The QAbstractAxis class is used for manipulating chart's axis.
                 \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 shared common X axis.
                 Axis can be setup to show axis line with tick marks, grid lines and shades.
             */
             /*!
                 \qmlclass Axis QAbstractAxis
                 \brief The Axis element is used for manipulating chart's axes
                 There is only one x Axis, however there can be multiple y axes on a ChartView.
                 Each chart series can be bound to exactly one Y axis and the shared common X axis.
                 Axis can be setup to show axis line with tick marks, grid lines and shades.
                 To access Axes you can use ChartView API. For example:
                 \code
                     ChartView {
                         axisX.min: 0
                         axisX.max: 3
                         axisX.ticksCount: 4
                         axisY.min: 0
                         axisY.max: 4
                         // Add a few series...
                     }
                 \endcode
             */
             /*!
                 \enum QAbstractAxis::AxisType
                 The type of the series object.
                 \value AxisTypeValues
                 \value AxisTypeCategories
             */
             /*
                 \property QAbstractAxis::type
                 The type of the axis.
             */
             /*!
               \property QAbstractAxis::labelsVisible
               Defines if axis labels are visible.
             */
             /*!
               \qmlproperty bool Axis::labelsVisible
               Defines if axis labels are visible.
             */
             /*
               \property QAbstractAxis::min
               Defines the minimum value on the axis.
             */
             /*
               \qmlproperty real Axis::min
               Defines the minimum value on the axis.
             */
             /*
               \property QAbstractAxis::max
               Defines the maximum value on the axis.
             */
             /*
               \qmlproperty real Axis::max
               Defines the maximum value on the axis.
             */
             /*!
               \property QAbstractAxis::visible
               The visibility of the axis.
             */
             /*!
               \qmlproperty bool Axis::visible
               The visibility of the axis.
             */
             /*!
               \property QAbstractAxis::gridVisible
               The visibility of the grid lines.
             */
             /*!
               \qmlproperty bool Axis::gridVisible
               The visibility of the grid lines.
             */
             /*!
               \property QAbstractAxis::color
               The color of the axis and ticks.
             */
             /*!
               \qmlproperty color Axis::color
               The color of the axis and ticks.
             */
             /*!
               \property QAbstractAxis::labelsFont
               The font of the axis labels.
             */
             /*!
               \qmlproperty Font Axis::labelsFont
               The font of the axis labels.
               See the \l {Font} {QML Font Element} for detailed documentation.
             */
             /*!
               \property QAbstractAxis::labelsColor
               The color of the axis labels.
             */
             /*!
               \qmlproperty color Axis::labelsColor
               The color of the axis labels.
             */
             /*!
               \property QAbstractAxis::labelsAngle
               The angle of the axis labels in degrees.
             */
             /*!
               \qmlproperty int Axis::labelsAngle
               The angle of the axis labels in degrees.
             */
             /*!
               \property QAbstractAxis::shadesVisible
               The visibility of the axis shades.
             */
             /*!
               \qmlproperty bool Axis::shadesVisible
               The visibility of the axis shades.
             */
             /*!
               \property QAbstractAxis::shadesColor
               The fill (brush) color of the axis shades.
             */
             /*!
               \qmlproperty color Axis::shadesColor
               The fill (brush) color of the axis shades.
             */
             /*!
               \property QAbstractAxis::shadesBorderColor
               The border (pen) color of the axis shades.
             */
             /*!
               \qmlproperty color Axis::shadesBorderColor
               The border (pen) color of the axis shades.
             */
             /*!
               \fn void QAbstractAxis::visibleChanged(bool)
               Visiblity of the axis has changed to \a visible.
             */
             /*!
               \fn void QAbstractAxis::labelsVisibleChanged(bool)
               Visiblity of the labels of the axis has changed to \a visible.
             */
             /*!
               \fn void QAbstractAxis::gridVisibleChanged(bool)
               Visiblity of the grid lines of the axis has changed to \a visible.
             */
             /*
               \fn void QAbstractAxis::minChanged(qreal min)
               Axis emits signal when \a min of axis has changed.
             */
             /*
               \fn void QAbstractAxis::maxChanged(qreal max)
               Axis emits signal when \a max of axis has changed.
             */
             /*
               \fn void QAbstractAxis::rangeChanged(qreal min, qreal max)
               Axis emits signal when \a min or \a max of axis has changed.
             */
             /*
               \fn QChartAxisCategories* QAbstractAxis::categories()
               Returns pointer to the list of categories which correspond to the values on the axis.
             */
             /*!
               \fn void QAbstractAxis::colorChanged(QColor)
               Emitted if the \a color of the axis is changed.
             */
             /*!
               \fn void QAbstractAxis::labelsColorChanged(QColor)
               Emitted if the \a color of the axis labels is changed.
             */
             /*!
               \fn void QAbstractAxis::shadesVisibleChanged(bool)
               Emitted if the visibility of the axis shades is changed to \a visible.
             */
             /*!
               \fn void QAbstractAxis::shadesColorChanged(QColor)
               Emitted if the \a color of the axis shades is changed.
             */
             /*!
               \fn void QAbstractAxis::shadesBorderColorChanged(QColor)
               Emitted if the border \a color of the axis shades is changed.
             */
             /*!
               Constructs new axis object which is a child of \a parent. Ownership is taken by
               QChart when axis added.
             */
             QAbstractAxis::QAbstractAxis(QAbstractAxisPrivate &d, QObject *parent) :
             QObject(parent),
             d_ptr(&d)
             {
             }
             /*!
               Destructor of the axis object. When axis is added to chart, chart object takes ownership.
             */
             QAbstractAxis::~QAbstractAxis()
             {
             }
             /*!
               Sets \a pen used to draw axis line and ticks.
              */
             void QAbstractAxis::setAxisPen(const QPen &pen)
             {
             	if (d_ptr->m_axisPen!=pen) {
             	    d_ptr->m_axisPen = pen;
                     emit d_ptr->updated();
             	}
             }
             /*!
               Returns pen used to draw axis and ticks.
             */
             QPen QAbstractAxis::axisPen() const
             {
                 return d_ptr->m_axisPen;
             }
             void QAbstractAxis::setAxisPenColor(QColor color)
             {
                 QPen p = d_ptr->m_axisPen;
                 if (p.color() != color) {
                     p.setColor(color);
                     setAxisPen(p);
                     emit colorChanged(color);
                 }
             }
             QColor QAbstractAxis::axisPenColor() const
             {
                 return d_ptr->m_axisPen.color();
             }
             /*!
               Sets if axis and ticks are \a visible.
              */
             void QAbstractAxis::setAxisVisible(bool visible)
             {
                 if (d_ptr->m_axisVisible != visible) {
                     d_ptr->m_axisVisible = visible;
                     emit d_ptr->updated();
                     emit visibleChanged(visible);
             	}
             }
             bool QAbstractAxis::isAxisVisible() const
             {
                 return d_ptr->m_axisVisible;
             }
             void QAbstractAxis::setGridLineVisible(bool visible)
             {
                 if (d_ptr->m_gridLineVisible != visible) {
                     d_ptr->m_gridLineVisible = visible;
                     emit d_ptr->updated();
                     emit gridVisibleChanged(visible);
             	}
             }
             bool QAbstractAxis::isGridLineVisible() const
             {
                 return d_ptr->m_gridLineVisible;
             }
             /*!
               Sets \a pen used to draw grid line.
             */
             void QAbstractAxis::setGridLinePen(const QPen &pen)
             {
                 if (d_ptr->m_gridLinePen != pen) {
                     d_ptr->m_gridLinePen = pen;
                     emit d_ptr->updated();
             	}
             }
             /*!
               Returns pen used to draw grid.
             */
             QPen QAbstractAxis::gridLinePen() const
             {
                 return d_ptr->m_gridLinePen;
             }
             void QAbstractAxis::setLabelsVisible(bool visible)
             {
                 if (d_ptr->m_labelsVisible != visible) {
                     d_ptr->m_labelsVisible = visible;
                     emit d_ptr->updated();
                     emit labelsVisibleChanged(visible);
             	}
             }
             bool QAbstractAxis::labelsVisible() const
             {
                 return d_ptr->m_labelsVisible;
             }
             /*!
               Sets \a pen used to draw labels.
             */
             void QAbstractAxis::setLabelsPen(const QPen &pen)
             {
                 if (d_ptr->m_labelsPen != pen) {
                     d_ptr->m_labelsPen = pen;
                     emit d_ptr->updated();
             	}
             }
             /*!
               Returns the pen used to labels.
             */
             QPen QAbstractAxis::labelsPen() const
             {
                 return d_ptr->m_labelsPen;
             }
             /*!
               Sets \a brush used to draw labels.
              */
             void QAbstractAxis::setLabelsBrush(const QBrush &brush)
             {
                 if (d_ptr->m_labelsBrush != brush) {
                     d_ptr->m_labelsBrush = brush;
                     emit d_ptr->updated();
             	}
             }
             /*!
               Returns brush used to draw labels.
             */
             QBrush  QAbstractAxis::labelsBrush() const
             {
                 return d_ptr->m_labelsBrush;
             }
             /*!
               Sets \a font used to draw labels.
             */
             void QAbstractAxis::setLabelsFont(const QFont &font)
             {
                 if (d_ptr->m_labelsFont != font) {
                     d_ptr->m_labelsFont = font;
                     emit d_ptr->updated();
             	}
             }
             /*!
               Returns font used to draw labels.
             */
             QFont QAbstractAxis::labelsFont() const
             {
                 return d_ptr->m_labelsFont;
             }
             void QAbstractAxis::setLabelsAngle(int angle)
             {
                 if (d_ptr->m_labelsAngle != angle) {
                     d_ptr->m_labelsAngle = angle;
                     emit d_ptr->updated();
             	}
             }
             int QAbstractAxis::labelsAngle() const
             {
                 return d_ptr->m_labelsAngle;
             }
             void QAbstractAxis::setLabelsColor(QColor color)
             {
                 QBrush b = d_ptr->m_labelsBrush;
                 if (b.color() != color) {
                     b.setColor(color);
                     setLabelsBrush(b);
                     emit labelsColorChanged(color);
                 }
             }
             QColor QAbstractAxis::labelsColor() const
             {
                 return d_ptr->m_labelsBrush.color();
             }
             void QAbstractAxis::setShadesVisible(bool visible)
             {
                 if (d_ptr->m_shadesVisible != visible) {
                     d_ptr->m_shadesVisible = visible;
                     emit d_ptr->updated();
                     emit shadesVisibleChanged(visible);
             	}
             }
             bool QAbstractAxis::shadesVisible() const
             {
                 return d_ptr->m_shadesVisible;
             }
             /*!
               Sets \a pen used to draw shades.
             */
             void QAbstractAxis::setShadesPen(const QPen &pen)
             {
                 if (d_ptr->m_shadesPen != pen) {
                     d_ptr->m_shadesPen = pen;
                     emit d_ptr->updated();
             	}
             }
             /*!
               Returns pen used to draw shades.
             */
             QPen QAbstractAxis::shadesPen() const
             {
                 return d_ptr->m_shadesPen;
             }
             /*!
               Sets \a brush used to draw shades.
             */
             void QAbstractAxis::setShadesBrush(const QBrush &brush)
             {
                 if (d_ptr->m_shadesBrush != brush) {
                     d_ptr->m_shadesBrush = brush;
                     emit d_ptr->updated();
                     emit shadesColorChanged(brush.color());
                 }
             }
             /*!
                Returns brush used to draw shades.
             */
             QBrush QAbstractAxis::shadesBrush() const
             {
                 return d_ptr->m_shadesBrush;
             }
             void QAbstractAxis::setShadesColor(QColor color)
             {
                 QBrush b = d_ptr->m_shadesBrush;
                 b.setColor(color);
                 setShadesBrush(b);
             }
             QColor QAbstractAxis::shadesColor() const
             {
                 return d_ptr->m_shadesBrush.color();
             }
             void QAbstractAxis::setShadesBorderColor(QColor color)
             {
                 QPen p = d_ptr->m_shadesPen;
                 p.setColor(color);
                 setShadesPen(p);
             }
             QColor QAbstractAxis::shadesBorderColor() const
             {
                 return d_ptr->m_shadesPen.color();
             }
             /*!
               Sets axis, shades, labels and grid lines to be visible.
             */
             void QAbstractAxis::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 QAbstractAxis::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();
             }
-            void QAbstractAxis::setMin(const qreal min)
+            void QAbstractAxis::setMin(const QVariant &min)
             {
                 d_ptr->setMin(min);
             }
-            void QAbstractAxis::setMax(const qreal max)
+            void QAbstractAxis::setMax(const QVariant &max)
             {
                 d_ptr->setMax(max);
             }
-            void QAbstractAxis::setRange(const qreal min, const qreal max)
+            void QAbstractAxis::setRange(const QVariant &min, const QVariant &max)
             {
                 d_ptr->setRange(min,max);
             }
             /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QAbstractAxisPrivate::QAbstractAxisPrivate(QAbstractAxis* q):
                 q_ptr(q),
                 m_axisVisible(true),
                 m_gridLineVisible(true),
                 m_labelsVisible(true),
                 m_labelsAngle(0),
                 m_shadesVisible(false),
                 m_shadesBrush(Qt::SolidPattern),
                 m_shadesOpacity(1.0),
                 m_orientation(Qt::Orientation(0)),
                 m_min(0),
                 m_max(0),
                 m_ticksCount(5)
             {
             }
             QAbstractAxisPrivate::~QAbstractAxisPrivate()
             {
             }
             #include "moc_qabstractaxis.cpp"
             #include "moc_qabstractaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/qabstractaxis.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 QABSTRACTAXIS_H
             #define QABSTRACTAXIS_H
             #include <qchartglobal.h>
             #include <QPen>
             #include <QFont>
             #include <QVariant>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QAbstractAxisPrivate;
             class QTCOMMERCIALCHART_EXPORT QAbstractAxis : public QObject
             {
             	Q_OBJECT
                 Q_PROPERTY(bool visible READ isAxisVisible WRITE setAxisVisible NOTIFY visibleChanged)
                 Q_PROPERTY(QColor color READ axisPenColor WRITE setAxisPenColor NOTIFY colorChanged)
                 Q_PROPERTY(bool labelsVisible READ labelsVisible WRITE setLabelsVisible NOTIFY labelsVisibleChanged)
                 Q_PROPERTY(int labelsAngle READ labelsAngle WRITE setLabelsAngle)
                 Q_PROPERTY(QFont labelsFont READ labelsFont WRITE setLabelsFont)
                 Q_PROPERTY(QColor labelsColor READ labelsColor WRITE setLabelsColor NOTIFY labelsColorChanged)
                 Q_PROPERTY(bool gridVisible READ isGridLineVisible WRITE setGridLineVisible NOTIFY gridVisibleChanged)
                 Q_PROPERTY(bool shadesVisible READ shadesVisible WRITE setShadesVisible NOTIFY shadesVisibleChanged)
                 Q_PROPERTY(QColor shadesColor READ shadesColor WRITE setShadesColor NOTIFY shadesColorChanged)
                 Q_PROPERTY(QColor shadesBorderColor READ shadesBorderColor WRITE setShadesBorderColor NOTIFY shadesBorderColorChanged)
             public:
                 enum AxisType {
                     AxisTypeValues,
                     AxisTypeCategories
                 };
             protected:
                 explicit QAbstractAxis(QAbstractAxisPrivate &d,QObject *parent = 0);
             public:
                 ~QAbstractAxis();
                 virtual AxisType type() const = 0;
                 //axis handling
                 bool isAxisVisible() const;
                 void setAxisVisible(bool visible = true);
                 void setAxisPen(const QPen &pen);
                 QPen axisPen() const;
                 void setAxisPenColor(QColor color);
                 QColor axisPenColor() 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;
                 void setLabelsColor(QColor color);
                 QColor labelsColor() 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 setShadesColor(QColor color);
                 QColor shadesColor() const;
                 void setShadesBorderColor(QColor color);
                 QColor shadesBorderColor() const;
                 //range handling
-                void setMin(const qreal min);
+                void setMin(const QVariant &min);
-                void setMax(const qreal max);
+                void setMax(const QVariant &max);
-                void setRange(const qreal min, const qreal max);
+                void setRange(const QVariant &min, const QVariant &max);
                 void show();
                 void hide();
             Q_SIGNALS:
                 void visibleChanged(bool visible);
                 void labelsVisibleChanged(bool visible);
                 void gridVisibleChanged(bool visible);
                 void colorChanged(QColor color);
                 void labelsColorChanged(QColor color);
                 void shadesVisibleChanged(bool visible);
                 void shadesColorChanged(QColor color);
                 void shadesBorderColorChanged(QColor color);
             protected:
             	QScopedPointer<QAbstractAxisPrivate> d_ptr;
                 Q_DISABLE_COPY(QAbstractAxis);
                 friend class ChartDataSet;
                 friend class ChartAxis;
                 friend class ChartPresenter;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/axis/qabstractaxis_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$
             **
             ****************************************************************************/
             //  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 QABSTRACTAXIS_P_H
             #define QABSTRACTAXIS_P_H
             #include "qabstractaxis.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartPresenter;
             class ChartAxis;
             class QAbstractAxisPrivate : public QObject
             {
                 Q_OBJECT
             public:
                 QAbstractAxisPrivate(QAbstractAxis *q);
                 ~QAbstractAxisPrivate();
             Q_SIGNALS:
                 void updated();
             public:
                 virtual ChartAxis* createGraphics(ChartPresenter* presenter) = 0;
                 virtual void updateRange() = 0;
             protected:
-                virtual void setMin(const qreal min) = 0;
+                virtual void setMin(const QVariant &min) = 0;
-                virtual void setMax(const qreal max) = 0;
+                virtual void setMax(const QVariant &max) = 0;
-                virtual void setRange(const qreal min, const qreal max, bool force = false) = 0;
+                virtual void setRange(const QVariant &min, const QVariant &max, bool force = false) = 0;
                 virtual int ticksCount() const = 0;
             public:
                 QAbstractAxis *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;
                 Qt::Orientation m_orientation;
                 // range
                 qreal m_min;
                 qreal m_max;
                 int m_ticksCount;
                 friend class QAbstractAxis;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/axis/qcategoriesaxis.cpp +9 -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 "qcategoriesaxis.h"
             #include "qcategoriesaxis_p.h"
             #include "chartcategoriesaxisx_p.h"
             #include "chartcategoriesaxisy_p.h"
             #include <qmath.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QCategoriesAxis::QCategoriesAxis(QObject *parent):
                 QAbstractAxis(*new QCategoriesAxisPrivate(this),parent)
             {
             }
             QCategoriesAxis::~QCategoriesAxis()
             {
             }
             QCategoriesAxis::QCategoriesAxis(QCategoriesAxisPrivate &d,QObject *parent):QAbstractAxis(d,parent)
             {
             }
             /*!
                 Appends \a categories to axis
             */
             void QCategoriesAxis::append(const QStringList &categories)
             {
                 Q_D(QCategoriesAxis);
                 d->m_categories.append(categories);
                 emit categoriesChanged();
             }
             /*!
                 Appends \a category to axis
             */
             void QCategoriesAxis::append(const QString &category)
             {
                 Q_D(QCategoriesAxis);
                 d->m_categories.append(category);
                 emit categoriesChanged();
             }
             /*!
                 Removes \a category from axis
             */
             void QCategoriesAxis::remove(const QString &category)
             {
                 Q_D(QCategoriesAxis);
                 if (d->m_categories.contains(category)) {
                     d->m_categories.removeAt(d->m_categories.indexOf(category));
                     emit categoriesChanged();
                 }
             }
             /*!
                 Inserts \a category to axis at \a index
             */
             void QCategoriesAxis::insert(int index, const QString &category)
             {
                 Q_D(QCategoriesAxis);
                 d->m_categories.insert(index,category);
                 emit categoriesChanged();
             }
             /*!
               Removes all categories.
              */
             void QCategoriesAxis::clear()
             {
                 Q_D(QCategoriesAxis);
                 d->m_categories.clear();
                 emit categoriesChanged();
             }
             void QCategoriesAxis::setCategories(const QStringList &categories)
             {
                 Q_D(QCategoriesAxis);
                 d->m_categories = categories;
                 emit categoriesChanged();
             }
             QStringList QCategoriesAxis::categories()
             {
                 Q_D(QCategoriesAxis);
                 return d->m_categories;
             }
             /*!
               Returns number of categories.
              */
             int QCategoriesAxis::count() const
             {
                 Q_D(const QCategoriesAxis);
                 return d->m_categories.count();
             }
             /*!
                 Returns category at \a index. Index must be valid.
             */
             QString QCategoriesAxis::at(int index) const
             {
                 Q_D(const QCategoriesAxis);
                 return d->m_categories.at(index);
             }
             /*!
                 Sets minimum category to \a minCategory.
             */
             void QCategoriesAxis::setMinCategory(const QString& minCategory)
             {
                 Q_D(QCategoriesAxis);
                 d->setMinCategory(minCategory);
             }
             /*!
                 Returns minimum category.
             */
             QString QCategoriesAxis::minCategory() const
             {
                 Q_D(const QCategoriesAxis);
                 return d->m_minCategory;
             }
             /*!
                 Sets maximum category to \a maxCategory.
             */
             void QCategoriesAxis::setMaxCategory(const QString& maxCategory)
             {
                 Q_D(QCategoriesAxis);
                 d->setMaxCategory(maxCategory);
             }
             /*!
                 Returns maximum category
             */
             QString QCategoriesAxis::maxCategory() const
             {
                 Q_D(const QCategoriesAxis);
                 return d->m_maxCategory;
             }
             /*!
                 Sets range from \a minCategory to \a maxCategory
             */
             void QCategoriesAxis::setCategoryRange(const QString& minCategory, const QString& maxCategory)
             {
                 Q_D(QCategoriesAxis);
                 d->setRangeCategory(minCategory,maxCategory);
             }
             /*!
                 Returns the type of axis.
             */
             QAbstractAxis::AxisType QCategoriesAxis::type() const
             {
                 return AxisTypeCategories;
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QCategoriesAxisPrivate::QCategoriesAxisPrivate(QCategoriesAxis* q):
                 QAbstractAxisPrivate(q)
             {
             }
             QCategoriesAxisPrivate::~QCategoriesAxisPrivate()
             {
             }
             void QCategoriesAxisPrivate::setMinCategory(const QString& minCategory)
             {
                 // Convert the category to value
                 int minIndex = m_categories.indexOf(minCategory);
                 if (minIndex == -1) {
                     return;
                 }
                 int maxIndex = qFloor(m_max);
                 if (minIndex > maxIndex) {
                     maxIndex = m_categories.count()-1;
                 }
                 setRange(minIndex - 0.5, maxIndex + 0.5);
             }
             void QCategoriesAxisPrivate::setMaxCategory(const QString& maxCategory)
             {
                 // Convert the category to value
                 int maxIndex = m_categories.indexOf(maxCategory);
                 if (maxIndex == -1) {
                     return;
                 }
                 int minIndex = qCeil(m_min);
                 if (maxIndex < minIndex) {
                     minIndex = 0;
                 }
                 setRange(minIndex - 0.5, maxIndex + 0.5);
             }
             void QCategoriesAxisPrivate::setRangeCategory(const QString& minCategory, const QString& maxCategory)
             {
                 // TODO:
                 int minIndex = m_categories.indexOf(minCategory);
                 if (minIndex == -1) {
                     return;
                 }
                 int maxIndex = m_categories.indexOf(maxCategory);
                 if (maxIndex == -1) {
                     return;
                 }
                 setRange(minIndex -0.5, maxIndex + 0.5);
             }
-            void QCategoriesAxisPrivate::setMin(const qreal min)
+            void QCategoriesAxisPrivate::setMin(const QVariant &min)
             {
                 setRange(min,m_max);
             }
-            void QCategoriesAxisPrivate::setMax(const qreal max)
+            void QCategoriesAxisPrivate::setMax(const QVariant &max)
             {
                 setRange(m_min,max);
             }
-            void QCategoriesAxisPrivate::setRange(const qreal min, const qreal max, bool force)
+            void QCategoriesAxisPrivate::setRange(const QVariant &min, const QVariant &max, bool force)
             {
+                Q_UNUSED(min);
+                Q_UNUSED(max);
+                Q_UNUSED(force);
+                // TODO: refactor
+            /*
                 if (max <= min) {
                     // max must be greater than min
                     return;
                 }
                 Q_Q(QCategoriesAxis);
                 bool changed = false;
                 if (!qFuzzyIsNull(m_min - min)) {
                     m_min = min;
                     changed = true;
                 }
                 if (!qFuzzyIsNull(m_max - max)) {
                     m_max = max;
                     changed = true;
                 }
                 if ((changed) ||(force)) {
                     emit this->changed(m_min, m_max, qCeil(m_max) -qCeil(m_min) +1, false);
                     emit q->categoriesChanged();
                 }
+            */
             }
             int QCategoriesAxisPrivate::ticksCount() const
             {
                 return m_categories.count()+1;
             }
             void QCategoriesAxisPrivate::handleAxisRangeChanged(qreal min, qreal max,int count)
             {
                 m_min = min;
                 m_max = max;
                 m_ticksCount = count;
             }
             ChartAxis* QCategoriesAxisPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q( QCategoriesAxis);
                 if(m_orientation == Qt::Vertical){
                     return new ChartCategoriesAxisY(q,presenter);
                 }else{
                     return new ChartCategoriesAxisX(q,presenter);
                 }
             }
             void QCategoriesAxisPrivate::updateRange()
             {
                 setRange(m_min,m_max,true);
             }
             #include "moc_qcategoriesaxis.cpp"
             #include "moc_qcategoriesaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/qcategoriesaxis.h +4 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef QCATEGORIESAXIS_H
             #define QCATEGORIESAXIS_H
             #include "qabstractaxis.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QCategoriesAxisPrivate;
             class QTCOMMERCIALCHART_EXPORT QCategoriesAxis : public QAbstractAxis
             {
                 Q_OBJECT
                 Q_PROPERTY(QStringList categories READ categories WRITE setCategories NOTIFY categoriesChanged)
             public:
                 explicit QCategoriesAxis(QObject *parent = 0);
                 ~QCategoriesAxis();
             protected:
                 QCategoriesAxis(QCategoriesAxisPrivate &d,QObject *parent = 0);
             public:
                 AxisType type() const;
                 void append(const QStringList &categories);
                 void append(const QString &category);
                 void remove(const QString &category);
                 void insert(int index, const QString &category);
                 void clear();
                 void setCategories(const QStringList &categories);
                 QStringList categories();
                 int count() const;
                 QString at(int index) const;
                 //range handling convenience functions
                 void setMinCategory(const QString& minCategory);
                 QString minCategory() const;
                 void setMaxCategory(const QString& maxCategory);
                 QString maxCategory() const;
                 void setCategoryRange(const QString& minCategory, const QString& maxCategory);
+                void setMin(const QVariant &min);
+                void setMax(const QVariant &max);
+                void setRange(const QVariant &min, const QVariant &max);
             Q_SIGNALS:
                 void categoriesChanged();
             private:
                 Q_DECLARE_PRIVATE(QCategoriesAxis)
                 Q_DISABLE_COPY(QCategoriesAxis)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QCATEGORIESAXIS_H

src/axis/qcategoriesaxis_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$
             **
             ****************************************************************************/
             //  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 QCATEGORIESAXIS_P_H
             #define QCATEGORIESAXIS_P_H
             #include "qcategoriesaxis.h"
             #include "qabstractaxis_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QCategoriesAxisPrivate : public QAbstractAxisPrivate
             {
                 Q_OBJECT
             public:
                 QCategoriesAxisPrivate(QCategoriesAxis *q);
                 ~QCategoriesAxisPrivate();
             public:
                 ChartAxis* createGraphics(ChartPresenter* presenter);
                 void updateRange();
             private:
                 void setMinCategory(const QString& minCategory);
                 void setMaxCategory(const QString& maxCategory);
                 void setRangeCategory(const QString& minCategory, const QString& maxCategory);
                 //range handling
-                void setMin(const qreal min);
+                void setMin(const QVariant &min);
-                void setMax(const qreal max);
+                void setMax(const QVariant &max);
-                void setRange(const qreal min, const qreal max, bool force = false);
+                void setRange(const QVariant &min, const QVariant &max, bool force = false);
                 int ticksCount() const;
             Q_SIGNALS:
                 void changed(qreal min, qreal max, int tickCount,bool niceNumbers);
             public Q_SLOTS:
                 void handleAxisRangeChanged(qreal min, qreal max,int count);
             private:
                 QStringList m_categories;
                 QString m_minCategory;
                 QString m_maxCategory;
             private:
                 Q_DECLARE_PUBLIC(QCategoriesAxis)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QCATEGORIESAXIS_P_H

src/axis/qvaluesaxis.cpp +34 -22

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qvaluesaxis.h"
             #include "qvaluesaxis_p.h"
             #include "chartvaluesaxisx_p.h"
             #include "chartvaluesaxisy_p.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QValuesAxis
                 \brief The QValuesAxis class is used for manipulating chart's axis.
                 \mainclass
                 Axis can be setup to show axis line with tick marks, grid lines and shades.
             */
             /*!
                 \qmlclass Axis QValuesAxis
                 \brief The Axis element is used for manipulating chart's axes
                 Axis can be setup to show axis line with tick marks, grid lines and shades.
                 To access Axes you can use ChartView API. For example:
                 \code
                     ChartView {
                         axisX.min: 0
                         axisX.max: 3
                         axisX.ticksCount: 4
                         axisY.min: 0
                         axisY.max: 4
                         // Add a few series...
                     }
                 \endcode
             */
             /*!
               \property QValuesAxis::min
               Defines the minimum value on the axis.
             */
             /*!
               \qmlproperty real Axis::min
               Defines the minimum value on the axis.
             */
             /*!
               \property QValuesAxis::max
               Defines the maximum value on the axis.
             */
             /*!
               \qmlproperty real Axis::max
               Defines the maximum value on the axis.
             */
             /*!
               \fn void QValuesAxis::minChanged(qreal min)
               Axis emits signal when \a min of axis has changed.
             */
             /*!
               \fn void QValuesAxis::maxChanged(qreal max)
               Axis emits signal when \a max of axis has changed.
             */
             /*!
               \fn void QValuesAxis::rangeChanged(qreal min, qreal max)
               Axis emits signal when \a min or \a max of axis has changed.
             */
             /*!
               \property QValuesAxis::ticksCount
               The number of tick marks for the axis.
             */
             /*!
               \qmlproperty int Axis::ticksCount
               The number of tick marks for the axis.
             */
             /*!
               \property QValuesAxis::niceNumbersEnabled
               Whether the nice numbers algorithm is enabled or not for the axis.
             */
             /*!
               \qmlproperty bool Axis::niceNumbersEnabled
               Whether the nice numbers algorithm is enabled or not for the axis.
             */
             QValuesAxis::QValuesAxis(QObject *parent) :
                 QAbstractAxis(*new QValuesAxisPrivate(this),parent)
             {
             }
             QValuesAxis::QValuesAxis(QValuesAxisPrivate &d,QObject *parent) : QAbstractAxis(d,parent)
             {
             }
             QValuesAxis::~QValuesAxis()
             {
             }
             void QValuesAxis::setMin(qreal min)
             {
                 Q_D(QValuesAxis);
                 setRange(min,d->m_max);
             }
             qreal QValuesAxis::min() const
             {
                 Q_D(const QValuesAxis);
                 return d->m_min;
             }
             void QValuesAxis::setMax(qreal max)
             {
                 Q_D(QValuesAxis);
                 setRange(d->m_min,max);
             }
             qreal QValuesAxis::max() const
             {
                 Q_D(const QValuesAxis);
                 return d->m_max;
             }
             /*!
               Sets range from \a min to \a max on the axis.
             */
             void QValuesAxis::setRange(qreal min, qreal max)
             {
                 Q_D(QValuesAxis);
+                bool changed = false;
+                if (!qFuzzyIsNull(d->m_min - min)) {
+                    d->m_min = min;
+                    changed = true;
+                    emit minChanged(min);
+                }
+                if (!qFuzzyIsNull(d->m_max - max)) {
+                    d->m_max = max;
+                    changed = true;
+                    emit maxChanged(max);
+                }
+                if (changed) {
+                   emit rangeChanged(d->m_min,d->m_max);
+                   emit d->changed(d->m_min, d->m_max, d->m_ticksCount, d->m_niceNumbers);
+                }
                 d->setRange(min,max);
             }
             /*!
               Sets \a count for ticks on the axis.
             */
             void QValuesAxis::setTicksCount(int count)
             {
                 Q_D(QValuesAxis);
                 if (d->m_ticksCount != count) {
                     d->m_ticksCount = count;
                     emit d->changed(d->m_min, d->m_max, d->m_ticksCount, d->m_niceNumbers);
                 }
             }
             /*!
               \fn int QValuesAxis::ticksCount() const
               Return number of ticks on the axis
             */
             int QValuesAxis::ticksCount() const
             {
                 Q_D(const QValuesAxis);
                 return d->m_ticksCount;
             }
             void QValuesAxis::setNiceNumbersEnabled(bool enable)
             {
                 Q_D(QValuesAxis);
                 if (d->m_niceNumbers != enable){
                     d->m_niceNumbers = enable;
                     emit d->changed(d->m_min, d->m_max, d->m_ticksCount, d->m_niceNumbers);
                 }
             }
             bool  QValuesAxis::niceNumbersEnabled() const
             {
                 Q_D(const QValuesAxis);
                 return d->m_niceNumbers;
             }
             QAbstractAxis::AxisType QValuesAxis::type() const
             {
                 return AxisTypeValues;
             }
             /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QValuesAxisPrivate::QValuesAxisPrivate(QValuesAxis* q):
                 QAbstractAxisPrivate(q),
                 m_niceNumbers(false)
             {
             }
             QValuesAxisPrivate::~QValuesAxisPrivate()
             {
             }
             void QValuesAxisPrivate::handleAxisRangeChanged(qreal min, qreal max,int count)
             {
                Q_Q(QValuesAxis);
                q->setRange(min,max);
                q->setTicksCount(count);
             }
-            void QValuesAxisPrivate::setMin(const qreal min)
+            void QValuesAxisPrivate::setMin(const QVariant &min)
             {
-                setRange(min,m_max);
+                Q_Q(QValuesAxis);
+                bool ok;
+                qreal value = min.toReal(&ok);
+                if(ok) q->setMin(value);
             }
-            void QValuesAxisPrivate::setMax(const qreal max)
+            void QValuesAxisPrivate::setMax(const QVariant &max)
             {
-                setRange(m_min,max);
+                Q_Q(QValuesAxis);
+                bool ok;
+                qreal value = max.toReal(&ok);
+                if(ok) q->setMax(value);
             }
-            void QValuesAxisPrivate::setRange(const qreal min, const qreal max, bool force)
+            void QValuesAxisPrivate::setRange(const QVariant &min, const QVariant &max, bool force)
             {
+                Q_UNUSED(force);    // TODO: use this
                 Q_Q(QValuesAxis);
-                bool changed = false;
+                bool ok1;
-                if (!qFuzzyIsNull(m_min - min)) {
+                bool ok2;
-                    m_min = min;
+                qreal value1 = min.toReal(&ok1);
-                    changed = true;
+                qreal value2 = max.toReal(&ok2);
-                    emit q->minChanged(min);
+                if(ok1&&ok2) q->setRange(value1,value2);
-                if (!qFuzzyIsNull(m_max - max)) {
-                    m_max = max;
-                    changed = true;
-                    emit q->maxChanged(max);
-                if ((changed) ||(force)) {
-                   emit q->rangeChanged(m_min,m_max);
-                   emit this->changed(m_min, m_max, m_ticksCount, m_niceNumbers);
             }
             int QValuesAxisPrivate::ticksCount() const
             {
                 return m_ticksCount;
             }
             ChartAxis* QValuesAxisPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QValuesAxis);
                 if(m_orientation == Qt::Vertical){
                     return new ChartValuesAxisY(q,presenter);
                 }else{
                     return new ChartValuesAxisX(q,presenter);
                 }
             }
             void QValuesAxisPrivate::updateRange()
             {
                 setRange(m_min,m_max,true);
             }
             #include "moc_qvaluesaxis.cpp"
             #include "moc_qvaluesaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/qvaluesaxis_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$
             **
             ****************************************************************************/
             //  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 QVALUESAXIS_P_H
             #define QVALUESAXIS_P_H
             #include "qvaluesaxis.h"
             #include "qabstractaxis_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QValuesAxisPrivate : public QAbstractAxisPrivate
             {
                 Q_OBJECT
             public:
                 QValuesAxisPrivate(QValuesAxis *q);
                 ~QValuesAxisPrivate();
             Q_SIGNALS:
                 void changed(qreal min, qreal max, int tickCount,bool niceNumbers);
             public Q_SLOTS:
                 void handleAxisRangeChanged(qreal min, qreal max,int count);
             public:
                 ChartAxis* createGraphics(ChartPresenter* presenter);
                 void updateRange();
             protected:
-                void setMin(const qreal min);
+                void setMin(const QVariant &min);
-                void setMax(const qreal max);
+                void setMax(const QVariant &max);
-                void setRange(const qreal min, const qreal max, bool force = false);
+                void setRange(const QVariant &min, const QVariant &max, bool force = false);
                 int ticksCount() const;
             private:
                 bool m_niceNumbers;
                 Q_DECLARE_PUBLIC(QValuesAxis)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QVALUESAXIS_P_H

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages