HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2284:5ea9e4fa75c8

Adds domains swap logic

Michal Klocek -

r2284:5ea9e4fa75c8

parent child

Context file:

r2284:5ea9e4fa75c8

Collapse all files

src/axis/qabstractaxis.cpp +1 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$
             **
             ****************************************************************************/
             #include "qabstractaxis.h"
             #include "qabstractaxis_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_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 visible at the time, 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 AbstractAxis QAbstractAxis
                 \brief The Axis element is used for manipulating chart's axes
                 There is only one x Axis visible at the time, 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 AxisTypeNoAxis
                 \value AxisTypeValue
                 \value AxisTypeBarCategory
                 \value AxisTypeCategory
                 \value AxisTypeDateTime
             */
             /*!
              *\fn void QAbstractAxis::type() const
               Returns the type of the axis
             */
             /*!
               \property QAbstractAxis::lineVisible
               The visibility of the axis line
             */
             /*!
               \qmlproperty bool AbstractAxis::lineVisible
               The visibility of the axis line
             */
             /*!
               \property QAbstractAxis::labelsVisible
               Defines if axis labels are visible.
             */
             /*!
               \qmlproperty bool AbstractAxis::labelsVisible
               Defines if axis labels are visible.
             */
             /*!
               \property QAbstractAxis::visible
               The visibility of the axis.
             */
             /*!
               \qmlproperty bool AbstractAxis::visible
               The visibility of the axis.
             */
             /*!
               \property QAbstractAxis::gridVisible
               The visibility of the grid lines.
             */
             /*!
               \qmlproperty bool AbstractAxis::gridVisible
               The visibility of the grid lines.
             */
             /*!
               \property QAbstractAxis::color
               The color of the axis and ticks.
             */
             /*!
               \qmlproperty color AbstractAxis::color
               The color of the axis and ticks.
             */
             /*!
               \property QAbstractAxis::labelsFont
               The font of the axis labels.
             */
             /*!
               \qmlproperty Font AbstractAxis::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 AbstractAxis::labelsColor
               The color of the axis labels.
             */
             /*!
               \property QAbstractAxis::labelsAngle
               The angle of the axis labels in degrees.
             */
             /*!
               \qmlproperty int AbstractAxis::labelsAngle
               The angle of the axis labels in degrees.
             */
             /*!
               \property QAbstractAxis::shadesVisible
               The visibility of the axis shades.
             */
             /*!
               \qmlproperty bool AbstractAxis::shadesVisible
               The visibility of the axis shades.
             */
             /*!
               \property QAbstractAxis::shadesColor
               The fill (brush) color of the axis shades.
             */
             /*!
               \qmlproperty color AbstractAxis::shadesColor
               The fill (brush) color of the axis shades.
             */
             /*!
               \property QAbstractAxis::shadesBorderColor
               The border (pen) color of the axis shades.
             */
             /*!
               \qmlproperty color AbstractAxis::shadesBorderColor
               The border (pen) color of the axis shades.
             */
             /*!
               \property QAbstractAxis::titleVisible
               The visibility of the axis title. By default the value is true.
             */
             /*!
               \qmlproperty bool AbstractAxis::titleVisible
               The visibility of the axis title. By default the value is true.
             */
             /*!
               \property QAbstractAxis::titleFont
               The font of the title of the axis.
             */
             /*!
               \qmlproperty Font AbstractAxis::title
               The font of the title of the axis.
             */
             /*!
               \property QAbstractAxis::title
               The title of the axis. Empty by default.
             */
             /*!
               \qmlproperty string AbstractAxis::title
               The title of the axis. Empty string by default.
             */
             /*!
               \property QAbstractAxis::alignment
               The alignment of the axis. Either Qt::AlignLeft or Qt::AlignBottom.
             */
             /*!
               \qmlproperty alignment AbstractAxis::alignment
               The alignment of the axis. Either Qt.AlignLeft or Qt.AlignBottom.
             */
             /*!
               \fn void QAbstractAxis::visibleChanged(bool visible)
               Visibility of the axis has changed to \a visible.
             */
             /*!
               \qmlsignal AbstractAxis::onVisibleChanged(bool visible)
               Visibility of the axis has changed to \a visible.
             */
             /*!
               \fn void QAbstractAxis::lineVisibleChanged(bool visible)
               Visibility of the axis line has changed to \a visible.
             */
             /*!
               \qmlsignal AbstractAxis::onLineVisibleChanged(bool visible)
               Visibility of the axis line has changed to \a visible.
             */
             /*!
               \fn void QAbstractAxis::labelsVisibleChanged(bool visible)
               Visibility of the labels of the axis has changed to \a visible.
             */
             /*!
               \qmlsignal AbstractAxis::onLabelsVisibleChanged(bool visible)
               Visibility of the labels of the axis has changed to \a visible.
             */
             /*!
               \fn void QAbstractAxis::gridVisibleChanged(bool visible)
               Visibility of the grid lines of the axis has changed to \a visible.
             */
             /*!
               \qmlsignal AbstractAxis::onGridVisibleChanged(bool visible)
               Visibility of the grid lines of the axis has changed to \a visible.
             */
             /*!
               \fn void QAbstractAxis::colorChanged(QColor color)
               Emitted if the \a color of the axis is changed.
             */
             /*!
               \qmlsignal AbstractAxis::onColorChanged(QColor color)
               Emitted if the \a color of the axis is changed.
             */
             /*!
               \fn void QAbstractAxis::labelsColorChanged(QColor color)
               Emitted if the \a color of the axis labels is changed.
             */
             /*!
               \qmlsignal AbstractAxis::onLabelsColorChanged(QColor color)
               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.
             */
             /*!
               \qmlsignal AbstractAxis::onShadesVisibleChanged(bool visible)
               Emitted if the visibility of the axis shades is changed to \a visible.
             */
             /*!
               \fn void QAbstractAxis::shadesColorChanged(QColor color)
               Emitted if the \a color of the axis shades is changed.
             */
             /*!
               \qmlsignal AbstractAxis::onShadesColorChanged(QColor color)
               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.
             */
             /*!
               \qmlsignal AbstractAxis::onBorderColorChanged(QColor color)
               Emitted if the border \a color of the axis shades is changed.
             */
             /*!
              \internal
               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()
             {
                 if (d_ptr->m_chart)
                     qFatal("Still binded axis detected !");
             }
             /*!
               Sets \a pen used to draw axis line and ticks.
              */
             void QAbstractAxis::setLinePen(const QPen &pen)
             {
                 if (d_ptr->m_axisPen != pen) {
                     d_ptr->m_axisPen = pen;
                     emit linePenChanged(pen);
                 }
             }
             /*!
               Returns pen used to draw axis and ticks.
             */
             QPen QAbstractAxis::linePen() const
             {
                 return d_ptr->m_axisPen;
             }
             //TODO: remove me
             void QAbstractAxis::setLinePenColor(QColor color)
             {
                 QPen p = d_ptr->m_axisPen;
                 if (p.color() != color) {
                     p.setColor(color);
                     setLinePen(p);
                     emit colorChanged(color);
                 }
             }
             QColor QAbstractAxis::linePenColor() const
             {
                 return d_ptr->m_axisPen.color();
             }
             /*!
               Sets if axis and ticks are \a visible.
              */
             void QAbstractAxis::setLineVisible(bool visible)
             {
                 if (d_ptr->m_arrowVisible != visible) {
                     d_ptr->m_arrowVisible = visible;
                     emit lineVisibleChanged(visible);
                 }
             }
             bool QAbstractAxis::isLineVisible() const
             {
                 return d_ptr->m_arrowVisible;
             }
             void QAbstractAxis::setGridLineVisible(bool visible)
             {
                 if (d_ptr->m_gridLineVisible != visible) {
                     d_ptr->m_gridLineVisible = visible;
                     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 gridLinePenChanged(pen);
                 }
             }
             /*!
               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 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 labelsPenChanged(pen);
                 }
             }
             /*!
               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 labelsBrushChanged(brush);
                 }
             }
             /*!
               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 labelsFontChanged(font);
                 }
             }
             /*!
               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 labelsAngleChanged(angle);
                 }
             }
             int QAbstractAxis::labelsAngle() const
             {
                 return d_ptr->m_labelsAngle;
             }
             //TODO: remove me
             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::setTitleVisible(bool visible)
             {
                 if (d_ptr->m_titleVisible != visible) {
                     d_ptr->m_titleVisible = visible;
                     emit labelsVisibleChanged(visible);
                 }
             }
             bool QAbstractAxis::titleVisible() const
             {
                 return d_ptr->m_titleVisible;
             }
             /*!
               Sets \a pen used to draw title.
             */
             void QAbstractAxis::setTitlePen(const QPen &pen)
             {
                 if (d_ptr->m_titlePen != pen) {
                     d_ptr->m_titlePen = pen;
                     emit titlePenChanged(pen);
                 }
             }
             /*!
               Returns the pen used to title.
             */
             QPen QAbstractAxis::titlePen() const
             {
                 return d_ptr->m_titlePen;
             }
             /*!
               Sets \a brush used to draw title.
              */
             void QAbstractAxis::setTitleBrush(const QBrush &brush)
             {
                 if (d_ptr->m_titleBrush != brush) {
                     d_ptr->m_titleBrush = brush;
                     emit titleBrushChanged(brush);
                 }
             }
             /*!
               Returns brush used to draw title.
             */
             QBrush  QAbstractAxis::titleBrush() const
             {
                 return d_ptr->m_titleBrush;
             }
             /*!
               Sets \a font used to draw title.
             */
             void QAbstractAxis::setTitleFont(const QFont &font)
             {
                 if (d_ptr->m_titleFont != font) {
                     d_ptr->m_titleFont = font;
                     emit titleFontChanged(font);
                 }
             }
             /*!
               Returns font used to draw title.
             */
             QFont QAbstractAxis::titleFont() const
             {
                 return d_ptr->m_titleFont;
             }
             void QAbstractAxis::setTitleText(const QString &title)
             {
                 if (d_ptr->m_title != title) {
                     d_ptr->m_title = title;
                     emit titleTextChanged(title);
                 }
             }
             QString QAbstractAxis::titleText() const
             {
                 return d_ptr->m_title;
             }
             void QAbstractAxis::setShadesVisible(bool visible)
             {
                 if (d_ptr->m_shadesVisible != visible) {
                     d_ptr->m_shadesVisible = visible;
                     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 shadesPenChanged(pen);
                 }
             }
             /*!
               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 shadesBrushChanged(brush);
                 }
             }
             /*!
                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;
                 if (b.color() != color) {
                     b.setColor(color);
                     setShadesBrush(b);
                     emit shadesColorChanged(color);
                 }
             }
             QColor QAbstractAxis::shadesColor() const
             {
                 return d_ptr->m_shadesBrush.color();
             }
             void QAbstractAxis::setShadesBorderColor(QColor color)
             {
             	QPen p = d_ptr->m_shadesPen;
             	if (p.color() != color) {
             		p.setColor(color);
             		setShadesPen(p);
             		emit shadesColorChanged(color);
             	}
             }
             QColor QAbstractAxis::shadesBorderColor() const
             {
                 return d_ptr->m_shadesPen.color();
             }
             bool QAbstractAxis::isVisible() const
             {
                 return d_ptr->m_visible;
             }
             /*!
               Sets axis, shades, labels and grid lines to be visible.
             */
             void QAbstractAxis::setVisible(bool visible)
             {
                 if (d_ptr->m_visible != visible) {
                     d_ptr->m_visible = visible;
                     emit visibleChanged(visible);
                 }
             }
             /*!
               Sets axis, shades, labels and grid lines to be visible.
             */
             void QAbstractAxis::show()
             {
                 setVisible(true);
             }
             /*!
               Sets axis, shades, labels and grid lines to not be visible.
             */
             void QAbstractAxis::hide()
             {
                 setVisible(false);
             }
             /*!
               Sets the minimum value shown on the axis.
               Depending on the actual axis type the \a min parameter is converted to appropriate type.
               If the conversion is impossible then the function call does nothing
             */
             void QAbstractAxis::setMin(const QVariant &min)
             {
                 d_ptr->setMin(min);
             }
             /*!
               Sets the maximum value shown on the axis.
               Depending on the actual axis type the \a max parameter is converted to appropriate type.
               If the conversion is impossible then the function call does nothing
             */
             void QAbstractAxis::setMax(const QVariant &max)
             {
                 d_ptr->setMax(max);
             }
             /*!
               Sets the range shown on the axis.
               Depending on the actual axis type the \a min and \a max parameters are converted to appropriate types.
               If the conversion is impossible then the function call does nothing.
             */
             void QAbstractAxis::setRange(const QVariant &min, const QVariant &max)
             {
                 d_ptr->setRange(min, max);
             }
             /*!
               Returns the orientation in which the axis is being used (Vertical or Horizontal)
             */
             // NOTE: should have const but it breaks BC:
             // http://techbase.kde.org/Policies/Binary_Compatibility_Examples#Change_the_CV-qualifiers_of_a_member_function
             Qt::Orientation QAbstractAxis::orientation()
             {
                 return d_ptr->orientation();
             }
             Qt::Alignment QAbstractAxis::alignment() const
             {
                 return d_ptr->alignment();
             }
             /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QAbstractAxisPrivate::QAbstractAxisPrivate(QAbstractAxis *q)
                 : q_ptr(q),
                   m_chart(0),
                   m_orientation(Qt::Orientation(0)),
                   m_alignment(0),
                   m_visible(true),
                   m_arrowVisible(true),
                   m_gridLineVisible(true),
                   m_labelsVisible(true),
                   m_labelsAngle(0),
                   m_shadesVisible(false),
                   m_shadesBrush(Qt::SolidPattern),
                   m_shadesOpacity(1.0),
                   m_dirty(false)
             {
             }
             QAbstractAxisPrivate::~QAbstractAxisPrivate()
             {
             }
             void QAbstractAxisPrivate::setAlignment( Qt::Alignment alignment)
             {
                 switch(alignment) {
                     case Qt::AlignTop:
                     case Qt::AlignBottom:
                     m_orientation = Qt::Horizontal;
                     break;
                     case Qt::AlignLeft:
                     case Qt::AlignRight:
                     m_orientation = Qt::Vertical;
                     break;
                     default:
                     qWarning()<<"No alignment specified !";
                     break;
                 };
                 m_alignment=alignment;
             }
             void QAbstractAxisPrivate::initializeTheme(ChartTheme* theme, bool forced)
             {
                 QPen pen;
                 QBrush brush;
                 QFont font;
                 bool axisX = m_orientation == Qt::Horizontal;
                 if (m_arrowVisible) {
                     if (forced || brush == m_labelsBrush){
                         q_ptr->setLabelsBrush(theme->labelBrush());
                     }
                     //TODO: introduce axis brush
                     if (forced || brush == m_titleBrush){
                         q_ptr->setTitleBrush(theme->labelBrush());
                     }
                     if (forced || pen == m_labelsPen){
                         q_ptr->setLabelsPen(Qt::NoPen);// NoPen for performance reasons
                     }
                     if (forced || pen == m_titlePen){
                         q_ptr->setTitlePen(Qt::NoPen);// Noen for performance reasons
                     }
                     if (forced || m_shadesVisible) {
                         if (forced || brush == m_shadesBrush){
                             q_ptr->setShadesBrush(theme->backgroundShadesBrush());
                         }
                         if (forced || pen == m_shadesPen){
                             q_ptr->setShadesPen(theme->backgroundShadesPen());
                         }
                         if (forced && (theme->backgroundShades() == ChartTheme::BackgroundShadesBoth
                                 || (theme->backgroundShades() == ChartTheme::BackgroundShadesVertical && axisX)
                                 || (theme->backgroundShades() == ChartTheme::BackgroundShadesHorizontal && !axisX))) {
                         	 q_ptr->setShadesVisible(true);
                         }
                     }
             		if (forced || pen == m_axisPen) {
             			q_ptr->setLinePen(theme->axisLinePen());
             		}
             		if (forced || pen == m_gridLinePen) {
             			q_ptr->setGridLinePen(theme->girdLinePen());
             		}
                     if (forced || font == m_labelsFont){
                     	q_ptr->setLabelsFont(theme->labelFont());
                     }
                     //TODO: discuss with Tero
                     if (forced || font == m_titleFont){
                         QFont font(m_labelsFont);
                         font.setBold(true);
                         q_ptr->setTitleFont(font);
                     }
                 }
             }
             void QAbstractAxisPrivate::handleRangeChanged(qreal min, qreal max)
             {
                 setRange(min,max);
             }
             void QAbstractAxisPrivate::initializeGraphics(QGraphicsItem* parent)
             {
                 Q_UNUSED(parent);
             }
             void QAbstractAxisPrivate::initializeAnimations(QChart::AnimationOptions options)
             {
                 ChartAxis* axis = m_item.data();
                 Q_ASSERT(axis);
                 if(options.testFlag(QChart::GridAxisAnimations)) {
                     axis->setAnimation(new AxisAnimation(axis));
                 }else{
                     axis->setAnimation(0);
                 }
             }
             #include "moc_qabstractaxis.cpp"
             #include "moc_qabstractaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/qabstractaxis.h +1 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 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
                 //visibility
                 Q_PROPERTY(bool visible READ isVisible WRITE setVisible NOTIFY visibleChanged)
                 //arrow
                 Q_PROPERTY(bool lineVisible READ isLineVisible WRITE setLineVisible NOTIFY lineVisibleChanged)
                 Q_PROPERTY(QPen linePen READ linePen WRITE setLinePen NOTIFY linePenChanged)
                 //TODO: make wrapping of color for qml
                 Q_PROPERTY(QColor color READ linePenColor WRITE setLinePenColor NOTIFY colorChanged)
                 //labels
                 Q_PROPERTY(bool labelsVisible READ labelsVisible WRITE setLabelsVisible NOTIFY labelsVisibleChanged)
                 Q_PROPERTY(QPen lablesPen READ labelsPen WRITE setLabelsPen NOTIFY labelsPenChanged)
                 Q_PROPERTY(QBrush lablesBrush READ labelsBrush WRITE setLabelsBrush NOTIFY labelsBrushChanged)
                 //TODO: fix labels angles to work with layout
                 Q_PROPERTY(int labelsAngle READ labelsAngle WRITE setLabelsAngle NOTIFY labelsAngleChanged)
                 Q_PROPERTY(QFont labelsFont READ labelsFont WRITE setLabelsFont NOTIFY labelsFontChanged)
                 //TODO: make wrapping of color for qml
                 Q_PROPERTY(QColor labelsColor READ labelsColor WRITE setLabelsColor NOTIFY labelsColorChanged)
                 //grid
                 Q_PROPERTY(bool gridVisible READ isGridLineVisible WRITE setGridLineVisible NOTIFY gridVisibleChanged)
                 Q_PROPERTY(QPen girdLinePen READ gridLinePen WRITE setGridLinePen NOTIFY gridLinePenChanged)
                 //shades
                 Q_PROPERTY(bool shadesVisible READ shadesVisible WRITE setShadesVisible NOTIFY shadesVisibleChanged)
                 //TODO: make wrapping of color for qml
                 Q_PROPERTY(QColor shadesColor READ shadesColor WRITE setShadesColor NOTIFY shadesColorChanged)
                 //TODO: make wrapping of border for qml
                 Q_PROPERTY(QColor shadesBorderColor READ shadesBorderColor WRITE setShadesBorderColor NOTIFY shadesBorderColorChanged)
                 Q_PROPERTY(QPen shadesPen READ shadesPen WRITE setShadesPen NOTIFY shadesPenChanged)
                 Q_PROPERTY(QBrush shadesBrush READ shadesBrush WRITE setShadesBrush NOTIFY shadesBrushChanged)
                 //title
                 Q_PROPERTY(QString titleText READ titleText WRITE setTitleText NOTIFY titleTextChanged)
                 Q_PROPERTY(QPen titlePen READ titlePen WRITE setTitlePen NOTIFY titlePenChanged)
                 Q_PROPERTY(QBrush titleBrush READ titleBrush WRITE setTitleBrush NOTIFY titleBrushChanged)
                 Q_PROPERTY(bool titleVisible READ titleVisible WRITE setTitleVisible)
                 Q_PROPERTY(QFont titleFont READ titleFont WRITE setTitleFont)
                 //orientation
                 Q_PROPERTY(Qt::Orientation orinetation READ orientation)
                 //aligment
                 Q_PROPERTY(Qt::Alignment alignment READ alignment)
             public:
                 enum AxisType {
                     AxisTypeNoAxis = 0x0,
                     AxisTypeValue = 0x1,
                     AxisTypeBarCategory = 0x2,
                     AxisTypeCategory = 0x3,
                     AxisTypeDateTime = 0x4,
                     AxisTypeLogValue = 0x5
                 };
                 Q_DECLARE_FLAGS(AxisTypes, AxisType)
             protected:
                 explicit QAbstractAxis(QAbstractAxisPrivate &d, QObject *parent = 0);
             public:
                 ~QAbstractAxis();
                 virtual AxisType type() const = 0;
                 //visibility handling
                 bool isVisible() const;
                 void setVisible(bool visible = true);
                 void show();
                 void hide();
                 //arrow handling
                 bool isLineVisible() const;
                 void setLineVisible(bool visible = true);
                 void setLinePen(const QPen &pen);
                 QPen linePen() const;
                 void setLinePenColor(QColor color);
                 QColor linePenColor() 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;
                 //title handling
                 bool titleVisible() const;
                 void setTitleVisible(bool visible = true);
                 void setTitlePen(const QPen &pen);
                 QPen titlePen() const;
                 void setTitleBrush(const QBrush &brush);
                 QBrush titleBrush() const;
                 void setTitleFont(const QFont &font);
                 QFont titleFont() const;
                 void setTitleText(const QString &title);
                 QString titleText() 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;
                 Qt::Orientation orientation(); //TODO: missing const <- BC
                 Qt::Alignment alignment() const;
                 //range handling
                 void setMin(const QVariant &min);
                 void setMax(const QVariant &max);
                 void setRange(const QVariant &min, const QVariant &max);
             Q_SIGNALS:
                 void visibleChanged(bool visible);
                 void linePenChanged(const QPen& pen);
                 void lineVisibleChanged(bool visible);
                 void labelsVisibleChanged(bool visible);
                 void labelsPenChanged(const QPen& pen);
                 void labelsBrushChanged(const QBrush& brush);
                 void labelsFontChanged(const QFont& pen);
                 void labelsAngleChanged(int angle);
                 void gridLinePenChanged(const QPen& pen);
                 void gridVisibleChanged(bool visible);
                 void colorChanged(QColor color);
                 void labelsColorChanged(QColor color);
                 void titleTextChanged(const QString& title);
                 void titlePenChanged(const QPen& pen);
                 void titleBrushChanged(const QBrush brush);
                 void titleVisibleChanged(bool visible);
                 void titleFontChanged(const QFont& font);
                 void shadesVisibleChanged(bool visible);
                 void shadesColorChanged(QColor color);
                 void shadesBorderColorChanged(QColor color);
                 void shadesPenChanged(const QPen& pen);
                 void shadesBrushChanged(const QBrush brush);
             protected:
                 QScopedPointer<QAbstractAxisPrivate> d_ptr;
                 Q_DISABLE_COPY(QAbstractAxis)
                 friend class ChartDataSet;
                 friend class ChartAxis;
                 friend class ChartPresenter;
                 friend class ChartThemeManager;
+                friend class AbstractDomain;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QABSTRACTAXIS_H

src/chartdataset.cpp +100 -39

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "chartdataset_p.h"
             #include "chartpresenter_p.h"
             #include "qchart.h"
             #include "qchart_p.h"
             #include "qvalueaxis.h"
             #include "qbarcategoryaxis.h"
             #include "qvalueaxis_p.h"
             #include "qcategoryaxis.h"
             #include "qabstractseries_p.h"
             #include "qabstractbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qpieseries.h"
             #include "chartitem_p.h"
             #include "xydomain_p.h"
             #include "xlogydomain_p.h"
             #include "logxydomain_p.h"
             #include "logxlogydomain_p.h"
             #ifndef QT_ON_ARM
             #include "qdatetimeaxis.h"
             #endif
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartDataSet::ChartDataSet(QChart *chart)
                 : QObject(chart),
                   m_chart(chart)
             {
             }
             ChartDataSet::~ChartDataSet()
             {
-                removeAllSeries();
+                deleteAllSeries();
-                removeAllAxes();
+                deleteAllAxes();
             }
             /*
              * This method adds series to chartdataset, series ownership is taken from caller.
              */
             void ChartDataSet::addSeries(QAbstractSeries *series)
             {
                 if (m_seriesList.contains(series)) {
                     qWarning() << QObject::tr("Can not add series. Series already on the chart.");
                     return;
                 }
                 series->d_ptr->initializeDomain();
                 m_seriesList.append(series);
                 series->setParent(this); // take ownership
                 series->d_ptr->m_chart = m_chart;
                 emit seriesAdded(series);
             }
             /*
              * This method adds axis to chartdataset, axis ownership is taken from caller.
              */
             void ChartDataSet::addAxis(QAbstractAxis *axis,Qt::Alignment aligment)
             {
                 if (m_axisList.contains(axis)) {
                     qWarning() << QObject::tr("Can not add axis. Axis already on the chart.");
                     return;
                 }
                 axis->d_ptr->setAlignment(aligment);
                 if(!axis->alignment()) {
                     qWarning()<< QObject::tr("No alignment specified !");
                     return;
                 };
                 QSharedPointer<AbstractDomain> domain(new XYDomain());
                 axis->d_ptr->initializeDomain(domain.data());
                 axis->setParent(this);
                 axis->d_ptr->m_chart = m_chart;
                 m_axisList.append(axis);
                 emit axisAdded(axis);
             }
             /*
              * This method removes series form chartdataset, series ownership is passed back to caller.
              */
             void ChartDataSet::removeSeries(QAbstractSeries *series)
             {
                 if (! m_seriesList.contains(series)) {
                     qWarning() << QObject::tr("Can not remove series. Series not found on the chart.");
                     return;
                 }
                 emit seriesRemoved(series);
                 m_seriesList.removeAll(series);
                 series->setParent(0);
                 series->d_ptr->m_chart = 0;
                 series->d_ptr->m_domain.clear();
                 QList<QAbstractAxis*> axes = series->d_ptr->m_axes;
                 foreach(QAbstractAxis* axis, axes) {
                     axis->d_ptr->m_series.removeAll(series);
                     series->d_ptr->m_axes.removeAll(axis);
                 }
             }
             /*
              * This method removes axis form chartdataset, series ownership is passed back to caller.
              */
             void ChartDataSet::removeAxis(QAbstractAxis *axis)
             {
                 if (! m_axisList.contains(axis)) {
                     qWarning() << QObject::tr("Can not remove axis. Axis not found on the chart.");
                     return;
                 }
                 emit axisRemoved(axis);
                 m_axisList.removeAll(axis);
                 axis->setParent(0);
                 axis->d_ptr->m_chart = 0;
                 QList<QAbstractSeries*> series =  axis->d_ptr->m_series;
                 foreach(QAbstractSeries* s, series) {
                    s->d_ptr->m_axes.removeAll(axis);
                    axis->d_ptr->m_series.removeAll(s);
                 }
             }
             /*
-             * This method attach axis to series, return true if success.
+             * This method attaches axis to series, return true if success.
              */
             bool ChartDataSet::attachAxis(QAbstractSeries* series,QAbstractAxis *axis)
             {
                 Q_ASSERT(series);
                 Q_ASSERT(axis);
                 QList<QAbstractSeries* > attachedSeriesList = axis->d_ptr->m_series;
                 QList<QAbstractAxis* > attachedAxisList = series->d_ptr->m_axes;
-                QSharedPointer<AbstractDomain> domain =  series->d_ptr->m_domain;
                 if (!m_seriesList.contains(series)) {
                     qWarning() << QObject::tr("Can not find series on the chart.");
                     return false;
                 }
                 if (axis && !m_axisList.contains(axis)) {
                     qWarning() << QObject::tr("Can not find axis on the chart.");
                     return false;
                 }
                 if (attachedAxisList.contains(axis)) {
                     qWarning() << QObject::tr("Axis already attached to series.");
                     return false;
                 }
-                Q_ASSERT(!attachedSeriesList.contains(series));
+                if (attachedSeriesList.contains(series)) {
-                Q_ASSERT(!domain.isNull());
+                    qWarning() << QObject::tr("Axis already attached to series.");
+                    return false;
+                }
+                QSharedPointer<AbstractDomain> domain = series->d_ptr->domain();
+                AbstractDomain::DomainType type = selectDomain(attachedAxisList<<axis);
+                if(type == AbstractDomain::UndefinedDomain) return false;
-                if(attachedSeriesList.isEmpty()){
-                }else{
+                if(domain->type()!=type){
-                    domain = attachedSeriesList.first()->d_ptr->domain();
+                    domain =  QSharedPointer<AbstractDomain>(createDomain(type));
-                    Q_ASSERT(!domain.isNull());
-                    series->d_ptr->setDomain(domain);
                 }
+                if(domain.isNull()) return false;
+                if(!domain->attachAxis(axis)) return false;
                 series->d_ptr->m_axes<<axis;
                 axis->d_ptr->m_series<<series;
+                series->d_ptr->setDomain(domain);
+                series->d_ptr->initializeDomain();
                 series->d_ptr->initializeAxes();
                 axis->d_ptr->initializeDomain(domain.data());
-                if(axis->orientation()==Qt::Vertical){
+                if(attachedSeriesList.count()>0 &&  attachedAxisList.count()>0){
-                    QObject::connect(axis->d_ptr.data(), SIGNAL(rangeChanged(qreal,qreal)), domain.data(), SLOT(handleVerticalAxisRangeChanged(qreal,qreal)));
+                      //TODO optimatization: joinDomain(attachedAxisList, attachedSeriesList);
-                    QObject::connect(domain.data(), SIGNAL(rangeVerticalChanged(qreal,qreal)), axis->d_ptr.data(), SLOT(handleRangeChanged(qreal,qreal)));
-                if(axis->orientation()==Qt::Horizontal){
-                    QObject::connect(axis->d_ptr.data(), SIGNAL(rangeChanged(qreal,qreal)), domain.data(), SLOT(handleHorizontalAxisRangeChanged(qreal,qreal)));
-                    QObject::connect(domain.data(), SIGNAL(rangeHorizontalChanged(qreal,qreal)), axis->d_ptr.data(), SLOT(handleRangeChanged(qreal,qreal)));
                 }
                 return true;
             }
             /*
-             * This method detach axis to series, return true if success.
+             * This method detaches axis to series, return true if success.
              */
             bool ChartDataSet::detachAxis(QAbstractSeries* series,QAbstractAxis *axis)
             {
                 Q_ASSERT(series);
                 Q_ASSERT(axis);
                 QList<QAbstractSeries* > attachedSeriesList = axis->d_ptr->m_series;
                 QList<QAbstractAxis* > attachedAxisList = series->d_ptr->m_axes;
                 QSharedPointer<AbstractDomain> domain =  series->d_ptr->m_domain;
                 if (!m_seriesList.contains(series)) {
                     qWarning() << QObject::tr("Can not find series on the chart.");
                     return false;
                 }
                 if (axis && !m_axisList.contains(axis)) {
                     qWarning() << QObject::tr("Can not find axis on the chart.");
                     return false;
                 }
                 if (!attachedAxisList.contains(axis)) {
                     qWarning() << QObject::tr("Axis not attached to series.");
                     return false;
                 }
                 Q_ASSERT(axis->d_ptr->m_series.contains(series));
+                domain->detachAxis(axis);
                 series->d_ptr->m_axes.removeAll(axis);
                 axis->d_ptr->m_series.removeAll(series);
-                if(axis->orientation()==Qt::Vertical){
-                    QObject::disconnect(axis->d_ptr.data(), SIGNAL(rangeChanged(qreal,qreal)), domain.data(), SLOT(handleVerticalAxisRangeChanged(qreal,qreal)));
-                    QObject::disconnect(domain.data(), SIGNAL(rangeVerticalChanged(qreal,qreal)), axis->d_ptr.data(), SLOT(handleRangeChanged(qreal,qreal)));
-                if(axis->orientation()==Qt::Horizontal){
-                    QObject::disconnect(axis->d_ptr.data(), SIGNAL(rangeChanged(qreal,qreal)), domain.data(), SLOT(handleHorizontalAxisRangeChanged(qreal,qreal)));
-                    QObject::disconnect(domain.data(), SIGNAL(rangeHorizontalChanged(qreal,qreal)), axis->d_ptr.data(), SLOT(handleRangeChanged(qreal,qreal)));
                 return true;
             }
             void ChartDataSet::createDefaultAxes()
             {
                 if (m_seriesList.isEmpty())
                     return;
                 QAbstractAxis::AxisTypes typeX(0);
                 QAbstractAxis::AxisTypes typeY(0);
                 // Remove possibly existing axes
-                removeAllAxes();
+                deleteAllAxes();
                 Q_ASSERT(m_axisList.isEmpty());
                 // Select the required axis x and axis y types based on the types of the current series
                 foreach(QAbstractSeries* s, m_seriesList) {
                     typeX |= s->d_ptr->defaultAxisType(Qt::Horizontal);
                     typeY |= s->d_ptr->defaultAxisType(Qt::Vertical);
                 }
                 // Create the axes of the types selected
                 createAxes(typeX, Qt::Horizontal);
                 createAxes(typeY, Qt::Vertical);
             }
             void ChartDataSet::createAxes(QAbstractAxis::AxisTypes type, Qt::Orientation orientation)
             {
                 QAbstractAxis *axis = 0;
                 //decide what axis should be created
                 switch (type) {
                     case QAbstractAxis::AxisTypeValue:
                     axis = new QValueAxis(this);
                     break;
                     case QAbstractAxis::AxisTypeBarCategory:
                     axis = new QBarCategoryAxis(this);
                     break;
                     case QAbstractAxis::AxisTypeCategory:
                     axis = new QCategoryAxis(this);
                     break;
             #ifndef Q_WS_QWS
                     case QAbstractAxis::AxisTypeDateTime:
                     axis = new QDateTimeAxis(this);
                     break;
             #endif
                     default:
                     axis = 0;
                     break;
                 }
                 if (axis) {
                     //create one axis for all
                     addAxis(axis,orientation==Qt::Horizontal?Qt::AlignBottom:Qt::AlignLeft);
                     foreach(QAbstractSeries *s, m_seriesList) {
                         attachAxis(s,axis);
                     }
                 }
                 else if (!type.testFlag(QAbstractAxis::AxisTypeNoAxis)) {
                     //create separate axis
                     foreach(QAbstractSeries *s, m_seriesList) {
                         QAbstractAxis *axis = s->d_ptr->createDefaultAxis(orientation);
                         if(axis) {
                             addAxis(axis,orientation==Qt::Horizontal?Qt::AlignBottom:Qt::AlignLeft);
                             attachAxis(s,axis);
                         }
                     }
                 }
             }
-            void ChartDataSet::removeAllSeries()
+            void ChartDataSet::deleteAllSeries()
             {
-                foreach (QAbstractSeries *s , m_seriesList)
+                foreach (QAbstractSeries *s , m_seriesList){
                     removeSeries(s);
+                    delete s;
+                }
                 Q_ASSERT(m_seriesList.count() == 0);
-                qDeleteAll(m_seriesList);
             }
-            void ChartDataSet::removeAllAxes()
+            void ChartDataSet::deleteAllAxes()
             {
-                foreach (QAbstractAxis *a , m_axisList)
+                foreach (QAbstractAxis *a , m_axisList){
                     removeAxis(a);
+                    delete a;
+                }
                 Q_ASSERT(m_axisList.count() == 0);
-                qDeleteAll(m_axisList);
             }
             void ChartDataSet::zoomInDomain(const QRectF &rect)
             {
                 QList<AbstractDomain*> domains;
                 foreach(QAbstractSeries *s, m_seriesList) {
                     AbstractDomain* domain = s->d_ptr->m_domain.data();
                     if(domains.contains(domain)) continue;
                     s->d_ptr->m_domain->blockAxisSignals(true);
                     domains<<domain;
                 }
                 foreach(AbstractDomain *domain, domains)
                     domain->zoomIn(rect);
                 foreach(AbstractDomain *domain, domains)
                     domain->blockAxisSignals(false);
             }
             void ChartDataSet::zoomOutDomain(const QRectF &rect)
             {
                 QList<AbstractDomain*> domains;
                 foreach(QAbstractSeries *s, m_seriesList) {
                     AbstractDomain* domain = s->d_ptr->m_domain.data();
                     if(domains.contains(domain)) continue;
                     s->d_ptr->m_domain->blockAxisSignals(true);
                     domains<<domain;
                 }
                 foreach(AbstractDomain *domain, domains)
                     domain->zoomOut(rect);
                 foreach(AbstractDomain *domain, domains)
                     domain->blockAxisSignals(false);
             }
             void ChartDataSet::scrollDomain(qreal dx, qreal dy)
             {
                 QList<AbstractDomain*> domains;
                 foreach(QAbstractSeries *s, m_seriesList) {
                     AbstractDomain* domain = s->d_ptr->m_domain.data();
                     if(domains.contains(domain)) continue;
                     s->d_ptr->m_domain->blockAxisSignals(true);
                     domains<<domain;
                 }
                 foreach(AbstractDomain *domain, domains)
                     domain->move(dx, dy);
                 foreach(AbstractDomain *domain, domains)
                     domain->blockAxisSignals(false);
             }
             QList<QAbstractAxis*> ChartDataSet::axes() const
             {
                return m_axisList;
             }
             QList<QAbstractSeries *> ChartDataSet::series() const
             {
                 return m_seriesList;
             }
+            AbstractDomain::DomainType ChartDataSet::selectDomain(QList<QAbstractAxis*> axes)
+            {
+                enum Type {
+                    LogType = 0x1,
+                    ValueType = 0x2
+                };
+                int horizontal(ValueType);
+                int vertical(ValueType);
+                foreach(QAbstractAxis* axis, axes)
+                {
+                    switch(axis->type()) {
+                        case QAbstractAxis::AxisTypeLogValue:
+                            axis->orientation()==Qt::Horizontal?horizontal:vertical|=LogType;
+                        break;
+                        case QAbstractAxis::AxisTypeValue:
+                        case QAbstractAxis::AxisTypeBarCategory:
+                        case QAbstractAxis::AxisTypeCategory:
+                        case QAbstractAxis::AxisTypeDateTime:
+                            axis->orientation()==Qt::Horizontal?horizontal:vertical|=ValueType;
+                        break;
+                        default:
+                        qWarning()<<"Undefined type";
+                        break;
+                    }
+                }
+                if(vertical==ValueType && horizontal== ValueType) {
+                    return AbstractDomain::XYDomain;
+                }
+                if(vertical==LogType && horizontal== ValueType) {
+                    return AbstractDomain::XLogYDomain;
+                }
+                if(vertical==ValueType && horizontal== LogType) {
+                    return AbstractDomain::LogXYDomain;
+                }
+                if(vertical==LogType && horizontal== LogType) {
+                    return AbstractDomain::XLogYLogDomain;
+                }
+                return AbstractDomain::UndefinedDomain;
+            }
+            //refactor create factory
+            AbstractDomain* ChartDataSet::createDomain(AbstractDomain::DomainType type)
+            {
+            	switch(type)
+            	{
+            		case AbstractDomain::XLogYLogDomain:
+            			return 0;
+            		case AbstractDomain::XYDomain:
+            			return new XYDomain();
+            		case AbstractDomain::XLogYDomain:
+            			return 0;
+            		case AbstractDomain::LogXYDomain:
+            			return 0;
+            		default:
+            			return 0;
+            	}
+            }
             #include "moc_chartdataset_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartdataset_p.h +4 -3

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef CHARTDATASET_P_H
             #define CHARTDATASET_P_H
             #include "qabstractseries.h"
             #include "abstractdomain_p.h"
             #include "qabstractaxis_p.h"
             #include <QVector>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QAbstractAxis;
             class ChartPresenter;
             class QTCOMMERCIALCHART_AUTOTEST_EXPORT ChartDataSet : public QObject
             {
                 Q_OBJECT
             public:
                 ChartDataSet(QChart *chart);
                 virtual ~ChartDataSet();
                 void addSeries(QAbstractSeries *series);
                 void removeSeries(QAbstractSeries *series);
                 QList<QAbstractSeries *> series() const;
-                void removeAllSeries();
                 void addAxis(QAbstractAxis *axis,Qt::Alignment aligment);
                 void removeAxis(QAbstractAxis *axis);
                 QList<QAbstractAxis*> axes() const;
-                void removeAllAxes();
                 bool attachAxis(QAbstractSeries* series,QAbstractAxis *axis);
                 bool detachAxis(QAbstractSeries* series,QAbstractAxis *axis);
                 void createDefaultAxes();
                 void zoomInDomain(const QRectF &rect);
                 void zoomOutDomain(const QRectF &rect);
                 void scrollDomain(qreal dx, qreal dy);
             Q_SIGNALS:
                 void axisAdded(QAbstractAxis* axis);
                 void axisRemoved(QAbstractAxis* axis);
                 void seriesAdded(QAbstractSeries* series);
                 void seriesRemoved(QAbstractSeries* series);
             private:
                 void createAxes(QAbstractAxis::AxisTypes type, Qt::Orientation orientation);
                 QAbstractAxis *createAxis(QAbstractAxis::AxisType type, Qt::Orientation orientation);
+                AbstractDomain::DomainType selectDomain(QList<QAbstractAxis* > axes);
+                AbstractDomain* createDomain(AbstractDomain::DomainType type);
+                void deleteAllAxes();
+                void deleteAllSeries();
             private:
                 QList<QAbstractSeries *> m_seriesList;
                 QList<QAbstractAxis *> m_axisList;
                 QChart* m_chart;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* CHARTENGINE_P_H */

src/domain/abstractdomain.cpp +29 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$
             **
             ****************************************************************************/
             #include "abstractdomain_p.h"
             #include "qabstractaxis_p.h"
             #include <qmath.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             AbstractDomain::AbstractDomain(QObject *parent)
                 : QObject(parent),
                   m_minX(0),
                   m_maxX(0),
                   m_minY(0),
                   m_maxY(0),
                   m_axisSignalsBlocked(false)
             {
             }
             AbstractDomain::~AbstractDomain()
             {
             }
             void AbstractDomain::setSize(const QSizeF& size)
             {
             	if(m_size!=size)
             	{
             		m_size=size;
             		emit updated();
             	}
             }
             QSizeF AbstractDomain::size() const
             {
             	return m_size;
             }
             void AbstractDomain::setRangeX(qreal min, qreal max)
             {
                 setRange(min, max, m_minY, m_maxY);
             }
             void AbstractDomain::setRangeY(qreal min, qreal max)
             {
                 setRange(m_minX, m_maxX, min, max);
             }
             void AbstractDomain::setMinX(qreal min)
             {
                 setRange(min, m_maxX, m_minY, m_maxY);
             }
             void AbstractDomain::setMaxX(qreal max)
             {
                 setRange(m_minX, max, m_minY, m_maxY);
             }
             void AbstractDomain::setMinY(qreal min)
             {
                 setRange(m_minX, m_maxX, min, m_maxY);
             }
             void AbstractDomain::setMaxY(qreal max)
             {
                 setRange(m_minX, m_maxX, m_minY, max);
             }
             qreal AbstractDomain::spanX() const
             {
                 Q_ASSERT(m_maxX >= m_minX);
                 return m_maxX - m_minX;
             }
             qreal AbstractDomain::spanY() const
             {
                 Q_ASSERT(m_maxY >= m_minY);
                 return m_maxY - m_minY;
             }
             bool AbstractDomain::isEmpty() const
             {
                 return qFuzzyIsNull(spanX()) || qFuzzyIsNull(spanY()) || m_size.isEmpty() ;
             }
             QPointF AbstractDomain::calculateDomainPoint(const QPointF &point) const
             {
                 const qreal deltaX = m_size.width() / (m_maxX - m_minX);
                 const qreal deltaY = m_size.height() / (m_maxY - m_minY);
                 qreal x = point.x() / deltaX + m_minX;
                 qreal y = (point.y() - m_size.height()) / (-deltaY) + m_minY;
                 return QPointF(x, y);
             }
             // handlers
             void AbstractDomain::handleVerticalAxisRangeChanged(qreal min, qreal max)
             {
                 if(!m_axisSignalsBlocked)
                     setRangeY(min, max);
             }
             void AbstractDomain::handleHorizontalAxisRangeChanged(qreal min, qreal max)
             {
                 if(!m_axisSignalsBlocked)
                     setRangeX(min, max);
             }
             void AbstractDomain::blockAxisSignals(bool block)
             {
                 m_axisSignalsBlocked=block;
             }
             //algorithm defined by Paul S.Heckbert GraphicalGems I
             void AbstractDomain::looseNiceNumbers(qreal &min, qreal &max, int &ticksCount)
             {
                 qreal range = niceNumber(max - min, true); //range with ceiling
                 qreal step = niceNumber(range / (ticksCount - 1), false);
                 min = qFloor(min / step);
                 max = qCeil(max / step);
                 ticksCount = int(max - min) + 1;
                 min *= step;
                 max *= step;
             }
             //nice numbers can be expressed as form of 1*10^n, 2* 10^n or 5*10^n
             qreal AbstractDomain::niceNumber(qreal x, bool ceiling)
             {
                 qreal z = qPow(10, qFloor(log10(x))); //find corresponding number of the form of 10^n than is smaller than x
                 qreal q = x / z; //q<10 && q>=1;
                 if (ceiling) {
                     if (q <= 1.0) q = 1;
                     else if (q <= 2.0) q = 2;
                     else if (q <= 5.0) q = 5;
                     else q = 10;
                 } else {
                     if (q < 1.5) q = 1;
                     else if (q < 3.0) q = 2;
                     else if (q < 7.0) q = 5;
                     else q = 10;
                 }
                 return q * z;
             }
+            bool AbstractDomain::attachAxis(QAbstractAxis* axis)
+            {
+            	if(axis->orientation()==Qt::Vertical) {
+            		QObject::connect(axis->d_ptr.data(), SIGNAL(rangeChanged(qreal,qreal)), this, SLOT(handleVerticalAxisRangeChanged(qreal,qreal)));
+            		QObject::connect(this, SIGNAL(rangeVerticalChanged(qreal,qreal)), axis->d_ptr.data(), SLOT(handleRangeChanged(qreal,qreal)));
+            	}
+            	if(axis->orientation()==Qt::Horizontal) {
+            		QObject::connect(axis->d_ptr.data(), SIGNAL(rangeChanged(qreal,qreal)), this, SLOT(handleHorizontalAxisRangeChanged(qreal,qreal)));
+            		QObject::connect(this, SIGNAL(rangeHorizontalChanged(qreal,qreal)), axis->d_ptr.data(), SLOT(handleRangeChanged(qreal,qreal)));
+            	}
+            	return true;
+            }
+            bool AbstractDomain::detachAxis(QAbstractAxis* axis)
+            {
+            	if(axis->orientation()==Qt::Vertical) {
+            		QObject::disconnect(axis->d_ptr.data(), SIGNAL(rangeChanged(qreal,qreal)), this, SLOT(handleVerticalAxisRangeChanged(qreal,qreal)));
+            		QObject::disconnect(this, SIGNAL(rangeVerticalChanged(qreal,qreal)), axis->d_ptr.data(), SLOT(handleRangeChanged(qreal,qreal)));
+            	}
+            	if(axis->orientation()==Qt::Horizontal) {
+            		QObject::disconnect(axis->d_ptr.data(), SIGNAL(rangeChanged(qreal,qreal)), this, SLOT(handleHorizontalAxisRangeChanged(qreal,qreal)));
+            		QObject::disconnect(this, SIGNAL(rangeHorizontalChanged(qreal,qreal)), axis->d_ptr.data(), SLOT(handleRangeChanged(qreal,qreal)));
+            	}
+            	return true;
+            }
             // operators
             bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator== (const AbstractDomain &domain1, const AbstractDomain &domain2)
             {
                 return (qFuzzyIsNull(domain1.m_maxX - domain2.m_maxX) &&
                         qFuzzyIsNull(domain1.m_maxY - domain2.m_maxY) &&
                         qFuzzyIsNull(domain1.m_minX - domain2.m_minX) &&
                         qFuzzyIsNull(domain1.m_minY - domain2.m_minY));
             }
             bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator!= (const AbstractDomain &domain1, const AbstractDomain &domain2)
             {
                 return !(domain1 == domain2);
             }
             QDebug QTCOMMERCIALCHART_AUTOTEST_EXPORT operator<<(QDebug dbg, const AbstractDomain &domain)
             {
                 dbg.nospace() << "AbstractDomain(" << domain.m_minX << ',' << domain.m_maxX << ',' << domain.m_minY << ',' << domain.m_maxY << ')' << domain.m_size;
                 return dbg.maybeSpace();
             }
             #include "moc_abstractdomain_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/domain/abstractdomain_p.h +9 -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$
             **
             ****************************************************************************/
             //  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 ABSTRACTDOMAIN_H
             #define ABSTRACTDOMAIN_H
             #include "qchartglobal.h"
             #include <QRectF>
             #include <QSizeF>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
+            class QAbstractAxis;
             class QTCOMMERCIALCHART_AUTOTEST_EXPORT AbstractDomain: public QObject
             {
                 Q_OBJECT
             public:
+                enum DomainType { UndefinedDomain, XYDomain, XLogYDomain, LogXYDomain, XLogYLogDomain };
+            public:
                 explicit AbstractDomain(QObject *object = 0);
                 virtual ~AbstractDomain();
                 void setSize(const QSizeF& size);
                 QSizeF size() const;
+                virtual DomainType type() = 0;
                 virtual void setRange(qreal minX, qreal maxX, qreal minY, qreal maxY) = 0;
                 void setRangeX(qreal min, qreal max);
                 void setRangeY(qreal min, qreal max);
                 void setMinX(qreal min);
                 void setMaxX(qreal max);
                 void setMinY(qreal min);
                 void setMaxY(qreal max);
                 qreal minX() const { return m_minX; }
                 qreal maxX() const { return m_maxX; }
                 qreal minY() const { return m_minY; }
                 qreal maxY() const { return m_maxY; }
                 qreal spanX() const;
                 qreal spanY() const;
                 bool isEmpty() const;
                 void blockAxisSignals(bool block);
                 bool axisSignalsBlocked() const { return m_axisSignalsBlocked; }
                 friend bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator== (const AbstractDomain &domain1, const AbstractDomain &domain2);
                 friend bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator!= (const AbstractDomain &domain1, const AbstractDomain &domain2);
                 friend QDebug QTCOMMERCIALCHART_AUTOTEST_EXPORT operator<<(QDebug dbg, const AbstractDomain &domain);
                 virtual void zoomIn(const QRectF &rect) = 0;
                 virtual void zoomOut(const QRectF &rect) = 0;
                 virtual void move(qreal dx, qreal dy) = 0;
                 virtual QPointF calculateGeometryPoint(const QPointF &point) const = 0;
                 virtual QPointF calculateDomainPoint(const QPointF &point) const = 0;
                 virtual QVector<QPointF> calculateGeometryPoints(const QList<QPointF>& vector) const = 0;
+                virtual bool attachAxis(QAbstractAxis* axis);
+                virtual bool detachAxis(QAbstractAxis* axis);
                 static void looseNiceNumbers(qreal &min, qreal &max, int &ticksCount);
                 static qreal niceNumber(qreal x, bool ceiling);
             Q_SIGNALS:
                 void updated();
                 void rangeHorizontalChanged(qreal min, qreal max);
                 void rangeVerticalChanged(qreal min, qreal max);
             public Q_SLOTS:
                 void handleVerticalAxisRangeChanged(qreal min,qreal max);
                 void handleHorizontalAxisRangeChanged(qreal min,qreal max);
             protected:
                 qreal m_minX;
                 qreal m_maxX;
                 qreal m_minY;
                 qreal m_maxY;
                 QSizeF m_size;
                 bool m_axisSignalsBlocked;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // ABSTRACTDOMAIN_H

src/domain/xydomain_p.h +2 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef XYDOMAIN_H
             #define XYDOMAIN_H
             #include "abstractdomain_p.h"
             #include <QRectF>
             #include <QSizeF>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QTCOMMERCIALCHART_AUTOTEST_EXPORT XYDomain: public AbstractDomain
             {
                 Q_OBJECT
             public:
                 explicit XYDomain(QObject *object = 0);
                 virtual ~XYDomain();
+                DomainType type(){ return AbstractDomain::XYDomain;}
                 void setRange(qreal minX, qreal maxX, qreal minY, qreal maxY);
                 friend bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator== (const XYDomain &Domain1, const XYDomain &Domain2);
                 friend bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator!= (const XYDomain &Domain1, const XYDomain &Domain2);
                 friend QDebug QTCOMMERCIALCHART_AUTOTEST_EXPORT operator<<(QDebug dbg, const XYDomain &AbstractDomain);
                 void zoomIn(const QRectF &rect);
                 void zoomOut(const QRectF &rect);
                 void move(qreal dx, qreal dy);
                 QPointF calculateGeometryPoint(const QPointF &point) const;
                 QPointF calculateDomainPoint(const QPointF &point) const;
                 QVector<QPointF> calculateGeometryPoints(const QList<QPointF>& vector) const;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // XYDOMAIN_H

src/legend/qlegend_p.h 0 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef QLEGEND_P_H
             #define QLEGEND_P_H
             #include "qlegend.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QChart;
             class ChartPresenter;
             class QAbstractSeries;
             class LegendLayout;
-            class Domain;
             class QLegendMarker;
             class QLegendPrivate : public QObject
             {
                 Q_OBJECT
             public:
                 QLegendPrivate(ChartPresenter *presenter, QChart *chart, QLegend *q);
                 ~QLegendPrivate();
                 void setOffset(const QPointF &offset);
                 QPointF offset() const;
                 int roundness(qreal size);
                 QGraphicsItemGroup* items() { return m_items; }
                 QList<QLegendMarker*> markers(QAbstractSeries *series = 0);
             public Q_SLOTS:
                 void handleSeriesAdded(QAbstractSeries *series);
                 void handleSeriesRemoved(QAbstractSeries *series);
                 void handleSeriesVisibleChanged();
                 void handleCountChanged();
             private:
                 // Internal helpers
                 void addMarkers(QList<QLegendMarker *> markers);
                 void removeMarkers(QList<QLegendMarker *> markers);
                 void decorateMarkers(QList<QLegendMarker *> markers);
             private:
                 QLegend *q_ptr;
                 ChartPresenter *m_presenter;
                 LegendLayout *m_layout;
                 QChart *m_chart;
                 QGraphicsItemGroup *m_items;
                 Qt::Alignment m_alignment;
                 QBrush m_brush;
                 QPen m_pen;
                 QFont m_font;
                 QBrush m_labelBrush;
                 qreal m_diameter;
                 bool m_attachedToChart;
                 bool m_backgroundVisible;
                 QList<QLegendMarker *> m_markers;
                 QList<QAbstractSeries *> m_series;
                 QHash<QGraphicsItem *, QLegendMarker *> m_markerHash;
                 friend class QLegend;
                 friend class LegendMarkerItem;
                 friend class LegendLayout;
                 friend class QLegendMarkerPrivate;
                 friend class LegendScroller;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/qchart.cpp +4 -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 "qchart.h"
             #include "qchart_p.h"
             #include "legendscroller_p.h"
             #include "qlegend_p.h"
             #include "chartbackground_p.h"
             #include "qabstractaxis.h"
             #include "chartlayout_p.h"
             #include "charttheme_p.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             #include <QGraphicsScene>
             #include <QGraphicsSceneResizeEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
              \enum QChart::ChartTheme
              This enum describes the theme used by the chart.
              \value ChartThemeLight The default theme
              \value ChartThemeBlueCerulean
              \value ChartThemeDark
              \value ChartThemeBrownSand
              \value ChartThemeBlueNcs
              \value ChartThemeHighContrast
              \value ChartThemeBlueIcy
              */
             /*!
              \enum QChart::AnimationOption
              For enabling/disabling animations. Defaults to NoAnimation.
              \value NoAnimation
              \value GridAxisAnimations
              \value SeriesAnimations
              \value AllAnimations
              */
             /*!
              \class QChart
              \brief QtCommercial chart API.
              QChart is a QGraphicsWidget that you can show in a QGraphicsScene. It manages the graphical
              representation of different types of 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::minimumMargins
              Minimum margins between the plot area (axes) and the edge of the chart widget.
              */
             /*!
              \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.
              */
             /*!
              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(this))
             {
                 d_ptr->m_legend = new LegendScroller(this);
                 setTheme(QChart::ChartThemeLight);
                 //TODO: what is that ?
                 //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()
             {
                 //start by deleting dataset, it will remove all series and axes
                 delete d_ptr->m_dataset;
                 d_ptr->m_dataset = 0;
             }
             /*!
              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();
+                foreach (QAbstractSeries *s ,  d_ptr->m_dataset->series()){
+                    removeSeries(s);
+                    delete s;
+                }
             }
             /*!
              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_themeManager->setTheme(theme);
             }
             QChart::ChartTheme QChart::theme() const
             {
                 return d_ptr->m_themeManager->theme()->id();
             }
             /*!
              Zooms in the view by a factor of 2
              */
             void QChart::zoomIn()
             {
                 d_ptr->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)
             {
             	d_ptr->zoomIn(rect);
             }
             /*!
              Restores the view zoom level to the previous one.
              */
             void QChart::zoomOut()
             {
                 d_ptr->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 (qFuzzyCompare(factor, 0))
                     return;
                 if (qFuzzyCompare(factor, (qreal)1.0))
                     return;
                 if (factor < 0)
                     return;
                 if (factor > 1.0)
                     d_ptr->zoomIn(factor);
                 else
                     d_ptr->zoomOut(1.0 / factor);
             }
             /*!
              Returns the pointer to the x axis object of the chart asociated with the specified \a series
              If no series is provided then pointer to currently visible axis is provided
              */
             QAbstractAxis *QChart::axisX(QAbstractSeries *series) const
             {
                 if(!series && d_ptr->m_dataset->series().size()>0){
                     series = d_ptr->m_dataset->series().first();
                 }
                 QList<QAbstractAxis*> axes = series->attachedAxes();
                 QAbstractAxis* bottom=0;
                 QAbstractAxis* top=0;
                 foreach(QAbstractAxis* axis, axes){
                     if(axis->alignment()==Qt::AlignTop){
                         top=axis;
                     }
                     if(axis->alignment()==Qt::AlignBottom){
                         bottom=axis;
                     }
                 }
                 return bottom?bottom:top;
             }
             /*!
              Returns the pointer to the y axis object of the chart asociated with the specified \a series
              If no series is provided then pointer to currently visible axis is provided
              */
             QAbstractAxis *QChart::axisY(QAbstractSeries *series) const
             {
                 if(!series && d_ptr->m_dataset->series().size()>0) {
                     series = d_ptr->m_dataset->series().first();
                 }
                 QList<QAbstractAxis*> axes = series->attachedAxes();
                 QAbstractAxis* left=0;
                 QAbstractAxis* right=0;
                 foreach(QAbstractAxis* axis, axes){
                     if(axis->alignment()==Qt::AlignLeft){
                        left=axis;
                     }
                     if(axis->alignment()==Qt::AlignRight){
                        right=axis;
                     }
                 }
                 return left?left:right;
             }
             QList<QAbstractAxis *> QChart::axes(Qt::Orientations orientation, QAbstractSeries *series) const
             {
                 QList<QAbstractAxis *> result ;
                 foreach(QAbstractAxis* axis,series->attachedAxes()){
                     if(orientation.testFlag(axis->orientation()))
                         result << axis;
                 }
                 return result;
             }
             /*!
              NOTICE: This function has to be called after series has been added to the chart if no customized axes are set to the chart. Otherwise axisX(), axisY() calls return NULL.
              Creates the axes for the chart based on the series that has already been added to the chart.
             \table
                  \header
                      \o Series type
                      \o X-axis
                      \o Y-axis
                  \row
                      \o QXYSeries
                      \o QValueAxis
                      \o QValueAxis
                  \row
                      \o QBarSeries
                      \o QBarCategoryAxis
                      \o QValueAxis
                  \row
                      \o QPieSeries
                      \o None
                      \o None
                  \endtable
              If there are several QXYSeries derived series added to the chart and no other series type has been added then only one pair of axes is created.
              If there are sevaral series added of different types then each series gets its own axes pair.
              NOTICE: if there is more than one x and y axes created then no axis is drawn by default and one needs to choose explicitly which axis should be shown.
              Axis specifix to the series can be later obtained from the chart by providing the series as the parameter of axisX(), axisY() function calls.
              QPieSeries does not create any axes.
              \sa axisX(), axisY(), setAxisX(), setAxisY()
              */
             void QChart::createDefaultAxes()
             {
                 d_ptr->m_dataset->createDefaultAxes();
             }
             /*!
              Returns the legend object of the chart. Ownership stays in chart.
              */
             QLegend *QChart::legend() const
             {
                 return d_ptr->m_legend;
             }
             /*!
               Sets the minimum \a margins between the plot area (axes) and the edge of the chart widget.
               Deprecated. Use setMargins().
             */
             void QChart::setMinimumMargins(const QMargins &margins)
             {
                 qWarning() << "QChart::setMinimumMargins is deprecated. Use QChart::setMargins instead.";
                 d_ptr->m_presenter->layout()->setMargins(margins);
             }
             /*!
                 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.
                 Deprecated. Use margins().
              */
             QMargins QChart::minimumMargins() const
             {
                 qWarning() << "QChart::minimumMargins is deprecated. Use QChart::margins instead.";
                 return d_ptr->m_presenter->layout()->margins();
             }
             /*!
               Sets the minimum \a margins between the plot area (axes) and the edge of the chart widget.
             */
             void QChart::setMargins(const QMargins &margins)
             {
                 d_ptr->m_presenter->layout()->setMargins(margins);
             }
             /*!
                 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.
              */
             QMargins QChart::margins() const
             {
                 return d_ptr->m_presenter->layout()->margins();
             }
             /*!
                 Returns the the rect within which the drawing of the chart is done.
                 It does not include the area defines by margins.
              */
             QRectF QChart::plotArea() const
             {
                 return d_ptr->m_presenter->geometry();
             }
             ///*!
             //    TODO: Dummy.
             //    Adjest the ranges of the axes so that all the data of the specified \a series is visible
             // */
             //void QChart::adjustViewToSeries(QAbstractSeries* series)
             //{
             //    //
             //}
             /*!
              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 dx and \a dy.
              */
             void QChart::scroll(qreal dx, qreal dy)
             {
                 d_ptr->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();
             }
             /*!
               Sets \a axis to the chart, which will control the presentation of the \a series
                \sa axisX(), axisY(), setAxisY(), createDefaultAxes()
             */
             void QChart::setAxisX(QAbstractAxis *axis , QAbstractSeries *series)
             {
                QList<QAbstractAxis*> list = axes(Qt::Horizontal,series);
                foreach(QAbstractAxis* a, list){
                     d_ptr->m_dataset->removeAxis(a);
                     delete a;
                }
                if(!d_ptr->m_dataset->axes().contains(axis))
                    d_ptr->m_dataset->addAxis(axis,Qt::AlignBottom);
                d_ptr->m_dataset->attachAxis(series,axis);
             }
             /*!
               Sets \a axis to the chart, which will control the presentation of the \a series
                \sa axisX(), axisY(), setAxisX(), createDefaultAxes()
             */
             void QChart::setAxisY(QAbstractAxis *axis , QAbstractSeries *series)
             {
                 QList<QAbstractAxis*> list = axes(Qt::Vertical,series);
                 foreach(QAbstractAxis* a, list) {
                     d_ptr->m_dataset->removeAxis(a);
                     delete a;
                 }
                 if(!d_ptr->m_dataset->axes().contains(axis))
                       d_ptr->m_dataset->addAxis(axis,Qt::AlignLeft);
                 d_ptr->m_dataset->attachAxis(series,axis);
             }
             void QChart::addAxis(QAbstractAxis *axis,Qt::Alignment aligment)
             {
             	d_ptr->m_dataset->addAxis(axis,aligment);
             }
             void QChart::removeAxis(QAbstractAxis *axis)
             {
             	d_ptr->m_dataset->removeAxis(axis);
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QChartPrivate::QChartPrivate(QChart *q):
                 q_ptr(q),
                 m_legend(0),
                 m_dataset(new ChartDataSet(q)),
                 m_presenter(new ChartPresenter(q)),
                 m_themeManager(new ChartThemeManager(q))
             {
                 QObject::connect(m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)), m_presenter, SLOT(handleSeriesAdded(QAbstractSeries*)));
                 QObject::connect(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)), m_presenter, SLOT(handleSeriesRemoved(QAbstractSeries*)));
                 QObject::connect(m_dataset, SIGNAL(axisAdded(QAbstractAxis*)), m_presenter, SLOT(handleAxisAdded(QAbstractAxis*)));
                 QObject::connect(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)), m_presenter, SLOT(handleAxisRemoved(QAbstractAxis*)));
                 QObject::connect(m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)), m_themeManager, SLOT(handleSeriesAdded(QAbstractSeries*)));
                 QObject::connect(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)), m_themeManager, SLOT(handleSeriesRemoved(QAbstractSeries*)));
                 QObject::connect(m_dataset, SIGNAL(axisAdded(QAbstractAxis*)), m_themeManager, SLOT(handleAxisAdded(QAbstractAxis*)));
                 QObject::connect(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)), m_themeManager, SLOT(handleAxisRemoved(QAbstractAxis*)));
             }
             QChartPrivate::~QChartPrivate()
             {
             }
             void QChartPrivate::zoomIn(qreal factor)
             {
                 QRectF rect = m_presenter->geometry();
                 rect.setWidth(rect.width() / factor);
                 rect.setHeight(rect.height() / factor);
                 rect.moveCenter(m_presenter->geometry().center());
                 zoomIn(rect);
             }
             void QChartPrivate::zoomIn(const QRectF &rect)
             {
                 if (!rect.isValid())
                 return;
                 QRectF r = rect.normalized();
                 const QRectF geometry = m_presenter->geometry();
                 r.translate(-geometry.topLeft());
                 if (!r.isValid())
                     return;
                 QPointF zoomPoint(r.center().x() / geometry.width(), r.center().y() / geometry.height());
                 m_presenter->setState(ChartPresenter::ZoomInState,zoomPoint);
                 m_dataset->zoomInDomain(r);
                 m_presenter->setState(ChartPresenter::ShowState,QPointF());
             }
             void QChartPrivate::zoomOut(qreal factor)
             {
                 const QRectF geometry = m_presenter->geometry();
                 QRectF r;
                 r.setSize(geometry.size() / factor);
                 r.moveCenter(QPointF(geometry.size().width()/2 ,geometry.size().height()/2));
                 if (!r.isValid())
                     return;
                 QPointF zoomPoint(r.center().x() / geometry.width(), r.center().y() / geometry.height());
                 m_presenter->setState(ChartPresenter::ZoomOutState,zoomPoint);
                 m_dataset->zoomOutDomain(r);
                 m_presenter->setState(ChartPresenter::ShowState,QPointF());
             }
             void QChartPrivate::scroll(qreal dx, qreal dy)
             {
                 if (dx < 0) m_presenter->setState(ChartPresenter::ScrollLeftState,QPointF());
                 if (dx > 0) m_presenter->setState(ChartPresenter::ScrollRightState,QPointF());
                 if (dy < 0) m_presenter->setState(ChartPresenter::ScrollUpState,QPointF());
                 if (dy > 0) m_presenter->setState(ChartPresenter::ScrollDownState,QPointF());
                 m_dataset->scrollDomain(dx, dy);
                 m_presenter->setState(ChartPresenter::ShowState,QPointF());
             }
             #include "moc_qchart.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

tests/auto/chartdataset/tst_chartdataset.cpp +48 -133

             /****************************************************************************
             **
             ** 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 BUILD_PRIVATE_UNIT_TESTS
             #include <QtTest/QtTest>
             class tst_ChartDataSet: public QObject {
                 Q_OBJECT
             private Q_SLOTS:
                 void skip();
             };
             void tst_ChartDataSet::skip()
             {
                 QSKIP("This test requires the debug version of library", SkipAll);
             }
             QTEST_MAIN(tst_ChartDataSet)
             #include "tst_chartdataset.moc"
             #else
             #include <QtTest/QtTest>
             #include <qabstractaxis.h>
             #include <qvalueaxis.h>
             #include <qbarcategoryaxis.h>
             #include <qcategoryaxis.h>
             #include <qdatetimeaxis.h>
             #include <qlineseries.h>
             #include <qareaseries.h>
             #include <qscatterseries.h>
             #include <qsplineseries.h>
             #include <qpieseries.h>
             #include <qbarseries.h>
             #include <qpercentbarseries.h>
             #include <qstackedbarseries.h>
             #include <private/chartdataset_p.h>
             #include <private/abstractdomain_p.h>
             #include <tst_definitions.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             Q_DECLARE_METATYPE(AbstractDomain *)
             Q_DECLARE_METATYPE(QAbstractAxis *)
             Q_DECLARE_METATYPE(QAbstractSeries *)
             Q_DECLARE_METATYPE(QList<QAbstractSeries *>)
             Q_DECLARE_METATYPE(QList<QAbstractAxis *>)
             Q_DECLARE_METATYPE(Qt::Alignment)
             Q_DECLARE_METATYPE(QList<Qt::Alignment>)
             Q_DECLARE_METATYPE(QLineSeries *)
             class tst_ChartDataSet: public QObject {
                 Q_OBJECT
+            public:
+                tst_ChartDataSet():m_dataset(0){};
             public Q_SLOTS:
                 void initTestCase();
                 void cleanupTestCase();
                 void init();
                 void cleanup();
             private Q_SLOTS:
                 void chartdataset_data();
                 void chartdataset();
                 void addSeries_data();
                 void addSeries();
                 void removeSeries_data();
                 void removeSeries();
-                void removeAllSeries_data();
-                void removeAllSeries();
                 void addAxis_data();
                 void addAxis();
                 void removeAxis_data();
                 void removeAxis();
-                void removeAllAxes_data();
-                void removeAllAxes();
                 void attachAxis_data();
                 void attachAxis();
                 void detachAxis_data();
                 void detachAxis();
             private:
                 ChartDataSet* m_dataset;
             };
             void tst_ChartDataSet::initTestCase()
             {
                 qRegisterMetaType<AbstractDomain*>();
                 qRegisterMetaType<QAbstractAxis*>();
                 qRegisterMetaType<QAbstractSeries*>();
             }
             void tst_ChartDataSet::cleanupTestCase()
             {
             }
             void tst_ChartDataSet::init()
             {
+            	Q_ASSERT(!m_dataset);
                 m_dataset = new ChartDataSet(0);
             }
             void tst_ChartDataSet::cleanup()
             {
-                QList<QAbstractSeries*> series = m_dataset->series();
+              delete m_dataset;
-                foreach (QAbstractSeries* serie, series)
+              m_dataset=0;
-                    m_dataset->removeSeries(serie);
             }
             void tst_ChartDataSet::chartdataset_data()
             {
             }
             void tst_ChartDataSet::chartdataset()
             {
             	QVERIFY(m_dataset->axes().isEmpty());
             	QVERIFY(m_dataset->series().isEmpty());
             	m_dataset->createDefaultAxes();
             }
             void tst_ChartDataSet::addSeries_data()
             {
                 QTest::addColumn<QAbstractSeries*>("series");
                 QAbstractSeries* line = new QLineSeries(this);
-                QAbstractSeries* area = new QAreaSeries(static_cast<QLineSeries*>(line));
-                QAbstractSeries* scatter = new QScatterSeries(this);
-                QAbstractSeries* spline = new QSplineSeries(this);
-                QAbstractSeries* pie = new QPieSeries(this);
-                QAbstractSeries* bar = new QBarSeries(this);
-                QAbstractSeries* percent = new QPercentBarSeries(this);
-                QAbstractSeries* stacked = new QStackedBarSeries(this);
                 QTest::newRow("line") << line;
+                QAbstractSeries* area = new QAreaSeries(static_cast<QLineSeries*>(new QLineSeries(this)));
                 QTest::newRow("area") << area;
+                QAbstractSeries* scatter = new QScatterSeries(this);
                 QTest::newRow("scatter") << scatter;
+                QAbstractSeries* spline = new QSplineSeries(this);
                 QTest::newRow("spline") << spline;
+                QAbstractSeries* pie = new QPieSeries(this);
                 QTest::newRow("pie") << pie;
+                QAbstractSeries* bar = new QBarSeries(this);
                 QTest::newRow("bar") << bar;
+                QAbstractSeries* percent = new QPercentBarSeries(this);
                 QTest::newRow("percent") << percent;
+                QAbstractSeries* stacked = new QStackedBarSeries(this);
                 QTest::newRow("stacked") << stacked;
             }
             void tst_ChartDataSet::addSeries()
             {
                 QFETCH(QAbstractSeries*, series);
                 QVERIFY(m_dataset->series().isEmpty());
                 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis*)));
                 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
                 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)));
                 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)));
                 m_dataset->addSeries(series);
                 QCOMPARE(m_dataset->series().count(),1);
                 TRY_COMPARE(spy0.count(), 0);
                 TRY_COMPARE(spy1.count(), 0);
                 TRY_COMPARE(spy2.count(), 1);
                 TRY_COMPARE(spy3.count(), 0);
             }
             void tst_ChartDataSet::removeSeries_data()
             {
                 addSeries_data();
             }
             void tst_ChartDataSet::removeSeries()
             {
                 QFETCH(QAbstractSeries*, series);
                 QVERIFY(m_dataset->series().isEmpty());
                 m_dataset->addSeries(series);
                 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis*)));
                 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
                 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)));
                 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)));
                 m_dataset->removeSeries(series);
                 QCOMPARE(m_dataset->series().count(),0);
                 TRY_COMPARE(spy0.count(), 0);
                 TRY_COMPARE(spy1.count(), 0);
                 TRY_COMPARE(spy2.count(), 0);
                 TRY_COMPARE(spy3.count(), 1);
             }
-            void tst_ChartDataSet::removeAllSeries_data()
-                QTest::addColumn<QList<QAbstractSeries*> >("seriesList");
-                QTest::addColumn<QList<QAbstractAxis*> >("axisList");
-                QList<QAbstractSeries*> series;
-                QList<QAbstractAxis*> axis;
-                series << new QLineSeries(this) << new QSplineSeries(this) << new QScatterSeries(this);
-                axis << new QValueAxis(this) << new QValueAxis(this) << new QValueAxis(this);
-                QTest::newRow("3 series , 3 axis") << series << axis;
-            void tst_ChartDataSet::removeAllSeries()
-                QFETCH(QList<QAbstractSeries*>, seriesList);
-                QFETCH(QList<QAbstractAxis*>, axisList);
-                QCOMPARE(m_dataset->series().count(),0);
-                QCOMPARE(m_dataset->axes().count(),0);
-                foreach (QAbstractSeries* series, seriesList) {
-                    m_dataset->addSeries(series);
-                foreach (QAbstractAxis* axis, axisList) {
-                    m_dataset->addAxis(axis,Qt::AlignBottom);
-                for (int i = 0; i < seriesList.count(); i++) {
-                    m_dataset->attachAxis(seriesList.at(i),axisList.at(i));
-                QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis*)));
-                QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
-                QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)));
-                QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)));
-                m_dataset->removeAllSeries();
-                TRY_COMPARE(spy0.count(), 0);
-                TRY_COMPARE(spy1.count(), 0);
-                TRY_COMPARE(spy2.count(), 0);
-                TRY_COMPARE(spy3.count(), seriesList.count());
-                QCOMPARE(m_dataset->series().count(),0);
-                QCOMPARE(m_dataset->axes().count(),axisList.count());
             void tst_ChartDataSet::addAxis_data()
             {
                 QTest::addColumn<QAbstractAxis*>("axis");
                 QAbstractAxis* value = new QValueAxis(this);
                 QAbstractAxis* category = new QCategoryAxis(this);
                 QAbstractAxis* barcategory = new QBarCategoryAxis(this);
                 QAbstractAxis* datetime = new QDateTimeAxis(this);
                 QTest::newRow("value") << value;
                 QTest::newRow("category") << category;
                 QTest::newRow("barcategory") << barcategory;
                 QTest::newRow("datetime") << datetime;
             }
             void tst_ChartDataSet::addAxis()
             {
                 QFETCH(QAbstractAxis*, axis);
                 QVERIFY(m_dataset->axes().isEmpty());
                 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis*)));
                 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
                 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)));
                 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)));
                 m_dataset->addAxis(axis,Qt::AlignBottom);
                 QCOMPARE(m_dataset->axes().count(),1);
                 TRY_COMPARE(spy0.count(), 1);
                 TRY_COMPARE(spy1.count(), 0);
                 TRY_COMPARE(spy2.count(), 0);
                 TRY_COMPARE(spy3.count(), 0);
             }
             void tst_ChartDataSet::removeAxis_data()
             {
                 addAxis_data();
             }
             void tst_ChartDataSet::removeAxis()
             {
                 QFETCH(QAbstractAxis*, axis);
                 QVERIFY(m_dataset->series().isEmpty());
                 m_dataset->addAxis(axis,Qt::AlignBottom);
                 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis*)));
                 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
                 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)));
                 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)));
                 m_dataset->removeAxis(axis);
                 QCOMPARE(m_dataset->series().count(),0);
                 TRY_COMPARE(spy0.count(), 0);
                 TRY_COMPARE(spy1.count(), 1);
                 TRY_COMPARE(spy2.count(), 0);
                 TRY_COMPARE(spy3.count(), 0);
             }
-            void tst_ChartDataSet::removeAllAxes_data()
-                QTest::addColumn<QList<QAbstractSeries*> >("seriesList");
-                QTest::addColumn<QList<QAbstractAxis*> >("axisList");
-                QList<QAbstractSeries*> series;
-                QList<QAbstractAxis*> axis;
-                series << new QLineSeries(this) << new QSplineSeries(this) << new QScatterSeries(this);
-                axis << new QValueAxis(this) << new QValueAxis(this) << new QValueAxis(this);
-                QTest::newRow("3 series , 3 axis") << series << axis;
-            void tst_ChartDataSet::removeAllAxes()
-                QFETCH(QList<QAbstractSeries*>, seriesList);
-                QFETCH(QList<QAbstractAxis*>, axisList);
-                QCOMPARE(m_dataset->series().count(),0);
-                QCOMPARE(m_dataset->axes().count(),0);
-                foreach (QAbstractSeries* series, seriesList) {
-                    m_dataset->addSeries(series);
-                foreach (QAbstractAxis* axis, axisList) {
-                    m_dataset->addAxis(axis,Qt::AlignBottom);
-                for (int i = 0; i < seriesList.count(); i++) {
-                    m_dataset->attachAxis(seriesList.at(i),axisList.at(i));
-                QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis*)));
-                QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
-                QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)));
-                QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)));
-                m_dataset->removeAllAxes();
-                TRY_COMPARE(spy0.count(), 0);
-                TRY_COMPARE(spy1.count(), axisList.count());
-                TRY_COMPARE(spy2.count(), 0);
-                TRY_COMPARE(spy3.count(), 0);
-                QCOMPARE(m_dataset->series().count(),seriesList.count());
-                QCOMPARE(m_dataset->axes().count(),0);
             void tst_ChartDataSet::attachAxis_data()
             {
                 QTest::addColumn<QList<QAbstractSeries*> >("series");
                 QTest::addColumn<QList<QAbstractAxis*> >("axis");
                 QTest::addColumn<QList<Qt::Alignment> >("alignment");
                 QTest::addColumn<QAbstractSeries*>("attachSeries");
                 QTest::addColumn<QAbstractAxis*>("attachAxis");
                 QTest::addColumn<bool>("success");
-                QList<QAbstractSeries*> series;
+                //QAbstractSeries* area = new QAreaSeries(static_cast<QLineSeries*>(line));
-                QList<QAbstractAxis*> axes;
-                QList<Qt::Alignment> alignment;
-                QAbstractSeries* line = new QLineSeries(this);
-                QAbstractSeries* area = new QAreaSeries(static_cast<QLineSeries*>(line));
                 QAbstractSeries* scatter = new QScatterSeries(this);
                 QAbstractSeries* spline = new QSplineSeries(this);
                 QAbstractSeries* pie = new QPieSeries(this);
                 QAbstractSeries* bar = new QBarSeries(this);
                 QAbstractSeries* percent = new QPercentBarSeries(this);
                 QAbstractSeries* stacked = new QStackedBarSeries(this);
-                QAbstractAxis* value1 = new QValueAxis(this);
-                QAbstractAxis* value2 = new QValueAxis(this);
                 QAbstractAxis* category = new QCategoryAxis(this);
                 QAbstractAxis* barcategory = new QBarCategoryAxis(this);
                 QAbstractAxis* datetime = new QDateTimeAxis(this);
+                {
+                 QList<QAbstractSeries*> series;
+                 QList<QAbstractAxis*> axes;
+                 QList<Qt::Alignment> alignment;
+                 QAbstractSeries* line = new QLineSeries(this);
+                 QAbstractAxis* value1 = new QValueAxis(this);
+                 QAbstractAxis* value2 = new QValueAxis(this);
+                 series << line << 0;
+                 axes << value1 << value2;
+                 alignment << Qt::AlignBottom << Qt::AlignLeft;
+                 QTest::newRow("first") << series << axes << alignment << line << value2 << true ;
+                }
-                series << line << 0;
-                axes << value1 << value2;
+                  QList<QAbstractSeries*> series;
-                alignment << Qt::AlignBottom << Qt::AlignLeft;
+                  QList<QAbstractAxis*> axes;
-                QTest::newRow("line + two axes") << series << axes << alignment << line << value2 << true;
+                  QList<Qt::Alignment> alignment;
+                  QAbstractSeries* line = new QLineSeries(this);
+                  QAbstractAxis* value1 = new QValueAxis(this);
+                  QAbstractAxis* value2 = new QValueAxis(this);
+                  series << 0 << line;
+                  axes << value1 << value2;
+                  alignment << Qt::AlignBottom << Qt::AlignLeft;
+                  QTest::newRow("second") << series << axes << alignment << line << value1 << true;
+                }
             }
             void tst_ChartDataSet::attachAxis()
             {
                 QFETCH(QList<QAbstractSeries*>, series);
                 QFETCH(QList<QAbstractAxis*>, axis);
                 QFETCH(QList<Qt::Alignment>, alignment);
                 QFETCH(QAbstractSeries*, attachSeries);
                 QFETCH(QAbstractAxis*, attachAxis);
                 QFETCH(bool, success);
                 Q_ASSERT(series.count() == axis.count());
                 Q_ASSERT(series.count() == alignment.count());
                 QVERIFY(m_dataset->series().isEmpty());
                 QVERIFY(m_dataset->axes().isEmpty());
                 for(int i = 0 ; i < series.count() ; i++){
                     if(series[i]) m_dataset->addSeries(series[i]);
                     if(axis[i]) m_dataset->addAxis(axis[i],alignment[i]);
                     if(series[i] && axis[i]) m_dataset->attachAxis(series[i],axis[i]);
                 }
                 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis*)));
                 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
                 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)));
                 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)));
                 QCOMPARE(m_dataset->attachAxis(attachSeries,attachAxis),success);
             }
             void tst_ChartDataSet::detachAxis_data()
             {
                 QTest::addColumn<QList<QAbstractSeries*> >("series");
                 QTest::addColumn<QList<QAbstractAxis*> >("axis");
                 QTest::addColumn<QAbstractSeries*>("detachSeries");
                 QTest::addColumn<QAbstractAxis*>("detachAxis");
                 QTest::addColumn<bool>("success");
+                {
                 QList<QAbstractSeries*> series;
                 QList<QAbstractAxis*> axes;
                 QAbstractSeries* line = new QLineSeries(this);
                 QAbstractAxis* value = new QValueAxis(this);
                 series << line;
                 axes << value;
-                QTest::newRow("line + axis") << series << axes << line << value << true;
+                QTest::newRow("first") << series << axes << line << value << true;
+                }
             }
             void tst_ChartDataSet::detachAxis()
             {
                 QFETCH(QList<QAbstractSeries*>, series);
                 QFETCH(QList<QAbstractAxis*>, axis);
                 QFETCH(QAbstractSeries*, detachSeries);
                 QFETCH(QAbstractAxis*, detachAxis);
                 QFETCH(bool, success);
                 Q_ASSERT(series.count() == axis.count());
                 QVERIFY(m_dataset->series().isEmpty());
                 QVERIFY(m_dataset->axes().isEmpty());
                 for(int i = 0; i < series.count(); i++) {
                     if(series[i]) m_dataset->addSeries(series[i]);
                     if(axis[i]) m_dataset->addAxis(axis[i],Qt::AlignBottom);
                     if(series[i] && axis[i]) m_dataset->attachAxis(series[i],axis[i]);
                 }
                 QSignalSpy spy0(m_dataset, SIGNAL(axisAdded(QAbstractAxis*)));
                 QSignalSpy spy1(m_dataset, SIGNAL(axisRemoved(QAbstractAxis*)));
                 QSignalSpy spy2(m_dataset, SIGNAL(seriesAdded(QAbstractSeries*)));
                 QSignalSpy spy3(m_dataset, SIGNAL(seriesRemoved(QAbstractSeries*)));
                 QCOMPARE(m_dataset->detachAxis(detachSeries,detachAxis),success);
             }
             QTEST_MAIN(tst_ChartDataSet)
             #include "tst_chartdataset.moc"
             #endif

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