HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2719:5490e1de47f4

Fix QAbstractAxis::AxisTypes enum values....

Miikka Heikkinen -

r2719:5490e1de47f4

parent child

Context file:

r2719:5490e1de47f4

Collapse all files

src/charts/axis/qabstractaxis.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2014 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 Enterprise Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Enterprise licenses may use this file in
             ** accordance with the Qt Enterprise 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 <QtCharts/QAbstractAxis>
             #include <private/qabstractaxis_p.h>
             #include <private/chartdataset_p.h>
             #include <private/charttheme_p.h>
             #include <private/qchart_p.h>
             QT_CHARTS_BEGIN_NAMESPACE
             /*!
                 \class QAbstractAxis
                 \inmodule Qt Charts
                 \brief The QAbstractAxis class is used for manipulating chart's axis.
                 \mainclass
                 Each series can be bound to one or more horizontal and vertical axes, but mixing axis types
                 that would result in different domains is not supported, such as specifying
                 QValueAxis and QLogValueAxis on the same orientation.
                 Properties and visibility of various axis elements such as axis line, title, labels, grid lines,
                 and shades can be individually controlled.
             */
             /*!
                 \qmltype AbstractAxis
                 \instantiates QAbstractAxis
                 \inqmlmodule QtCharts
                 \brief The AbstractAxis is a base element used for specialized axis elements.
                 Each series can be bound to only one horizontal and vertical axis.
                 Properties and visibility of various axis elements such as axis line, title, labels, grid lines,
                 and shades can be individually controlled.
             */
             /*!
                 \enum QAbstractAxis::AxisType
-                The type of the series object.
+                The type of the axis object.
                 \value AxisTypeNoAxis
                 \value AxisTypeValue
                 \value AxisTypeBarCategory
                 \value AxisTypeCategory
                 \value AxisTypeDateTime
                 \value AxisTypeLogValue
             */
             /*!
              *\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::linePen
               The pen of the line.
             */
             /*!
               \property QAbstractAxis::labelsVisible
               Defines if axis labels are visible.
             */
             /*!
               \qmlproperty bool AbstractAxis::labelsVisible
               Defines if axis labels are visible.
             */
             /*!
               \property QAbstractAxis::labelsPen
               \deprecated
               The pen of the labels.
             */
             /*!
               \property QAbstractAxis::labelsBrush
               The brush of the labels. Only the color of the brush is relevant.
             */
             /*!
               \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::gridLinePen
               The pen of the grid line.
             */
             /*!
               \property QAbstractAxis::labelsFont
               The font of the axis labels.
             */
             /*!
               \qmlproperty Font AbstractAxis::labelsFont
               The font of the axis labels.
               See the Qt documentation for more details of Font.
             */
             /*!
               \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::shadesPen
               The pen of the axis shades (area between grid lines).
             */
             /*!
               \property QAbstractAxis::shadesBrush
               The brush of the axis shades (area between grid lines).
             */
             /*!
               \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::titleText
               The title of the axis. Empty by default. Axis titles support html formatting.
             */
             /*!
               \qmlproperty String AbstractAxis::titleText
               The title of the axis. Empty by default. Axis titles support html formatting.
             */
             /*!
               \property QAbstractAxis::titlePen
               \deprecated
               The pen of the title text.
             */
             /*!
               \property QAbstractAxis::titleBrush
               The brush of the title text. Only the color of the brush is relevant.
             */
             /*!
               \property QAbstractAxis::titleFont
               The font of the title of the axis.
             */
             /*!
               \qmlproperty Font AbstractAxis::titleFont
               The font of the title of the axis.
             */
             /*!
               \property QAbstractAxis::orientation
               The orientation of the axis. Fixed to either Qt::Horizontal or Qt::Vertical when you add the axis to a chart.
             */
             /*!
               \qmlproperty Qt.Orientation AbstractAxis::orientation
               The orientation of the axis. Fixed to either Qt.Horizontal or Qt.Vertical when the axis is set to a series.
             */
             /*!
               \property QAbstractAxis::alignment
               The alignment of the axis. Can be Qt::AlignLeft, Qt::AlignRight, Qt::AlignBottom, or Qt::AlignTop.
             */
             /*!
               \qmlproperty alignment AbstractAxis::alignment
               The alignment of the axis. Can be Qt.AlignLeft, Qt.AlignRight, Qt.AlignBottom, or Qt.AlignTop.
             */
             /*!
               \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::linePenChanged(const QPen& pen)
               The pen of the line of the axis has changed to \a pen.
             */
             /*!
               \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::labelsFontChanged(const QFont& font)
               The font of the axis labels has changed to \a font.
             */
             /*!
               \qmlsignal AbstractAxis::onLabelsFontChanged(Font font)
               The font of the axis labels has changed to \a font.
             */
             /*!
               \fn void QAbstractAxis::labelsPenChanged(const QPen& pen)
               \deprecated
               The pen of the axis labels has changed to \a pen.
             */
             /*!
               \fn void QAbstractAxis::labelsBrushChanged(const QBrush& brush)
               The brush of the axis labels has changed to \a brush.
             */
             /*!
               \fn void QAbstractAxis::labelsAngleChanged(int angle)
               The angle of the axis labels has changed to \a angle.
             */
             /*!
               \qmlsignal AbstractAxis::onLabelsAngleChanged(int angle)
               The angle of the axis labels has changed to \a angle.
             */
             /*!
               \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::gridLinePenChanged(const QPen& pen)
               The pen of the grid line has changed to \a pen.
             */
             /*!
               \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::titleVisibleChanged(bool visible)
               Visibility of the title text of the axis has changed to \a visible.
             */
             /*!
               \qmlsignal AbstractAxis::onTitleVisibleChanged(bool visible)
               Visibility of the title text of the axis has changed to \a visible.
             */
             /*!
               \fn void QAbstractAxis::titleTextChanged(const QString& text)
               The text of the axis title has changed to \a text.
             */
             /*!
               \qmlsignal AbstractAxis::onTitleTextChanged(String text)
               The text of the axis title has changed to \a text.
             */
             /*!
               \fn void QAbstractAxis::titlePenChanged(const QPen& pen)
               \deprecated
               The pen of the axis shades has changed to \a pen.
             */
             /*!
               \fn void QAbstractAxis::titleBrushChanged(const QBrush& brush)
               The brush of the axis title has changed to \a brush.
             */
             /*!
               \fn void QAbstractAxis::titleFontChanged(const QFont& font)
               The font of the axis title has changed to \a font.
             */
             /*!
               \qmlsignal AbstractAxis::onTitleFontChanged(Font font)
               The font of the axis title has changed to \a font.
             */
             /*!
               \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.
             */
             /*!
               \fn void QAbstractAxis::shadesBrushChanged(const QBrush& brush)
               The brush of the axis shades has changed to \a brush.
             */
             /*!
               \fn void QAbstractAxis::shadesPenChanged(const QPen& pen)
               The pen of the axis shades has changed to \a pen.
             */
             /*!
              \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
             {
                 if (d_ptr->m_axisPen == QChartPrivate::defaultPen())
                     return QPen();
                 else
                     return d_ptr->m_axisPen;
             }
             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 linePen().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
             {
                 if (d_ptr->m_gridLinePen == QChartPrivate::defaultPen())
                     return QPen();
                 else
                     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;
             }
             void QAbstractAxis::setLabelsPen(const QPen &pen)
             {
                 if (d_ptr->m_labelsPen != pen) {
                     d_ptr->m_labelsPen = pen;
                     emit labelsPenChanged(pen);
                 }
             }
             QPen QAbstractAxis::labelsPen() const
             {
                 if (d_ptr->m_labelsPen == QChartPrivate::defaultPen())
                     return QPen();
                 else
                     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
             {
                 if (d_ptr->m_labelsBrush == QChartPrivate::defaultBrush())
                     return QBrush();
                 else
                     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
             {
                 if (d_ptr->m_labelsFont == QChartPrivate::defaultFont())
                     return QFont();
                 else
                     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;
             }
             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 labelsBrush().color();
             }
             void QAbstractAxis::setTitleVisible(bool visible)
             {
                 if (d_ptr->m_titleVisible != visible) {
                     d_ptr->m_titleVisible = visible;
                     emit titleVisibleChanged(visible);
                 }
             }
             bool QAbstractAxis::isTitleVisible() const
             {
                 return d_ptr->m_titleVisible;
             }
             void QAbstractAxis::setTitlePen(const QPen &pen)
             {
                 if (d_ptr->m_titlePen != pen) {
                     d_ptr->m_titlePen = pen;
                     emit titlePenChanged(pen);
                 }
             }
             QPen QAbstractAxis::titlePen() const
             {
                 if (d_ptr->m_titlePen == QChartPrivate::defaultPen())
                     return QPen();
                 else
                     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
             {
                 if (d_ptr->m_titleBrush == QChartPrivate::defaultBrush())
                     return QBrush();
                 else
                     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
             {
                 if (d_ptr->m_titleFont == QChartPrivate::defaultFont())
                     return QFont();
                 else
                     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
             {
                 if (d_ptr->m_shadesPen == QChartPrivate::defaultPen())
                     return QPen();
                 else
                     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
             {
                 if (d_ptr->m_shadesBrush == QChartPrivate::defaultBrush())
                     return QBrush(Qt::SolidPattern);
                 else
                     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 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 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)
             */
             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_alignment(0),
                   m_orientation(Qt::Orientation(0)),
                   m_visible(true),
                   m_arrowVisible(true),
                   m_axisPen(QChartPrivate::defaultPen()),
                   m_axisBrush(QChartPrivate::defaultBrush()),
                   m_gridLineVisible(true),
                   m_gridLinePen(QChartPrivate::defaultPen()),
                   m_labelsVisible(true),
                   m_labelsPen(QChartPrivate::defaultPen()),
                   m_labelsBrush(QChartPrivate::defaultBrush()),
                   m_labelsFont(QChartPrivate::defaultFont()),
                   m_labelsAngle(0),
                   m_titleVisible(true),
                   m_titlePen(QChartPrivate::defaultPen()),
                   m_titleBrush(QChartPrivate::defaultBrush()),
                   m_titleFont(QChartPrivate::defaultFont()),
                   m_shadesVisible(false),
                   m_shadesPen(QChartPrivate::defaultPen()),
                   m_shadesBrush(QChartPrivate::defaultBrush()),
                   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)
             {
                 if (forced || QChartPrivate::defaultPen() == m_axisPen)
                     q_ptr->setLinePen(theme->axisLinePen());
                 if (forced || QChartPrivate::defaultPen() == m_gridLinePen)
                     q_ptr->setGridLinePen(theme->girdLinePen());
                 if (forced || QChartPrivate::defaultBrush() == m_labelsBrush)
                     q_ptr->setLabelsBrush(theme->labelBrush());
                 if (forced || QChartPrivate::defaultPen() == m_labelsPen)
                     q_ptr->setLabelsPen(Qt::NoPen); // NoPen for performance reasons
                 if (forced || QChartPrivate::defaultFont() == m_labelsFont)
                     q_ptr->setLabelsFont(theme->labelFont());
                 if (forced || QChartPrivate::defaultBrush() == m_titleBrush)
                     q_ptr->setTitleBrush(theme->labelBrush());
                 if (forced || QChartPrivate::defaultPen() == m_titlePen)
                     q_ptr->setTitlePen(Qt::NoPen); // NoPen for performance reasons
                 if (forced || QChartPrivate::defaultFont() == m_titleFont) {
                     QFont font(m_labelsFont);
                     font.setBold(true);
                     q_ptr->setTitleFont(font);
                 }
                 if (forced || QChartPrivate::defaultBrush() == m_shadesBrush)
                     q_ptr->setShadesBrush(theme->backgroundShadesBrush());
                 if (forced || QChartPrivate::defaultPen() == m_shadesPen)
                     q_ptr->setShadesPen(theme->backgroundShadesPen());
                 bool axisX = m_orientation == Qt::Horizontal;
                 if (forced && (theme->backgroundShades() == ChartTheme::BackgroundShadesBoth
                         || (theme->backgroundShades() == ChartTheme::BackgroundShadesVertical && axisX)
                         || (theme->backgroundShades() == ChartTheme::BackgroundShadesHorizontal && !axisX))) {
                      q_ptr->setShadesVisible(true);
                 } else if (forced) {
                     q_ptr->setShadesVisible(false);
                 }
             }
             void QAbstractAxisPrivate::handleRangeChanged(qreal min, qreal max)
             {
                 setRange(min,max);
             }
             void QAbstractAxisPrivate::initializeGraphics(QGraphicsItem* parent)
             {
                 Q_UNUSED(parent);
             }
             void QAbstractAxisPrivate::initializeAnimations(QChart::AnimationOptions options)
             {
                 ChartAxisElement *axis = m_item.data();
                 Q_ASSERT(axis);
                 if (axis->animation())
                     axis->animation()->stopAndDestroyLater();
                 if (options.testFlag(QChart::GridAxisAnimations))
                     axis->setAnimation(new AxisAnimation(axis));
                 else
                     axis->setAnimation(0);
             }
             #include "moc_qabstractaxis.cpp"
             #include "moc_qabstractaxis_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/axis/qabstractaxis.h +3 -3

             /****************************************************************************
             **
             ** Copyright (C) 2014 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 Enterprise Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Enterprise licenses may use this file in
             ** accordance with the Qt Enterprise 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 <QtCharts/QChartGlobal>
             #include <QtGui/QPen>
             #include <QtGui/QFont>
             #include <QtCore/QVariant>
             QT_CHARTS_BEGIN_NAMESPACE
             class QAbstractAxisPrivate;
             class QT_CHARTS_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)
                 Q_PROPERTY(QColor color READ linePenColor WRITE setLinePenColor NOTIFY colorChanged)
                 //labels
                 Q_PROPERTY(bool labelsVisible READ labelsVisible WRITE setLabelsVisible NOTIFY labelsVisibleChanged)
                 Q_PROPERTY(QPen labelsPen READ labelsPen WRITE setLabelsPen NOTIFY labelsPenChanged)
                 Q_PROPERTY(QBrush labelsBrush READ labelsBrush WRITE setLabelsBrush NOTIFY labelsBrushChanged)
                 Q_PROPERTY(int labelsAngle READ labelsAngle WRITE setLabelsAngle NOTIFY labelsAngleChanged)
                 Q_PROPERTY(QFont labelsFont READ labelsFont WRITE setLabelsFont NOTIFY labelsFontChanged)
                 Q_PROPERTY(QColor labelsColor READ labelsColor WRITE setLabelsColor NOTIFY labelsColorChanged)
                 //grid
                 Q_PROPERTY(bool gridVisible READ isGridLineVisible WRITE setGridLineVisible NOTIFY gridVisibleChanged)
                 Q_PROPERTY(QPen gridLinePen READ gridLinePen WRITE setGridLinePen NOTIFY gridLinePenChanged)
                 //shades
                 Q_PROPERTY(bool shadesVisible READ shadesVisible WRITE setShadesVisible NOTIFY shadesVisibleChanged)
                 Q_PROPERTY(QColor shadesColor READ shadesColor WRITE setShadesColor NOTIFY shadesColorChanged)
                 Q_PROPERTY(QColor shadesBorderColor READ shadesBorderColor WRITE setShadesBorderColor NOTIFY shadesBorderColorChanged)
                 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 isTitleVisible WRITE setTitleVisible NOTIFY titleVisibleChanged)
                 Q_PROPERTY(QFont titleFont READ titleFont WRITE setTitleFont NOTIFY titleFontChanged)
                 //orientation
                 Q_PROPERTY(Qt::Orientation orientation READ orientation)
                 //aligment
                 Q_PROPERTY(Qt::Alignment alignment READ alignment)
             public:
                 enum AxisType {
                     AxisTypeNoAxis = 0x0,
                     AxisTypeValue = 0x1,
                     AxisTypeBarCategory = 0x2,
-                    AxisTypeCategory = 0x3,
+                    AxisTypeCategory = 0x4,
-                    AxisTypeDateTime = 0x4,
+                    AxisTypeDateTime = 0x8,
-                    AxisTypeLogValue = 0x5
+                    AxisTypeLogValue = 0x10
                 };
                 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 isTitleVisible() 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();
                 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 ChartPresenter;
                 friend class ChartThemeManager;
                 friend class AbstractDomain;
                 friend class ChartAxisElement;
                 friend class XYChart;
             };
             QT_CHARTS_END_NAMESPACE
             #endif // QABSTRACTAXIS_H

src/charts/chartdataset.cpp +4 -19

             /****************************************************************************
             **
             ** Copyright (C) 2014 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 Enterprise Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Enterprise licenses may use this file in
             ** accordance with the Qt Enterprise 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 <private/chartdataset_p.h>
             #include <private/chartpresenter_p.h>
             #include <QtCharts/QChart>
             #include <private/qchart_p.h>
             #include <QtCharts/QValueAxis>
             #include <QtCharts/QBarCategoryAxis>
             #include <private/qvalueaxis_p.h>
             #include <QtCharts/QCategoryAxis>
             #include <private/qabstractseries_p.h>
             #include <QtCharts/QAbstractBarSeries>
             #include <QtCharts/QStackedBarSeries>
             #include <QtCharts/QPercentBarSeries>
             #include <QtCharts/QPieSeries>
             #include <private/chartitem_p.h>
             #include <private/xydomain_p.h>
             #include <private/xypolardomain_p.h>
             #include <private/xlogydomain_p.h>
             #include <private/logxydomain_p.h>
             #include <private/logxlogydomain_p.h>
             #include <private/xlogypolardomain_p.h>
             #include <private/logxypolardomain_p.h>
             #include <private/logxlogypolardomain_p.h>
             #ifndef QT_ON_ARM
             #include <QtCharts/QDateTimeAxis>
             #endif
             QT_CHARTS_BEGIN_NAMESPACE
             ChartDataSet::ChartDataSet(QChart *chart)
                 : QObject(chart),
                   m_chart(chart)
             {
             }
             ChartDataSet::~ChartDataSet()
             {
                 deleteAllSeries();
                 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;
                 }
                 // Ignore unsupported series added to polar chart
                 if (m_chart && m_chart->chartType() == QChart::ChartTypePolar) {
                     if (!(series->type() == QAbstractSeries::SeriesTypeArea
                         || series->type() == QAbstractSeries::SeriesTypeLine
                         || series->type() == QAbstractSeries::SeriesTypeScatter
                         || series->type() == QAbstractSeries::SeriesTypeSpline)) {
                         qWarning() << QObject::tr("Can not add series. Series type is not supported by a polar chart.");
                         return;
                     }
                     series->d_ptr->setDomain(new XYPolarDomain());
                 } else {
                     series->d_ptr->setDomain(new XYDomain());
                 }
                 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;
                 };
                 AbstractDomain *newDomain;
                 if (m_chart && m_chart->chartType() == QChart::ChartTypePolar)
                     newDomain = new XYPolarDomain();
                 else
                     newDomain = new XYDomain();
                 QSharedPointer<AbstractDomain> domain(newDomain);
                 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;
                 }
                 QList<QAbstractAxis*> axes = series->d_ptr->m_axes;
                 foreach(QAbstractAxis* axis, axes) {
                     detachAxis(series,axis);
                 }
                 emit seriesRemoved(series);
                 m_seriesList.removeAll(series);
                 // Reset domain to default
                 series->d_ptr->setDomain(new XYDomain());
                 series->setParent(0);
                 series->d_ptr->m_chart = 0;
             }
             /*
              * 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;
                 }
                 QList<QAbstractSeries*> series =  axis->d_ptr->m_series;
                 foreach(QAbstractSeries* s, series) {
                   detachAxis(s,axis);
                 }
                 emit axisRemoved(axis);
                 m_axisList.removeAll(axis);
                 axis->setParent(0);
                 axis->d_ptr->m_chart = 0;
             }
             /*
              * This method attaches axis to series, return true if success.
              */
             bool ChartDataSet::attachAxis(QAbstractSeries *series,QAbstractAxis *axis)
             {
                 Q_ASSERT(axis);
                 if (!series)
                     return false;
                 QList<QAbstractSeries *> attachedSeriesList = axis->d_ptr->m_series;
                 QList<QAbstractAxis *> attachedAxisList = series->d_ptr->m_axes;
                 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;
                 }
                 if (attachedSeriesList.contains(series)) {
                     qWarning() << QObject::tr("Axis already attached to series.");
                     return false;
                 }
                 AbstractDomain *domain = series->d_ptr->domain();
                 AbstractDomain::DomainType type = selectDomain(attachedAxisList<<axis);
                 if (type == AbstractDomain::UndefinedDomain) return false;
                 if (domain->type() != type) {
                     AbstractDomain *old = domain;
                     domain = createDomain(type);
                     domain->setRange(old->minX(), old->maxX(), old->minY(), old->maxY());
                     // Initialize domain size to old domain size, as it won't get updated
                     // unless geometry changes.
                     domain->setSize(old->size());
                 }
                 if (!domain)
                     return false;
                 if (!domain->attachAxis(axis))
                     return false;
                 QList<AbstractDomain *> blockedDomains;
                 domain->blockRangeSignals(true);
                 blockedDomains << domain;
                 if (domain != series->d_ptr->domain()) {
                     foreach (QAbstractAxis *axis, series->d_ptr->m_axes) {
                         series->d_ptr->domain()->detachAxis(axis);
                         domain->attachAxis(axis);
                         foreach (QAbstractSeries *otherSeries, axis->d_ptr->m_series) {
                             if (otherSeries != series && otherSeries->d_ptr->domain()) {
                                 if (!otherSeries->d_ptr->domain()->rangeSignalsBlocked()) {
                                     otherSeries->d_ptr->domain()->blockRangeSignals(true);
                                     blockedDomains << otherSeries->d_ptr->domain();
                                 }
                             }
                         }
                     }
                     series->d_ptr->setDomain(domain);
                     series->d_ptr->initializeDomain();
                 }
                 series->d_ptr->m_axes<<axis;
                 axis->d_ptr->m_series<<series;
                 series->d_ptr->initializeAxes();
                 axis->d_ptr->initializeDomain(domain);
                 foreach (AbstractDomain *blockedDomain, blockedDomains)
                     blockedDomain->blockRangeSignals(false);
                 return true;
             }
             /*
              * 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;
                 AbstractDomain* domain =  series->d_ptr->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);
                 return true;
             }
             void ChartDataSet::createDefaultAxes()
             {
                 if (m_seriesList.isEmpty())
                     return;
                 QAbstractAxis::AxisTypes typeX(0);
                 QAbstractAxis::AxisTypes typeY(0);
                 // Remove possibly existing axes
                 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);
-                // As long as AxisType enum balues are sequential a check to see if there are series of
+                createAxes(typeY, Qt::Vertical);
-                // different types is needed. In such cases AxisTypeNoAxis is used to create separate axes
-                // for the types.
-                if (typeX != QAbstractAxis::AxisTypeNoAxis) {
-                    if (typeX != m_seriesList.first()->d_ptr->defaultAxisType(Qt::Horizontal))
-                        typeX = QAbstractAxis::AxisTypeNoAxis;
-                    createAxes(typeX, Qt::Horizontal);
-                if (typeY != QAbstractAxis::AxisTypeNoAxis) {
-                    if (typeY != m_seriesList.first()->d_ptr->defaultAxisType(Qt::Vertical))
-                        typeY = QAbstractAxis::AxisTypeNoAxis;
-                    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);
                     qreal min = 0;
                     qreal max = 0;
                     findMinMaxForSeries(m_seriesList,orientation,min,max);
                     foreach(QAbstractSeries *s, m_seriesList) {
                         attachAxis(s,axis);
                     }
                     axis->setRange(min,max);
+                } else {
-                else if (type.testFlag(QAbstractAxis::AxisTypeNoAxis)) {
+                    // Create separate axis for each series
-                    //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::findMinMaxForSeries(QList<QAbstractSeries *> series,Qt::Orientations orientation, qreal &min, qreal &max)
             {
                 Q_ASSERT(!series.isEmpty());
                 AbstractDomain *domain = series.first()->d_ptr->domain();
                 min = (orientation == Qt::Vertical) ? domain->minY() : domain->minX();
                 max = (orientation == Qt::Vertical) ? domain->maxY() : domain->maxX();
                 for (int i = 1; i< series.size(); i++) {
                     AbstractDomain *domain = series[i]->d_ptr->domain();
                     min = qMin((orientation == Qt::Vertical) ? domain->minY() : domain->minX(), min);
                     max = qMax((orientation == Qt::Vertical) ? domain->maxY() : domain->maxX(), max);
                 }
                 if (min == max) {
                     min -= 0.5;
                     max += 0.5;
                 }
             }
             void ChartDataSet::deleteAllSeries()
             {
                 foreach (QAbstractSeries *s , m_seriesList){
                     removeSeries(s);
                     s->deleteLater();
                 }
                 Q_ASSERT(m_seriesList.count() == 0);
             }
             void ChartDataSet::deleteAllAxes()
             {
                 foreach (QAbstractAxis *a , m_axisList){
                     removeAxis(a);
                     a->deleteLater();
                 }
                 Q_ASSERT(m_axisList.count() == 0);
             }
             void ChartDataSet::zoomInDomain(const QRectF &rect)
             {
                 QList<AbstractDomain*> domains;
                 foreach(QAbstractSeries *s, m_seriesList) {
                     AbstractDomain* domain = s->d_ptr->domain();
                     s->d_ptr->m_domain->blockRangeSignals(true);
                     domains<<domain;
                 }
                 foreach(AbstractDomain *domain, domains)
                     domain->zoomIn(rect);
                 foreach(AbstractDomain *domain, domains)
                     domain->blockRangeSignals(false);
             }
             void ChartDataSet::zoomOutDomain(const QRectF &rect)
             {
                 QList<AbstractDomain*> domains;
                 foreach(QAbstractSeries *s, m_seriesList) {
                     AbstractDomain* domain = s->d_ptr->domain();
                     s->d_ptr->m_domain->blockRangeSignals(true);
                     domains<<domain;
                 }
                 foreach(AbstractDomain *domain, domains)
                     domain->zoomOut(rect);
                 foreach(AbstractDomain *domain, domains)
                     domain->blockRangeSignals(false);
             }
             void ChartDataSet::zoomResetDomain()
             {
                 QList<AbstractDomain*> domains;
                 foreach (QAbstractSeries *s, m_seriesList) {
                     AbstractDomain *domain = s->d_ptr->domain();
                     s->d_ptr->m_domain->blockRangeSignals(true);
                     domains << domain;
                 }
                 foreach (AbstractDomain *domain, domains)
                     domain->zoomReset();
                 foreach (AbstractDomain *domain, domains)
                     domain->blockRangeSignals(false);
             }
             bool ChartDataSet::isZoomedDomain()
             {
                 foreach (QAbstractSeries *s, m_seriesList) {
                     if (s->d_ptr->domain()->isZoomed())
                         return true;
                 }
                 return false;
             }
             void ChartDataSet::scrollDomain(qreal dx, qreal dy)
             {
                 QList<AbstractDomain*> domains;
                 foreach(QAbstractSeries *s, m_seriesList) {
                     AbstractDomain* domain = s->d_ptr->domain();
                     s->d_ptr->m_domain->blockRangeSignals(true);
                     domains<<domain;
                 }
                 foreach(AbstractDomain *domain, domains)
                     domain->move(dx, dy);
                 foreach(AbstractDomain *domain, domains)
                     domain->blockRangeSignals(false);
             }
             QPointF ChartDataSet::mapToValue(const QPointF &position, QAbstractSeries *series)
             {
                 QPointF point;
                 if (series == 0 && !m_seriesList.isEmpty())
                     series = m_seriesList.first();
                 if (series && series->type() == QAbstractSeries::SeriesTypePie)
                     return point;
                 if (series && m_seriesList.contains(series))
                     point = series->d_ptr->m_domain->calculateDomainPoint(position - m_chart->plotArea().topLeft());
                 return point;
             }
             QPointF ChartDataSet::mapToPosition(const QPointF &value, QAbstractSeries *series)
             {
                 QPointF point = m_chart->plotArea().topLeft();
                 if (series == 0 && !m_seriesList.isEmpty())
                     series = m_seriesList.first();
                 if (series && series->type() == QAbstractSeries::SeriesTypePie)
                     return QPoint(0, 0);
                 bool ok;
                 if (series && m_seriesList.contains(series))
                     point += series->d_ptr->m_domain->calculateGeometryPoint(value, ok);
                 return point;
             }
             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 {
                     Undefined = 0,
                     LogType = 0x1,
                     ValueType = 0x2
                 };
                 int horizontal(Undefined);
                 int vertical(Undefined);
                 // Assume cartesian chart type, unless chart is set
                 QChart::ChartType chartType(QChart::ChartTypeCartesian);
                 if (m_chart)
                     chartType = m_chart->chartType();
                 foreach (QAbstractAxis *axis, axes)
                 {
                     switch (axis->type()) {
                     case QAbstractAxis::AxisTypeLogValue:
                         if (axis->orientation() == Qt::Horizontal)
                             horizontal |= LogType;
                         if (axis->orientation() == Qt::Vertical)
                             vertical |= LogType;
                         break;
                     case QAbstractAxis::AxisTypeValue:
                     case QAbstractAxis::AxisTypeBarCategory:
                     case QAbstractAxis::AxisTypeCategory:
                     case QAbstractAxis::AxisTypeDateTime:
                         if (axis->orientation() == Qt::Horizontal)
                             horizontal |= ValueType;
                         if (axis->orientation() == Qt::Vertical)
                             vertical |= ValueType;
                         break;
                     default:
                         qWarning() << "Undefined type";
                         break;
                     }
                 }
                 if (vertical == Undefined)
                     vertical = ValueType;
                 if (horizontal == Undefined)
                     horizontal = ValueType;
                 if (vertical == ValueType && horizontal == ValueType) {
                     if (chartType == QChart::ChartTypeCartesian)
                         return AbstractDomain::XYDomain;
                     else if (chartType == QChart::ChartTypePolar)
                         return AbstractDomain::XYPolarDomain;
                 }
                 if (vertical == LogType && horizontal == ValueType) {
                     if (chartType == QChart::ChartTypeCartesian)
                         return AbstractDomain::XLogYDomain;
                     if (chartType == QChart::ChartTypePolar)
                         return AbstractDomain::XLogYPolarDomain;
                 }
                 if (vertical == ValueType && horizontal == LogType) {
                     if (chartType == QChart::ChartTypeCartesian)
                         return AbstractDomain::LogXYDomain;
                     else if (chartType == QChart::ChartTypePolar)
                         return AbstractDomain::LogXYPolarDomain;
                 }
                 if (vertical == LogType && horizontal == LogType) {
                     if (chartType == QChart::ChartTypeCartesian)
                         return AbstractDomain::LogXLogYDomain;
                     else if (chartType == QChart::ChartTypePolar)
                         return AbstractDomain::LogXLogYPolarDomain;
                 }
                 return AbstractDomain::UndefinedDomain;
             }
             //refactor create factory
             AbstractDomain* ChartDataSet::createDomain(AbstractDomain::DomainType type)
             {
                 switch (type)
                 {
                 case AbstractDomain::LogXLogYDomain:
                     return new LogXLogYDomain();
                 case AbstractDomain::XYDomain:
                     return new XYDomain();
                 case AbstractDomain::XLogYDomain:
                     return new XLogYDomain();
                 case AbstractDomain::LogXYDomain:
                     return new LogXYDomain();
                 case AbstractDomain::XYPolarDomain:
                     return new XYPolarDomain();
                 case AbstractDomain::XLogYPolarDomain:
                     return new XLogYPolarDomain();
                 case AbstractDomain::LogXYPolarDomain:
                     return new LogXYPolarDomain();
                 case AbstractDomain::LogXLogYPolarDomain:
                     return new LogXLogYPolarDomain();
                 default:
                     return 0;
                 }
             }
             #include "moc_chartdataset_p.cpp"
             QT_CHARTS_END_NAMESPACE

General Comments 0

Write
Preview

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

No TODOs yet

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

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