HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1575:5c9e4e8ea61d

fixed documentation errors

sauimone -

r1575:5c9e4e8ea61d

parent child

Context file:

r1575:5c9e4e8ea61d

Collapse all files

src/axis/qabstractaxis.cpp +11 -28

             /****************************************************************************
             **
             ** 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 QAxis::labelsFont
+              \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.
             */
             /*!
-              \property QAbstractAxis::ticksCount
-              The number of tick marks for the axis.
-            */
-            /*!
-              \qmlproperty int Axis::ticksCount
-              The number of tick marks for the axis.
-            */
-            /*!
-              \property QAbstractAxis::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.
-            */
-            /*!
               \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)
             {
                 d_ptr->setMin(min);
             }
             void QAbstractAxis::setMax(const qreal max)
             {
                 d_ptr->setMax(max);
             }
             void QAbstractAxis::setRange(const qreal min, const qreal 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/qvaluesaxis.cpp +21 -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 "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);
                 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 QAbstractAxis::ticksCount() const
+              \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)
             {
                 setRange(min,m_max);
             }
             void QValuesAxisPrivate::setMax(const qreal max)
             {
                 setRange(m_min,max);
             }
             void QValuesAxisPrivate::setRange(const qreal min, const qreal max, bool force)
             {
                 Q_Q(QValuesAxis);
                 bool changed = false;
                 if (!qFuzzyIsNull(m_min - min)) {
                     m_min = min;
                     changed = true;
                     emit q->minChanged(min);
                 }
                 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/legend/qlegend.cpp 0 -15

             /****************************************************************************
              **
              ** 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 "qlegend.h"
             #include "qlegend_p.h"
             #include "qabstractseries.h"
             #include "qabstractseries_p.h"
             #include "qchart_p.h"
             #include "legendlayout_p.h"
             #include "legendmarker_p.h"
             #include "qxyseries.h"
             #include "qlineseries.h"
             #include "qareaseries.h"
             #include "qscatterseries.h"
             #include "qsplineseries.h"
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qbarset.h"
             #include "qpieseries.h"
             #include "qpieseries_p.h"
             #include "qpieslice.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
             #include <QPen>
             #include <QTimer>
             #include <QGraphicsLayout>
             #include <QGraphicsSceneEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QLegend
                 \brief Legend object
                 \mainclass
                 QLegend is a graphical object, whics displays legend of the chart. Legend state is updated by QChart, when
                 series have been changed. By default, legend is drawn by QChart, but user can set a new parent to legend and
                 handle the drawing manually.
                 User isn't supposed to create or delete legend objects, but can reference it via QChart class.
                 \image examples_percentbarchart_legend.png
                 \sa QChart
             */
             /*!
                 \qmlclass Legend QLegend
                 \brief Legend is part of QtCommercial Chart QML API.
                 Legend is a graphical object, whics displays legend of the chart. Legend state is updated by ChartView, when
                 series have been changed. Legend is used via ChartView class. For example:
                 \code
                     ChartView {
                         legend.visible: true
                         legend.alignment: Qt.AlignBottom
                         // Add a few series...
                     }
                 \endcode
                 \image examples_percentbarchart_legend.png
             */
             /*!
                 \property QLegend::alignment
                 \brief The alignment of the legend.
                 Legend paints on the defined position in the chart. The following alignments are supported:
                 Qt::AlignTop, Qt::AlignBottom, Qt::AlignLeft, Qt::AlignRight. If you set more than one flag the result is undefined.
             */
             /*!
                 \qmlproperty Qt.Alignment Legend::alignment
                 \brief The alignment of the legend.
                 Legend paints on the defined position in the chart. The following alignments are supported:
                 Qt.AlignTop, Qt.AlignBottom, Qt.AlignLeft, Qt.AlignRight. If you set more than one flag the result is undefined.
             */
             /*!
                 \property QLegend::backgroundVisible
                 Whether the legend background is visible or not.
             */
             /*!
                 \qmlproperty bool Legend::backgroundVisible
                 Whether the legend background is visible or not.
             */
             /*!
                 \property QLegend::color
                 The color of the legend, i.e. the background (brush) color. Note that if you change the color
                 of the legend, the style of the legend brush is set to Qt::SolidPattern.
             */
             /*!
                 \qmlproperty color Legend::color
                 The color of the legend, i.e. the background (brush) color.
             */
             /*!
                 \property QLegend::borderColor
                 The border color of the legend, i.e. the line color.
             */
             /*!
                 \qmlproperty color Legend::borderColor
                 The border color of the legend, i.e. the line color.
             */
             /*!
                 \property QLegend::font
                 The font of markers used by legend
             */
             /*!
                 \qmlproperty color Legend::font
                 The font of markers used by legend
             */
             /*!
                 \property QLegend::labelColor
                 The color of brush used to draw labels.
             */
             /*!
                 \qmlproperty color QLegend::labelColor
                 The color of brush used to draw labels.
             */
             /*!
                 \fn void QLegend::backgroundVisibleChanged(bool)
                 The visibility of the legend background changed to \a visible.
             */
             /*!
                 \fn void QLegend::colorChanged(QColor)
                 The color of the legend background changed to \a color.
             */
             /*!
                 \fn void QLegend::borderColorChanged(QColor)
                 The border color of the legend background changed to \a color.
             */
             /*!
                 \fn void QLegend::fontChanged(QFont)
                 The font of markers of the legend changed to \a font.
             */
             /*!
-                \fn void QLegend::labelBrushChanged(QBrush brush)
-                This signal is emitted when the brush used to draw labels has changed to \a brush.
-            */
-            /*!
                 \fn void QLegend::labelColorChanged(QColor color)
                 This signal is emitted when the color of brush used to draw labels has changed to \a color.
             */
             /*!
-             \fn qreal QLegend::minWidth() const
-             Returns minimum width of the legend
-             */
-            /*!
-             \fn qreal QLegend::minHeight() const
-             Returns minimum height of the legend
-             */
-            /*!
              Constructs the legend object and sets the parent to \a parent
              */
             QLegend::QLegend(QChart *chart):QGraphicsWidget(chart),
             d_ptr(new QLegendPrivate(chart->d_ptr->m_presenter,chart,this))
             {
                 setZValue(ChartPresenter::LegendZValue);
                 setFlags(QGraphicsItem::ItemClipsChildrenToShape);
                 QObject::connect(chart->d_ptr->m_dataset,SIGNAL(seriesAdded(QAbstractSeries*,Domain*)),d_ptr.data(),SLOT(handleSeriesAdded(QAbstractSeries*,Domain*)));
                 QObject::connect(chart->d_ptr->m_dataset,SIGNAL(seriesRemoved(QAbstractSeries*)),d_ptr.data(),SLOT(handleSeriesRemoved(QAbstractSeries*)));
                 QObject::connect(chart->d_ptr->m_dataset,SIGNAL(seriesUpdated(QAbstractSeries*)),d_ptr.data(),SLOT(handleSeriesUpdated(QAbstractSeries*)));
                 setLayout(d_ptr->m_layout);
             }
             /*!
                 Destroys the legend object. Legend is always owned by a QChart, so an application should never call this.
             */
             QLegend::~QLegend()
             {
             }
             /*!
              \internal
              */
             void QLegend::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(option)
                 Q_UNUSED(widget)
                 if(!d_ptr->m_backgroundVisible) return;
                 painter->setOpacity(opacity());
                 painter->setPen(d_ptr->m_pen);
                 painter->setBrush(d_ptr->m_brush);
                 painter->drawRoundRect(rect(),d_ptr->roundness(rect().width()),d_ptr->roundness(rect().height()));
             }
             /*!
              Sets the \a brush of legend. Brush affects the background of legend.
              */
             void QLegend::setBrush(const QBrush &brush)
             {
                 if (d_ptr->m_brush != brush) {
                     d_ptr->m_brush = brush;
                     update();
                     emit colorChanged(brush.color());
                 }
             }
             /*!
              Returns the brush used by legend.
              */
             QBrush QLegend::brush() const
             {
                 return d_ptr->m_brush;
             }
             void QLegend::setColor(QColor color)
             {
                 QBrush b = d_ptr->m_brush;
                 if (b.style() != Qt::SolidPattern || b.color() != color) {
                     b.setStyle(Qt::SolidPattern);
                     b.setColor(color);
                     setBrush(b);
                 }
             }
             QColor QLegend::color()
             {
                 return d_ptr->m_brush.color();
             }
             /*!
              Sets the \a pen of legend. Pen affects the legend borders.
              */
             void QLegend::setPen(const QPen &pen)
             {
                 if (d_ptr->m_pen != pen) {
                     d_ptr->m_pen = pen;
                     update();
                     emit borderColorChanged(pen.color());
                 }
             }
             /*!
              Returns the pen used by legend
              */
             QPen QLegend::pen() const
             {
                 return d_ptr->m_pen;
             }
             void QLegend::setFont(const QFont &font)
             {
                 if (d_ptr->m_font != font) {
                     d_ptr->m_font = font;
                     foreach (LegendMarker *marker, d_ptr->markers()) {
                         marker->setFont(d_ptr->m_font);
                     }
                     layout()->invalidate();
                     emit fontChanged(font);
                 }
             }
             QFont QLegend::font() const
             {
                return d_ptr->m_font;
             }
             void QLegend::setBorderColor(QColor color)
             {
                 QPen p = d_ptr->m_pen;
                 if (p.color() != color) {
                     p.setColor(color);
                     setPen(p);
                 }
             }
             QColor QLegend::borderColor()
             {
                 return d_ptr->m_pen.color();
             }
             /*!
                 Set brush used to draw labels to \a brush.
             */
             void QLegend::setLabelBrush(const QBrush &brush)
             {
                 if (d_ptr->m_labelBrush != brush) {
                     d_ptr->m_labelBrush = brush;
                     foreach (LegendMarker *marker, d_ptr->markers()) {
                         marker->setLabelBrush(d_ptr->m_labelBrush);
                     }
                     emit labelColorChanged(brush.color());
                 }
             }
             /*!
                 Brush used to draw labels.
             */
             QBrush QLegend::labelBrush() const
             {
                 return d_ptr->m_labelBrush;
             }
             void QLegend::setLabelColor(QColor color)
             {
                 QBrush b = d_ptr->m_labelBrush;
                 if (b.style() != Qt::SolidPattern || b.color() != color) {
                     b.setStyle(Qt::SolidPattern);
                     b.setColor(color);
                     setLabelBrush(b);
                 }
             }
             QColor QLegend::labelColor() const
             {
                 return d_ptr->m_labelBrush.color();
             }
             void QLegend::setAlignment(Qt::Alignment alignment)
             {
                 if(d_ptr->m_alignment!=alignment) {
                     d_ptr->m_alignment = alignment;
                     updateGeometry();
                     if(isAttachedToChart()){
                         d_ptr->m_presenter->layout()->invalidate();
                     }else{
                         layout()->invalidate();
                     }
                 }
             }
             Qt::Alignment QLegend::alignment() const
             {
                 return d_ptr->m_alignment;
             }
             /*!
              Detaches the legend from chart. Chart won't change layout of the legend.
              */
             void QLegend::detachFromChart()
             {
                 d_ptr->m_attachedToChart = false;
                 d_ptr->m_layout->invalidate();
                 setParent(0);
             }
             /*!
              Attaches the legend to chart. Chart may change layout of the legend.
              */
             void QLegend::attachToChart()
             {
                 d_ptr->m_attachedToChart = true;
                 d_ptr->m_layout->invalidate();
                 setParent(d_ptr->m_chart);
             }
             /*!
              Returns true, if legend is attached to chart.
              */
             bool QLegend::isAttachedToChart()
             {
                 return d_ptr->m_attachedToChart;
             }
             /*!
              Sets the visibility of legend background to \a visible
              */
             void QLegend::setBackgroundVisible(bool visible)
             {
                 if(d_ptr->m_backgroundVisible != visible) {
                     d_ptr->m_backgroundVisible = visible;
                     update();
                     emit backgroundVisibleChanged(visible);
                 }
             }
             /*!
              Returns the visibility of legend background
              */
             bool QLegend::isBackgroundVisible() const
             {
                 return d_ptr->m_backgroundVisible;
             }
             /*!
              \internal \a event see QGraphicsWidget for details
              */
             void QLegend::hideEvent(QHideEvent *event)
             {
                 QGraphicsWidget::hideEvent(event);
                 d_ptr->m_presenter->layout()->invalidate();
             }
             /*!
              \internal \a event see QGraphicsWidget for details
              */
             void QLegend::showEvent(QShowEvent *event)
             {
                 QGraphicsWidget::showEvent(event);
                 d_ptr->m_presenter->layout()->invalidate();
             }
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QLegendPrivate::QLegendPrivate(ChartPresenter* presenter, QChart *chart, QLegend *q):
                 q_ptr(q),
                 m_presenter(presenter),
                 m_layout(new LegendLayout(q)),
                 m_chart(chart),
                 m_items(new QGraphicsItemGroup(q)),
                 m_alignment(Qt::AlignTop),
                 m_brush(QBrush()),
                 m_pen(QPen()),
                 m_labelBrush(QBrush()),
                 m_diameter(5),
                 m_attachedToChart(true),
                 m_backgroundVisible(false)
             {
             }
             QLegendPrivate::~QLegendPrivate()
             {
             }
             void QLegendPrivate::setOffset(qreal x, qreal y)
             {
                m_layout->setOffset(x,y);
             }
             QPointF QLegendPrivate::offset() const
             {
                 return m_layout->offset();
             }
             int QLegendPrivate::roundness(qreal size)
             {
                 return 100*m_diameter/int(size);
             }
             void QLegendPrivate::handleSeriesAdded(QAbstractSeries *series, Domain *domain)
             {
                 Q_UNUSED(domain)
                 QList<LegendMarker*> markers = series->d_ptr->createLegendMarker(q_ptr);
                 foreach(LegendMarker* marker, markers) {
                     marker->setFont(m_font);
                     marker->setLabelBrush(m_labelBrush);
                     m_items->addToGroup(marker);
                     m_markers<<marker;
                 }
                 QObject::connect(series, SIGNAL(visibleChanged()), this, SLOT(handleSeriesVisibleChanged()));
                 if(series->type() == QAbstractSeries::SeriesTypePie) {
                     QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
                     QObject::connect(pieSeries, SIGNAL(added(QList<QPieSlice*>)), this, SLOT(handleUpdatePieSeries()));
                     QObject::connect(pieSeries, SIGNAL(removed(QList<QPieSlice*>)), this, SLOT(handleUpdatePieSeries()));
                 }
                 q_ptr->layout()->invalidate();
                 q_ptr->layout()->activate();
             }
             void QLegendPrivate::handleSeriesRemoved(QAbstractSeries *series)
             {
                 foreach (LegendMarker *marker, m_markers) {
                     if (marker->series() == series) {
                         delete marker;
                         m_markers.removeAll(marker);
                     }
                 }
                 if(series->type() == QAbstractSeries::SeriesTypePie)
                 {
                     QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
                     QObject::disconnect(pieSeries, SIGNAL(added(QList<QPieSlice*>)), this, SLOT(handleUpdatePieSeries()));
                     QObject::disconnect(pieSeries, SIGNAL(removed(QList<QPieSlice*>)), this, SLOT(handleUpdatePieSeries()));
                 }
                 q_ptr->layout()->invalidate();
             }
             void QLegendPrivate::handleSeriesUpdated(QAbstractSeries *series)
             {
                 // TODO: find out which markers are are added or removed. Update them
                 // TODO: better implementation
                 handleSeriesRemoved(series);
                 Domain domain;
                 handleSeriesAdded(series, &domain);
             }
             void QLegendPrivate::handleUpdatePieSeries()
             {
                 //TODO: reimplement to be optimal
                 QPieSeries* series = qobject_cast<QPieSeries *> (sender());
                 Q_ASSERT(series);
                 handleSeriesRemoved(series);
                 handleSeriesAdded(series, 0);
             }
             void QLegendPrivate::handleSeriesVisibleChanged()
             {
                 QAbstractSeries* series = qobject_cast<QAbstractSeries *> (sender());
                 foreach (LegendMarker* marker, m_markers) {
                     if (marker->series() == series) {
                         marker->setVisible(!marker->isVisible());
                     }
                 }
                 q_ptr->layout()->invalidate();
             }
             #include "moc_qlegend.cpp"
             #include "moc_qlegend_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchart.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 "qchart.h"
             #include "qchart_p.h"
             #include "legendscroller_p.h"
             #include "qlegend_p.h"
             #include "chartbackground_p.h"
             #include "qabstractaxis.h"
             #include <QGraphicsScene>
             #include <QGraphicsSceneResizeEvent>
             #include <QGraphicsLayout>
             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 series and other chart related objects like
              QAxis and QLegend. If you simply want to show a chart in a layout, you can use the
              convenience class QChartView instead of QChart.
              \sa QChartView
              */
             /*!
              \property QChart::animationOptions
              The animation \a options for the chart. Animations are enabled/disabled based on this setting.
              */
             /*!
              \property QChart::backgroundVisible
              Whether the chart background is visible or not.
              \sa setBackgroundBrush(), setBackgroundPen()
              */
             /*!
              \property QChart::dropShadowEnabled
              If set to true, the background drop shadow effect is enabled. If set to false, it is disabled. Note that the drop
              shadow effect depends on theme, which means the setting may be changed if you switch to another theme.
              */
             /*!
              \property QChart::margins
              Margins around the plot area. Note that the margin area is used for drawing chart title, legend and axes.
              */
             /*!
              \property QChart::theme
              Theme is a built-in collection of UI style related settings applied for all visual elements of a chart, like colors,
              pens, brushes and fonts of series, axes, title and legend. \l {Chart themes demo} shows an example with a few
              different themes.
              Note: changing the theme will overwrite all customizations previously applied to the series.
              */
             /*!
              \property QChart::title
              Title is the name (label) of a chart. It is shown as a headline on top of the chart.
              */
             /*!
              \fn void QChart::marginsChanged(QRectF newMargins)
              The margins around plot area have changed to \a newMargins. This may happen for example if you change title font size,
              modify axes or hide/show legend.
              */
             /*!
              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);
                 //connect(d_ptr->m_presenter, SIGNAL(marginsChanged(QRectF)), this, SIGNAL(marginsChanged(QRectF)));
                 setLayout(d_ptr->m_presenter->layout());
             }
             /*!
              Destroys the object and it's children, like series and axis objects added to it.
              */
             QChart::~QChart()
             {
                 //delete first presenter , since this is a root of all the graphical items
                 setLayout(0);
                 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.
+             Adds the \a series onto the chart and takes the ownership of the object.
              If auto scaling is enabled, re-scales the axes the series is bound to (both the x axis and
              the y axis).
              \sa removeSeries(), removeAllSeries()
              */
             void QChart::addSeries(QAbstractSeries *series)
             {
                 Q_ASSERT(series);
                 d_ptr->m_dataset->addSeries(series);
             }
             /*!
              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)
             {
                 d_ptr->m_presenter->setBackgroundBrush(brush);
             }
             /*!
                 Gets the brush that is used for painting the background of the chart area.
              */
             QBrush QChart::backgroundBrush() const
             {
                 return d_ptr->m_presenter->backgroundBrush();
             }
             /*!
              Sets the \a pen that is used for painting the background of the chart area.
              */
             void QChart::setBackgroundPen(const QPen& pen)
             {
                 d_ptr->m_presenter->setBackgroundPen(pen);
             }
             /*!
                 Gets the pen that is used for painting the background of the chart area.
              */
             QPen QChart::backgroundPen() const
             {
                 return d_ptr->m_presenter->backgroundPen();
             }
             /*!
              Sets the chart \a title. The description text that is drawn above the chart.
              */
             void QChart::setTitle(const QString& title)
             {
                 d_ptr->m_presenter->setTitle(title);
             }
             /*!
              Returns the chart title. The description text that is drawn above the chart.
              */
             QString QChart::title() const
             {
                 return d_ptr->m_presenter->title();
             }
             /*!
              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)
             {
                 d_ptr->m_presenter->setTitleFont(font);
             }
             /*!
                 Gets the font that is used for drawing the chart description text that is rendered above the chart.
              */
             QFont QChart::titleFont() const
             {
                 return d_ptr->m_presenter->titleFont();
             }
             /*!
              Sets the \a brush used for rendering the title text.
              */
             void QChart::setTitleBrush(const QBrush &brush)
             {
                 d_ptr->m_presenter->setTitleBrush(brush);
             }
             /*!
              Returns the brush used for rendering the title text.
              */
             QBrush QChart::titleBrush() const
             {
                 return d_ptr->m_presenter->titleBrush();
             }
             void QChart::setTheme(QChart::ChartTheme theme)
             {
                 d_ptr->m_presenter->setTheme(theme);
             }
             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(2.0);
             }
             /*!
              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(2.0);
             }
             /*!
              Zooms in the view by a \a factor.
              A factor over 1.0 zooms the view in and factor between 0.0 and 1.0 zooms out.
              */
             void QChart::zoom(qreal factor)
             {
                 if (qFuzzyIsNull(factor))
                     return;
                 if (qFuzzyCompare(factor, 1.0))
                     return;
                 if (factor < 0)
                     return;
                 if (factor > 1.0)
                     d_ptr->m_presenter->zoomIn(factor);
                 else
                     d_ptr->m_presenter->zoomOut(1.0 / factor);
             }
             /*!
              Returns the pointer to the x axis object of the chart
              */
             QAbstractAxis* QChart::axisX(QAbstractSeries* series) const
             {
                 return d_ptr->m_dataset->axisX(series);
             }
             /*!
              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.
              */
             QAbstractAxis* 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();
             }
             /*!
              Sets animation \a options for the chart
              */
             void QChart::setAnimationOptions(AnimationOptions options)
             {
                 d_ptr->m_presenter->setAnimationOptions(options);
             }
             QChart::AnimationOptions QChart::animationOptions() const
             {
                 return d_ptr->m_presenter->animationOptions();
             }
             /*!
-                Scrolls the visible area of the chart by the distance defined in the \a delta.
+                Scrolls the visible area of the chart by the distance defined in the \a dx and \a dy.
              */
             void QChart::scroll(qreal dx, qreal dy)
             {
                 d_ptr->m_presenter->scroll(dx, dy);
             }
             void QChart::setBackgroundVisible(bool visible)
             {
                 d_ptr->m_presenter->setBackgroundVisible(visible);
             }
             bool QChart::isBackgroundVisible() const
             {
                 return d_ptr->m_presenter->isBackgroundVisible();
             }
             void QChart::setDropShadowEnabled(bool enabled)
             {
                 d_ptr->m_presenter->setBackgroundDropShadowEnabled(enabled);
             }
             bool QChart::isDropShadowEnabled() const
             {
                 return d_ptr->m_presenter->isBackgroundDropShadowEnabled();
             }
             /*!
               Returns all the series that are added to the chart.
               \sa addSeries(), removeSeries(), removeAllSeries()
             */
             QList<QAbstractSeries*> QChart::series() const
             {
                 return d_ptr->m_dataset->series();
             }
             void QChart::setMarginsMinimum(const QRectF& margins)
             {
                 d_ptr->m_presenter->setMarginsMinimum(margins);
             }
             void QChart::setAxisX(QAbstractSeries *series, QAbstractAxis* axis)
             {
                 d_ptr->m_dataset->setAxisX(series, axis);
             }
             void QChart::setAxisY(QAbstractSeries *series, QAbstractAxis* axis)
             {
                 d_ptr->m_dataset->setAxisY(series, axis);
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             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(QAbstractAxis*,Domain*)),m_presenter,SLOT(handleAxisAdded(QAbstractAxis*,Domain*)));
                 QObject::connect(m_dataset,SIGNAL(axisRemoved(QAbstractAxis*)),m_presenter,SLOT(handleAxisRemoved(QAbstractAxis*)));
                 //QObject::connect(m_presenter, SIGNAL(marginsChanged(QRectF)), q_ptr, SIGNAL(marginsChanged(QRectF)));
             }
             #include "moc_qchart.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

General Comments 0

Write
Preview

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

No TODOs yet

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

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