HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1654:746d930ea165

abstract axis qml documentation. bug fix to setArrowVisible

sauimone -

r1654:746d930ea165

parent child

Context file:

r1654:746d930ea165

Collapse all files

src/axis/chartaxis.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "chartaxis_p.h"
             #include "qabstractaxis.h"
             #include "qabstractaxis_p.h"
             #include "chartpresenter_p.h"
             #include "chartanimator_p.h"
             #include <QPainter>
             #include <QDebug>
             #include <qmath.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartAxis::ChartAxis(QAbstractAxis *axis,ChartPresenter *presenter) : Chart(presenter),
                 m_chartAxis(axis),
                 m_labelsAngle(0),
                 m_grid(new QGraphicsItemGroup(presenter->rootItem())),
                 m_shades(new QGraphicsItemGroup(presenter->rootItem())),
                 m_labels(new QGraphicsItemGroup(presenter->rootItem())),
                 m_axis(new QGraphicsItemGroup(presenter->rootItem())),
                 m_min(0),
                 m_max(0),
                 m_ticksCount(0),
                 m_animation(0),
                 m_minWidth(0),
                 m_minHeight(0)
             {
                 //initial initialization
                 m_axis->setZValue(ChartPresenter::AxisZValue);
                 m_axis->setHandlesChildEvents(false);
                 m_shades->setZValue(ChartPresenter::ShadesZValue);
                 m_grid->setZValue(ChartPresenter::GridZValue);
                 QObject::connect(m_chartAxis->d_ptr.data(),SIGNAL(updated()),this,SLOT(handleAxisUpdated()));
                 QGraphicsSimpleTextItem item;
                 m_font = item.font();
                 handleAxisUpdated();
             }
             ChartAxis::~ChartAxis()
             {
             }
             void ChartAxis::setAnimation(AxisAnimation* animation)
             {
                 m_animation=animation;
             }
             void ChartAxis::setLayout(QVector<qreal> &layout)
             {
                 m_layoutVector=layout;
             }
             void ChartAxis::createItems(int count)
             {
                 if (m_axis->children().size() == 0)
                 m_axis->addToGroup(new AxisItem(this));
                 for (int i = 0; i < count; ++i) {
                     m_grid->addToGroup(new QGraphicsLineItem());
                     m_labels->addToGroup(new QGraphicsSimpleTextItem());
                     m_axis->addToGroup(new QGraphicsLineItem());
                     if ((m_grid->childItems().size())%2 && m_grid->childItems().size()>2) m_shades->addToGroup(new QGraphicsRectItem());
                 }
             }
             void ChartAxis::deleteItems(int count)
             {
                 QList<QGraphicsItem *> lines = m_grid->childItems();
                 QList<QGraphicsItem *> labels = m_labels->childItems();
                 QList<QGraphicsItem *> shades = m_shades->childItems();
                 QList<QGraphicsItem *> axis = m_axis->childItems();
                 for (int i = 0; i < count; ++i) {
                     if (lines.size()%2 && lines.size() > 1) delete(shades.takeLast());
                     delete(lines.takeLast());
                     delete(labels.takeLast());
                     delete(axis.takeLast());
                 }
             }
             void ChartAxis::updateLayout(QVector<qreal> &layout)
             {
                 int diff = m_layoutVector.size() - layout.size();
                 if (diff>0) {
                     deleteItems(diff);
                 }
                 else if (diff<0) {
                     createItems(-diff);
                 }
                 if( diff!=0) handleAxisUpdated();
                 if (m_animation) {
                       switch(presenter()->state()){
                           case ChartPresenter::ZoomInState:
                               m_animation->setAnimationType(AxisAnimation::ZoomInAnimation);
                               m_animation->setAnimationPoint(presenter()->statePoint());
                               break;
                           case ChartPresenter::ZoomOutState:
                               m_animation->setAnimationType(AxisAnimation::ZoomOutAnimation);
                               m_animation->setAnimationPoint(presenter()->statePoint());
                               break;
                           case ChartPresenter::ScrollUpState:
                           case ChartPresenter::ScrollLeftState:
                               m_animation->setAnimationType(AxisAnimation::MoveBackwordAnimation);
                               break;
                           case ChartPresenter::ScrollDownState:
                           case ChartPresenter::ScrollRightState:
                               m_animation->setAnimationType(AxisAnimation::MoveForwardAnimation);
                               break;
                           case ChartPresenter::ShowState:
                               m_animation->setAnimationType(AxisAnimation::DefaultAnimation);
                               break;
                       }
                       m_animation->setValues(m_layoutVector,layout);
                       presenter()->startAnimation(m_animation);
                 }
                 else {
                     setLayout(layout);
                     updateGeometry();
                 }
             }
             void ChartAxis::setAxisOpacity(qreal opacity)
             {
                 m_axis->setOpacity(opacity);
             }
             qreal ChartAxis::axisOpacity() const
             {
                 return m_axis->opacity();
             }
             void ChartAxis::setGridOpacity(qreal opacity)
             {
                 m_grid->setOpacity(opacity);
             }
             qreal ChartAxis::gridOpacity() const
             {
                 return m_grid->opacity();
             }
             void ChartAxis::setLabelsOpacity(qreal opacity)
             {
                 m_labels->setOpacity(opacity);
             }
             qreal ChartAxis::labelsOpacity() const
             {
                 return m_labels->opacity();
             }
             void ChartAxis::setShadesOpacity(qreal opacity)
             {
                 m_shades->setOpacity(opacity);
             }
             qreal ChartAxis::shadesOpacity() const
             {
                 return m_shades->opacity();
             }
             void ChartAxis::setLabelsAngle(int angle)
             {
                 foreach(QGraphicsItem* item , m_labels->childItems()) {
                       item->setRotation(angle);
                 }
                 m_labelsAngle=angle;
             }
             void ChartAxis::setLabelsPen(const QPen &pen)
             {
                 foreach(QGraphicsItem* item , m_labels->childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setPen(pen);
                 }
             }
             void ChartAxis::setLabelsBrush(const QBrush &brush)
             {
                 foreach(QGraphicsItem* item , m_labels->childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setBrush(brush);
                 }
             }
             void ChartAxis::setLabelsFont(const QFont &font)
             {
                 foreach(QGraphicsItem* item , m_labels->childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setFont(font);
                 }
                 m_font = font;
             }
             void ChartAxis::setShadesBrush(const QBrush &brush)
             {
                 foreach(QGraphicsItem* item , m_shades->childItems()) {
                     static_cast<QGraphicsRectItem*>(item)->setBrush(brush);
                 }
             }
             void ChartAxis::setShadesPen(const QPen &pen)
             {
                 foreach(QGraphicsItem* item , m_shades->childItems()) {
                     static_cast<QGraphicsRectItem*>(item)->setPen(pen);
                 }
             }
             void ChartAxis::setAxisPen(const QPen &pen)
             {
                 foreach(QGraphicsItem* item , m_axis->childItems()) {
                        static_cast<QGraphicsLineItem*>(item)->setPen(pen);
                 }
             }
             void ChartAxis::setGridPen(const QPen &pen)
             {
                 foreach(QGraphicsItem* item , m_grid->childItems()) {
                     static_cast<QGraphicsLineItem*>(item)->setPen(pen);
                 }
             }
             bool ChartAxis::isEmpty()
             {
                 return m_rect.isEmpty() || qFuzzyIsNull(m_min - m_max) || m_ticksCount==0;
             }
             //handlers
             void ChartAxis::handleAxisCategoriesUpdated()
             {
                 if (isEmpty()) return;
             	updateLayout(m_layoutVector);
             }
             void ChartAxis::handleAxisUpdated()
             {
                 if (isEmpty()) return;
                 if (!m_chartAxis->isVisible()) {
                     setAxisOpacity(0);
                     setGridOpacity(0);
                     setLabelsOpacity(0);
                     setShadesOpacity(0);
                 }
                 else {
-                    if (m_chartAxis->isAxisVisible()) {
+                    if (m_chartAxis->isArrowVisible()) {
                         setAxisOpacity(100);
                     }
                     else {
                         setAxisOpacity(0);
                     }
                     if (m_chartAxis->isGridLineVisible()) {
                         setGridOpacity(100);
                     }
                     else {
                         setGridOpacity(0);
                     }
                     if (m_chartAxis->labelsVisible()) {
                         setLabelsOpacity(100);
                     }
                     else {
                         setLabelsOpacity(0);
                     }
                     if (m_chartAxis->shadesVisible()) {
                         setShadesOpacity(100);
                     }
                     else {
                         setShadesOpacity(0);
                     }
                 }
                 setLabelsAngle(m_chartAxis->labelsAngle());
                 setAxisPen(m_chartAxis->axisPen());
                 setLabelsPen(m_chartAxis->labelsPen());
                 setLabelsBrush(m_chartAxis->labelsBrush());
                 setLabelsFont(m_chartAxis->labelsFont());
                 setGridPen(m_chartAxis->gridLinePen());
                 setShadesPen(m_chartAxis->shadesPen());
                 setShadesBrush(m_chartAxis->shadesBrush());
             }
             void ChartAxis::handleRangeChanged(qreal min, qreal max,int tickCount)
             {
                 if (qFuzzyIsNull(min - max) || tickCount < 2)
                     return;
                 m_min = min;
                 m_max = max;
                 m_ticksCount= tickCount;
                 if (isEmpty()) return;
                 QVector<qreal> layout = calculateLayout();
                 updateLayout(layout);
             }
             void ChartAxis::handleGeometryChanged(const QRectF &rect)
             {
                 if(m_rect != rect)
                 {
                     m_rect = rect;
                     if (isEmpty()) return;
                     QVector<qreal> layout = calculateLayout();
                     updateLayout(layout);
                 }
             }
             qreal ChartAxis::minimumWidth()
             {
                 if(m_minWidth == 0) updateGeometry();
                 return m_minWidth;
             }
             qreal ChartAxis::minimumHeight()
             {
                 if(m_minHeight == 0) updateGeometry();
                 return m_minHeight;
             }
             void ChartAxis::axisSelected()
             {
                 qDebug()<<"TODO: axis clicked";
             }
             void ChartAxis::createNumberLabels(QStringList &labels,qreal min, qreal max, int ticks) const
             {
                 Q_ASSERT(max>min);
                 Q_ASSERT(ticks>1);
                 int n = qMax(int(-floor(log10((max-min)/(ticks-1)))),0);
                 n++;
                 for (int i=0; i< ticks; i++) {
                     qreal value = min + (i * (max - min)/ (ticks-1));
                     labels << QString::number(value,'f',n);
                 }
             }
             void ChartAxis::createCategoryLabels(QStringList &labels,qreal min, qreal max,const QStringList &categories) const
             {
                 Q_ASSERT(max>min);
                 Q_UNUSED(max);
                 int x = qCeil(min);
                 int count = 0;
                 // Try to find category for x coordinate
                 while (count < m_ticksCount) {
                     if ((x < categories.count()) && (x >= 0)) {
                         labels << categories.at(x);
                     } else {
                         // No label for x coordinate
                         labels << "";
                     }
                     x++;
                     count++;
                 }
             }
             #include "moc_chartaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/qabstractaxis.cpp +51 -30

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qabstractaxis.h"
             #include "qabstractaxis_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QAbstractAxis
                 \brief The QAbstractAxis class is used for manipulating chart's axis.
                 \mainclass
                 There is only one x Axis 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 AxisTypeValues
                 \value AxisTypeCategories
             */
             /*!
              *\fn void QAbstractAxis::type() const
               Returns the type of the axis
             */
             /*!
               \property QAbstractAxis::arrowVisible
               The visibility of the axis arrow
             */
             /*!
               \qmlproperty bool AbstractAxis::arrrowVisible
               The visibility of the axis arrow
             */
             /*!
               \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.
             */
             /*!
-              \fn void QAbstractAxis::visibleChanged(bool)
+              \fn void QAbstractAxis::visibleChanged(bool visible)
               Visiblity of the axis has changed to \a visible.
             */
             /*!
-              \fn void QAbstractAxis::labelsVisibleChanged(bool)
+              \qmlsignal AbstractAxis::onVisibleChanged(bool visible)
-              Visiblity of the labels of the axis has changed to \a visible.
+              Visiblity of the axis has changed to \a visible.
             */
             /*!
-              \fn void QAbstractAxis::gridVisibleChanged(bool)
+              \fn void QAbstractAxis::arrowVisibleChanged(bool visible)
-              Visiblity of the grid lines of the axis has changed to \a visible.
+              Visiblity of the axis arrow has changed to \a visible.
             */
+            /*!
-            /*
+              \qmlsignal AbstractAxis::onArrowVisibleChanged(bool visible)
-              \fn void QAbstractAxis::minChanged(qreal min)
+              Visiblity of the axis arrow has changed to \a visible.
-              Axis emits signal when \a min of axis has changed.
             */
-            /*
+            /*!
-              \fn void QAbstractAxis::maxChanged(qreal max)
+              \fn void QAbstractAxis::labelsVisibleChanged(bool visible)
-              Axis emits signal when \a max of axis has changed.
+              Visiblity of the labels of the axis has changed to \a visible.
             */
+            /*!
-            /*
+              \qmlsignal AbstractAxis::onLabelsVisibleChanged(bool visible)
-              \fn void QAbstractAxis::rangeChanged(qreal min, qreal max)
+              Visiblity of the labels of the axis has changed to \a visible.
-              Axis emits signal when \a min or \a max of axis has changed.
             */
-            /*
+            /*!
-              \fn QChartAxisCategories* QAbstractAxis::categories()
+              \fn void QAbstractAxis::gridVisibleChanged(bool visible)
-              Returns pointer to the list of categories which correspond to the values on the axis.
+              Visiblity of the grid lines of the axis has changed to \a visible.
+            */
+            /*!
+              \qmlsignal AbstractAxis::onGridVisibleChanged(bool visible)
+              Visiblity of the grid lines of the axis has changed to \a visible.
             */
             /*!
-              \fn void QAbstractAxis::colorChanged(QColor)
+              \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)
+              \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)
+              \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.
+            */
             /*!
               Constructs new axis object which is a child of \a parent. Ownership is taken by
               QChart when axis added.
             */
             QAbstractAxis::QAbstractAxis(QAbstractAxisPrivate &d, QObject *parent) :
             QObject(parent),
             d_ptr(&d)
             {
             }
             /*!
               Destructor of the axis object. When axis is added to chart, chart object takes ownership.
             */
             QAbstractAxis::~QAbstractAxis()
             {
             }
             /*!
               Sets \a pen used to draw axis line and ticks.
              */
             void QAbstractAxis::setAxisPen(const QPen &pen)
             {
             	if (d_ptr->m_axisPen!=pen) {
             	    d_ptr->m_axisPen = pen;
                     emit d_ptr->updated();
             	}
             }
             /*!
               Returns pen used to draw axis and ticks.
             */
             QPen QAbstractAxis::axisPen() const
             {
                 return d_ptr->m_axisPen;
             }
             void QAbstractAxis::setAxisPenColor(QColor color)
             {
                 QPen p = d_ptr->m_axisPen;
                 if (p.color() != color) {
                     p.setColor(color);
                     setAxisPen(p);
                     emit colorChanged(color);
                 }
             }
             QColor QAbstractAxis::axisPenColor() const
             {
                 return d_ptr->m_axisPen.color();
             }
             /*!
               Sets if axis and ticks are \a visible.
              */
-            void QAbstractAxis::setAxisVisible(bool visible)
+            void QAbstractAxis::setArrowVisible(bool visible)
             {
-                if (d_ptr->m_axisVisible != visible) {
+                if (d_ptr->m_arrowVisible != visible) {
-                    d_ptr->m_axisVisible = visible;
+                    d_ptr->m_arrowVisible = visible;
                     emit d_ptr->updated();
-                    emit visibleChanged(visible);
+                    emit arrowVisibleChanged(visible);
             	}
             }
-            bool QAbstractAxis::isAxisVisible() const
+            bool QAbstractAxis::isArrowVisible() const
             {
-                return d_ptr->m_axisVisible;
+                return d_ptr->m_arrowVisible;
             }
             void QAbstractAxis::setGridLineVisible(bool visible)
             {
                 if (d_ptr->m_gridLineVisible != visible) {
                     d_ptr->m_gridLineVisible = visible;
                     emit d_ptr->updated();
                     emit gridVisibleChanged(visible);
             	}
             }
             bool QAbstractAxis::isGridLineVisible() const
             {
                 return d_ptr->m_gridLineVisible;
             }
             /*!
               Sets \a pen used to draw grid line.
             */
             void QAbstractAxis::setGridLinePen(const QPen &pen)
             {
                 if (d_ptr->m_gridLinePen != pen) {
                     d_ptr->m_gridLinePen = pen;
                     emit d_ptr->updated();
             	}
             }
             /*!
               Returns pen used to draw grid.
             */
             QPen QAbstractAxis::gridLinePen() const
             {
                 return d_ptr->m_gridLinePen;
             }
             void QAbstractAxis::setLabelsVisible(bool visible)
             {
                 if (d_ptr->m_labelsVisible != visible) {
                     d_ptr->m_labelsVisible = visible;
                     emit d_ptr->updated();
                     emit labelsVisibleChanged(visible);
             	}
             }
             bool QAbstractAxis::labelsVisible() const
             {
                 return d_ptr->m_labelsVisible;
             }
             /*!
               Sets \a pen used to draw labels.
             */
             void QAbstractAxis::setLabelsPen(const QPen &pen)
             {
                 if (d_ptr->m_labelsPen != pen) {
                     d_ptr->m_labelsPen = pen;
                     emit d_ptr->updated();
             	}
             }
             /*!
               Returns the pen used to labels.
             */
             QPen QAbstractAxis::labelsPen() const
             {
                 return d_ptr->m_labelsPen;
             }
             /*!
               Sets \a brush used to draw labels.
              */
             void QAbstractAxis::setLabelsBrush(const QBrush &brush)
             {
                 if (d_ptr->m_labelsBrush != brush) {
                     d_ptr->m_labelsBrush = brush;
                     emit d_ptr->updated();
             	}
             }
             /*!
               Returns brush used to draw labels.
             */
             QBrush  QAbstractAxis::labelsBrush() const
             {
                 return d_ptr->m_labelsBrush;
             }
             /*!
               Sets \a font used to draw labels.
             */
             void QAbstractAxis::setLabelsFont(const QFont &font)
             {
                 if (d_ptr->m_labelsFont != font) {
                     d_ptr->m_labelsFont = font;
                     emit d_ptr->updated();
             	}
             }
             /*!
               Returns font used to draw labels.
             */
             QFont QAbstractAxis::labelsFont() const
             {
                 return d_ptr->m_labelsFont;
             }
             void QAbstractAxis::setLabelsAngle(int angle)
             {
                 if (d_ptr->m_labelsAngle != angle) {
                     d_ptr->m_labelsAngle = angle;
                     emit d_ptr->updated();
             	}
             }
             int QAbstractAxis::labelsAngle() const
             {
                 return d_ptr->m_labelsAngle;
             }
             void QAbstractAxis::setLabelsColor(QColor color)
             {
                 QBrush b = d_ptr->m_labelsBrush;
                 if (b.color() != color) {
                     b.setColor(color);
                     setLabelsBrush(b);
                     emit labelsColorChanged(color);
                 }
             }
             QColor QAbstractAxis::labelsColor() const
             {
                 return d_ptr->m_labelsBrush.color();
             }
             void QAbstractAxis::setShadesVisible(bool visible)
             {
                 if (d_ptr->m_shadesVisible != visible) {
                     d_ptr->m_shadesVisible = visible;
                     emit d_ptr->updated();
                     emit shadesVisibleChanged(visible);
             	}
             }
             bool QAbstractAxis::shadesVisible() const
             {
                 return d_ptr->m_shadesVisible;
             }
             /*!
               Sets \a pen used to draw shades.
             */
             void QAbstractAxis::setShadesPen(const QPen &pen)
             {
                 if (d_ptr->m_shadesPen != pen) {
                     d_ptr->m_shadesPen = pen;
                     emit d_ptr->updated();
             	}
             }
             /*!
               Returns pen used to draw shades.
             */
             QPen QAbstractAxis::shadesPen() const
             {
                 return d_ptr->m_shadesPen;
             }
             /*!
               Sets \a brush used to draw shades.
             */
             void QAbstractAxis::setShadesBrush(const QBrush &brush)
             {
                 if (d_ptr->m_shadesBrush != brush) {
                     d_ptr->m_shadesBrush = brush;
                     emit d_ptr->updated();
                     emit shadesColorChanged(brush.color());
                 }
             }
             /*!
                Returns brush used to draw shades.
             */
             QBrush QAbstractAxis::shadesBrush() const
             {
                 return d_ptr->m_shadesBrush;
             }
             void QAbstractAxis::setShadesColor(QColor color)
             {
                 QBrush b = d_ptr->m_shadesBrush;
                 b.setColor(color);
                 setShadesBrush(b);
             }
             QColor QAbstractAxis::shadesColor() const
             {
                 return d_ptr->m_shadesBrush.color();
             }
             void QAbstractAxis::setShadesBorderColor(QColor color)
             {
                 QPen p = d_ptr->m_shadesPen;
                 p.setColor(color);
                 setShadesPen(p);
             }
             QColor QAbstractAxis::shadesBorderColor() const
             {
                 return d_ptr->m_shadesPen.color();
             }
             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);
                     emit d_ptr->updated();
                 }
             }
             /*!
               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 paramter 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 paramter 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 paramters 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);
             }
             /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QAbstractAxisPrivate::QAbstractAxisPrivate(QAbstractAxis* q):
                 q_ptr(q),
                 m_visible(false),
-                m_axisVisible(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_orientation(Qt::Orientation(0)),
                 m_min(0),
                 m_max(0),
                 m_ticksCount(5)
             {
             }
             QAbstractAxisPrivate::~QAbstractAxisPrivate()
             {
             }
             #include "moc_qabstractaxis.cpp"
             #include "moc_qabstractaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/qabstractaxis.h +4 -4

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef QABSTRACTAXIS_H
             #define QABSTRACTAXIS_H
             #include <qchartglobal.h>
             #include <QPen>
             #include <QFont>
             #include <QVariant>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QAbstractAxisPrivate;
             class QTCOMMERCIALCHART_EXPORT QAbstractAxis : public QObject
             {
             	Q_OBJECT
             	Q_PROPERTY(bool visible READ isVisible WRITE setVisible NOTIFY visibleChanged)
-                Q_PROPERTY(bool axisVisible READ isAxisVisible WRITE setAxisVisible NOTIFY visibleChanged)
+                Q_PROPERTY(bool arrowVisible READ isArrowVisible WRITE setArrowVisible NOTIFY arrowVisibleChanged)
                 Q_PROPERTY(QColor color READ axisPenColor WRITE setAxisPenColor NOTIFY colorChanged)
                 Q_PROPERTY(bool labelsVisible READ labelsVisible WRITE setLabelsVisible NOTIFY labelsVisibleChanged)
                 Q_PROPERTY(int labelsAngle READ labelsAngle WRITE setLabelsAngle)
                 Q_PROPERTY(QFont labelsFont READ labelsFont WRITE setLabelsFont)
                 Q_PROPERTY(QColor labelsColor READ labelsColor WRITE setLabelsColor NOTIFY labelsColorChanged)
                 Q_PROPERTY(bool gridVisible READ isGridLineVisible WRITE setGridLineVisible NOTIFY gridVisibleChanged)
                 Q_PROPERTY(bool shadesVisible READ shadesVisible WRITE setShadesVisible NOTIFY shadesVisibleChanged)
                 Q_PROPERTY(QColor shadesColor READ shadesColor WRITE setShadesColor NOTIFY shadesColorChanged)
                 Q_PROPERTY(QColor shadesBorderColor READ shadesBorderColor WRITE setShadesBorderColor NOTIFY shadesBorderColorChanged)
             public:
                 enum AxisType {
                     AxisTypeNoAxis = 0x0,
                     AxisTypeValues = 0x1,
                     AxisTypeCategories = 0x2
                 };
                 Q_DECLARE_FLAGS(AxisTypes, AxisType)
             protected:
                 explicit QAbstractAxis(QAbstractAxisPrivate &d,QObject *parent = 0);
             public:
                 ~QAbstractAxis();
                 virtual AxisType type() const = 0;
                 //visibilty hadnling
                 bool isVisible() const;
                 void setVisible(bool visible = true);
                 //axis handling
-                bool isAxisVisible() const;
+                bool isArrowVisible() const;
-                void setAxisVisible(bool visible = true);
+                void setArrowVisible(bool visible = true);
                 void setAxisPen(const QPen &pen);
                 QPen axisPen() const;
                 void setAxisPenColor(QColor color);
                 QColor axisPenColor() const;
                 //grid handling
                 bool isGridLineVisible() const;
                 void setGridLineVisible(bool visible = true);
                 void setGridLinePen(const QPen &pen);
                 QPen gridLinePen() const;
                 //labels handling
                 bool labelsVisible() const;
                 void setLabelsVisible(bool visible = true);
                 void setLabelsPen(const QPen &pen);
                 QPen labelsPen() const;
                 void setLabelsBrush(const QBrush &brush);
                 QBrush labelsBrush() const;
                 void setLabelsFont(const QFont &font);
                 QFont labelsFont() const;
                 void setLabelsAngle(int angle);
                 int labelsAngle() const;
                 void setLabelsColor(QColor color);
                 QColor labelsColor() const;
                 //shades handling
                 bool shadesVisible() const;
                 void setShadesVisible(bool visible = true);
                 void setShadesPen(const QPen &pen);
                 QPen shadesPen() const;
                 void setShadesBrush(const QBrush &brush);
                 QBrush shadesBrush() const;
                 void setShadesColor(QColor color);
                 QColor shadesColor() const;
                 void setShadesBorderColor(QColor color);
                 QColor shadesBorderColor() const;
                 //range handling
                 void setMin(const QVariant &min);
                 void setMax(const QVariant &max);
                 void setRange(const QVariant &min, const QVariant &max);
                 void show();
                 void hide();
             Q_SIGNALS:
                 void visibleChanged(bool visible);
-                void axisVisibleChanged(bool visible);
+                void arrowVisibleChanged(bool visible);
                 void labelsVisibleChanged(bool visible);
                 void gridVisibleChanged(bool visible);
                 void colorChanged(QColor color);
                 void labelsColorChanged(QColor color);
                 void shadesVisibleChanged(bool visible);
                 void shadesColorChanged(QColor color);
                 void shadesBorderColorChanged(QColor color);
             protected:
             	QScopedPointer<QAbstractAxisPrivate> d_ptr;
                 Q_DISABLE_COPY(QAbstractAxis);
                 friend class ChartDataSet;
                 friend class ChartAxis;
                 friend class ChartPresenter;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/axis/qabstractaxis_p.h +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef QABSTRACTAXIS_P_H
             #define QABSTRACTAXIS_P_H
             #include "qabstractaxis.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartPresenter;
             class ChartAxis;
             class QAbstractAxisPrivate : public QObject
             {
                 Q_OBJECT
             public:
                 QAbstractAxisPrivate(QAbstractAxis *q);
                 ~QAbstractAxisPrivate();
             Q_SIGNALS:
                 void updated();
             public:
                 virtual ChartAxis* createGraphics(ChartPresenter* presenter) = 0;
                 virtual void emitRange() = 0;
             protected:
                 virtual void setMin(const QVariant &min) = 0;
                 virtual void setMax(const QVariant &max) = 0;
                 virtual void setRange(const QVariant &min, const QVariant &max) = 0;
                 virtual int ticksCount() const = 0;
             public:
                 QAbstractAxis *q_ptr;
                 bool m_visible;
-                bool m_axisVisible;
+                bool m_arrowVisible;
                 QPen m_axisPen;
                 QBrush m_axisBrush;
                 bool m_gridLineVisible;
                 QPen m_gridLinePen;
                 bool m_labelsVisible;
                 QPen m_labelsPen;
                 QBrush m_labelsBrush;
                 QFont m_labelsFont;
                 int m_labelsAngle;
                 bool m_shadesVisible;
                 QPen m_shadesPen;
                 QBrush m_shadesBrush;
                 qreal m_shadesOpacity;
                 Qt::Orientation m_orientation;
                 // range
                 qreal m_min;
                 qreal m_max;
                 int m_ticksCount;
                 friend class QAbstractAxis;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/axis/qbarcategoriesaxis.cpp +10 -2

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qbarcategoriesaxis.h"
             #include "qbarcategoriesaxis_p.h"
             #include "chartcategoriesaxisx_p.h"
             #include "chartcategoriesaxisy_p.h"
             #include <qmath.h>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QBarCategoriesAxis
                 \brief The QBarCategoriesAxis class is used for manipulating chart's axis.
                 \mainclass
                 BarCategoriesAxis can be setup to show axis line with tick marks, grid lines and shades.
                 Categories are drawn between ticks. Note that you can use this also with lineseries too.
                 See the \l {Line and BarChart Example} {Line and BarChart Example} to learn how to do that.
             */
             /*!
                 \qmlclass BarCategoriesAxis QBarCategoriesAxis
                 \brief The Axis element is used for manipulating chart's axes.
                 Axis can be setup to show axis line with tick marks, grid lines and shades.
                 Categories are drawn between ticks. Note that you can use this also with lineseries too.
                 To access BarCategoriesAxis you can use ChartView API. For example:
                 \code
                     ChartView {
                         BarCategoriesAxis {
                             id: categoryAxis
                             categories: ["Jan", "Feb", "Mar", "Apr", "May", "Jun" ]
                         }
                     // Add a few series...
                     }
                 \endcode
             */
             /*!
               \property QBarCategoriesAxis::categories
               Defines the categories of axis
             */
             /*!
               \qmlproperty QStringList BarCategoriesAxis::categories
               Defines the categories of axis
             */
             /*!
               \property QBarCategoriesAxis::min
               Defines the minimum value on the axis.
             */
             /*!
-              \qmlproperty real BarCategoriesAxis::min
+              \qmlproperty QString BarCategoriesAxis::min
               Defines the minimum value on the axis.
             */
             /*!
               \property QBarCategoriesAxis::max
               Defines the maximum value on the axis.
             */
             /*!
-              \qmlproperty real BarCategoriesAxis::max
+              \qmlproperty QString BarCategoriesAxis::max
               Defines the maximum value on the axis.
             */
             /*!
               \fn void QBarCategoriesAxis::minChanged(const QString &min)
               Axis emits signal when \a min of axis has changed.
             */
+            /*!
+              \qmlsignal BarCategoriesAxis::onMinChanged(const QString &min)
+              Axis emits signal when \a min of axis has changed.
+            */
             /*!
               \fn void QBarCategoriesAxis::maxChanged(const QString &max)
               Axis emits signal when \a max of axis has changed.
             */
+            /*!
+              \qmlsignal BarCategoriesAxis::onMaxChanged(const QString &max)
+              Axis emits signal when \a max of axis has changed.
+            */
             /*!
               \fn void QBarCategoriesAxis::rangeChanged(const QString &min, const QString &max)
               Axis emits signal when \a min or \a max of axis has changed.
             */
             /*!
                 Constructs an axis object which is a child of \a parent.
             */
             QBarCategoriesAxis::QBarCategoriesAxis(QObject *parent):
                 QAbstractAxis(*new QBarCategoriesAxisPrivate(this),parent)
             {
             }
             /*!
                 Destroys the object
             */
             QBarCategoriesAxis::~QBarCategoriesAxis()
             {
             }
             /*!
                 \internal
             */
             QBarCategoriesAxis::QBarCategoriesAxis(QBarCategoriesAxisPrivate &d,QObject *parent):QAbstractAxis(d,parent)
             {
             }
             /*!
                 Appends \a categories to axis
             */
             void QBarCategoriesAxis::append(const QStringList &categories)
             {
                 if(categories.isEmpty()) return;
                 Q_D(QBarCategoriesAxis);
                 if (d->m_categories.isEmpty()) {
                 	d->m_categories.append(categories);
                 	setRange(categories.first(),categories.last());
                 }else{
                 	d->m_categories.append(categories);
                 }
                 emit d->updated();
                 emit categoriesChanged();
             }
             /*!
                 Appends \a category to axis
             */
             void QBarCategoriesAxis::append(const QString &category)
             {
             	Q_D(QBarCategoriesAxis);
             	if (d->m_categories.isEmpty()) {
             		d->m_categories.append(category);
             		setRange(category,category);
             	}else{
             		d->m_categories.append(category);
             	}
             	emit d->updated();
             	emit categoriesChanged();
             }
             /*!
                 Removes \a category from axis
             */
             void QBarCategoriesAxis::remove(const QString &category)
             {
                 Q_D(QBarCategoriesAxis);
                 if (d->m_categories.contains(category)) {
                     d->m_categories.removeAt(d->m_categories.indexOf(category));
                     setRange(d->m_categories.first(),d->m_categories.last());
                     emit d->updated();
                     emit categoriesChanged();
                 }
             }
             /*!
                 Inserts \a category to axis at \a index
             */
             void QBarCategoriesAxis::insert(int index, const QString &category)
             {
                 Q_D(QBarCategoriesAxis);
                 if (d->m_categories.isEmpty()) {
                 	d->m_categories.insert(index,category);
                 	setRange(category,category);
                 }else{
                     d->m_categories.insert(index,category);
                 }
                 emit d->updated();
                 emit categoriesChanged();
             }
             /*!
               Removes all categories.
              */
             void QBarCategoriesAxis::clear()
             {
                 Q_D(QBarCategoriesAxis);
                 d->m_categories.clear();
                 setRange(QString::null,QString::null);
                 emit d->updated();
                 emit categoriesChanged();
             }
             void QBarCategoriesAxis::setCategories(const QStringList &categories)
             {
                 Q_D(QBarCategoriesAxis);
                 if(d->m_categories!=categories){
                 d->m_categories = categories;
                 setRange(categories.first(),categories.last());
                 emit d->updated();
                 emit categoriesChanged();
                 }
             }
             QStringList QBarCategoriesAxis::categories()
             {
                 Q_D(QBarCategoriesAxis);
                 return d->m_categories;
             }
             /*!
               Returns number of categories.
              */
             int QBarCategoriesAxis::count() const
             {
                 Q_D(const QBarCategoriesAxis);
                 return d->m_categories.count();
             }
             /*!
                 Returns category at \a index. Index must be valid.
             */
             QString QBarCategoriesAxis::at(int index) const
             {
                 Q_D(const QBarCategoriesAxis);
                 return d->m_categories.at(index);
             }
             /*!
                 Sets minimum category to \a min.
             */
             void QBarCategoriesAxis::setMin(const QString& min)
             {
                 Q_D(QBarCategoriesAxis);
                 setRange(min,d->m_maxCategory);
             }
             /*!
                 Returns minimum category.
             */
             QString QBarCategoriesAxis::min() const
             {
                 Q_D(const QBarCategoriesAxis);
                 return d->m_minCategory;
             }
             /*!
                 Sets maximum category to \a max.
             */
             void QBarCategoriesAxis::setMax(const QString& max)
             {
                 Q_D(QBarCategoriesAxis);
                 setRange(d->m_minCategory,max);
             }
             /*!
                 Returns maximum category
             */
             QString QBarCategoriesAxis::max() const
             {
                 Q_D(const QBarCategoriesAxis);
                 return d->m_maxCategory;
             }
             /*!
                 Sets range from \a minCategory to \a maxCategory
             */
             void QBarCategoriesAxis::setRange(const QString& minCategory, const QString& maxCategory)
             {
                 Q_D(QBarCategoriesAxis);
                 int minIndex = d->m_categories.indexOf(minCategory);
                 if (minIndex == -1) {
                     return;
                 }
                 int maxIndex = d->m_categories.indexOf(maxCategory);
                 if (maxIndex == -1) {
                     return;
                 }
                 if (maxIndex <= minIndex) {
                     // max must be greater than min
                     return;
                 }
                 bool changed = false;
                 if (!qFuzzyIsNull(d->m_min - (minIndex))||d->m_minCategory!=minCategory) {
                 	d->m_minCategory = minCategory;
                     d->m_min = minIndex;
                     emit minChanged(minCategory);
                     changed = true;
                 }
                 if (!qFuzzyIsNull(d->m_max - (maxIndex))||d->m_maxCategory!=maxCategory ) {
                     d->m_max = maxIndex;
                     d->m_maxCategory = maxCategory;
                     emit maxChanged(maxCategory);
                     changed = true;
                 }
                 if (changed) {
                     d->emitRange();
                 }
             }
             /*!
               Returns the type of the axis
             */
             QAbstractAxis::AxisType QBarCategoriesAxis::type() const
             {
                 return AxisTypeCategories;
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QBarCategoriesAxisPrivate::QBarCategoriesAxisPrivate(QBarCategoriesAxis* q):
                 QAbstractAxisPrivate(q)
             {
             }
             QBarCategoriesAxisPrivate::~QBarCategoriesAxisPrivate()
             {
             }
             void QBarCategoriesAxisPrivate::setMin(const QVariant &min)
             {
                 setRange(min,m_maxCategory);
             }
             void QBarCategoriesAxisPrivate::setMax(const QVariant &max)
             {
                 setRange(m_minCategory,max);
             }
             void QBarCategoriesAxisPrivate::setRange(const QVariant &min, const QVariant &max)
             {
                 Q_Q(QBarCategoriesAxis);
                 QString value1 = min.toString();
                 QString value2 = max.toString();
                 q->setRange(value1,value2);
             }
             int QBarCategoriesAxisPrivate::ticksCount() const
             {
                 return m_categories.count()+1;
             }
             void QBarCategoriesAxisPrivate::handleAxisRangeChanged(qreal min, qreal max,int count)
             {
                 m_min = min;
                 m_max = max;
                 m_ticksCount = count;
             }
             ChartAxis* QBarCategoriesAxisPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q( QBarCategoriesAxis);
                 if(m_orientation == Qt::Vertical){
                     return new ChartCategoriesAxisY(q,presenter);
                 }else{
                     return new ChartCategoriesAxisX(q,presenter);
                 }
             }
             void QBarCategoriesAxisPrivate::emitRange()
             {
             	emit changed(m_min -0.5, m_max +0.5, qCeil(m_max + 0.5) -qCeil(m_min - 0.5) +1, false);
             }
             #include "moc_qbarcategoriesaxis.cpp"
             #include "moc_qbarcategoriesaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/qintervalaxis.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qintervalaxis.h"
             #include "qintervalaxis_p.h"
             #include "chartcategoriesaxisx_p.h"
             #include "chartcategoriesaxisy_p.h"
             #include <qmath.h>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \internal
                 \class QIntervalAxis
                 \brief The QIntervalAxis class is used for manipulating chart's axis.
                 \mainclass
                 Axis can be setup to show axis line with tick marks, grid lines and shades.
             */
             /*!
                 \qmlclass Axis QIntervalAxis
                 \brief The Axis element is used for manipulating chart's axes.
                 Axis can be setup to show axis line with tick marks, grid lines and shades.
                 To access Axes you can use ChartView API. For example:
                 \code
                 // TODO :)
                 \endcode
             */
             /*!
                 Constructs an axis object which is a child of \a parent.
             */
             QIntervalAxis::QIntervalAxis(QObject *parent):
                 QValuesAxis(*new QIntervalAxisPrivate(this),parent)
             {
             }
             /*!
                 Destroys the object
             */
             QIntervalAxis::~QIntervalAxis()
             {
             }
             /*!
                 \internal
             */
             QIntervalAxis::QIntervalAxis(QIntervalAxisPrivate &d,QObject *parent):QValuesAxis(d,parent)
             {
             }
             /*!
-                Appends \a categories to axis
+                Appends \a category to axis
             */
             void QIntervalAxis::append(const QString& category, qreal x)
             {
                 Q_D(QIntervalAxis);
                 if (!d->m_categories.contains(category))
                 {
                 	if(d->m_categories.isEmpty()){
                 		Range range(d->m_categoryMinimum,x);
                 		d->m_categoriesMap.insert(category,range);
                 		d->m_categories.append(category);
                 	}else{
                 		Range range = d->m_categoriesMap.value(d->m_categories.last());
                 		d->m_categoriesMap.insert(category,Range(range.first,x));
                 		d->m_categories.append(category);
                 	}
                 	setRange(d->m_min,x);
                 }
             }
             void QIntervalAxis::setFisrtCategoryMinimum(qreal x)
             {
             	 Q_D(QIntervalAxis);
             	 if(d->m_categories.isEmpty()){
             		 d->m_categoryMinimum=x;
             	 }else{
             		 Range range = d->m_categoriesMap.value(d->m_categories.first());
             		 d->m_categoriesMap.insert(d->m_categories.first(),Range(x,range.second));
             		 setRange(x,d->m_min);
             	 }
             }
             /*!
                 Removes \a category from axis
             */
             void QIntervalAxis::remove(const QString &category)
             {
             	Q_UNUSED(category);
             	//TODO
             }
             QStringList QIntervalAxis::categories()
             {
                 Q_D(QIntervalAxis);
                 return d->m_categories;
             }
             /*!
               Returns number of categories.
              */
             int QIntervalAxis::count() const
             {
                 Q_D(const QIntervalAxis);
                 return d->m_categories.count();
             }
             /*!
               Returns the type of the axis
             */
             QAbstractAxis::AxisType QIntervalAxis::type() const
             {
                 return AxisTypeCategories;
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QIntervalAxisPrivate::QIntervalAxisPrivate(QIntervalAxis* q):
                 QValuesAxisPrivate(q),
                 m_categoryMinimum(0)
             {
             }
             QIntervalAxisPrivate::~QIntervalAxisPrivate()
             {
             }
             int QIntervalAxisPrivate::ticksCount() const
             {
                 return m_categories.count()+1;
             }
             void QIntervalAxisPrivate::handleAxisRangeChanged(qreal min, qreal max,int count)
             {
                 m_min = min;
                 m_max = max;
                 m_ticksCount = count;
             }
             ChartAxis* QIntervalAxisPrivate::createGraphics(ChartPresenter* presenter)
             {
             	Q_UNUSED(presenter);
                // Q_Q( QCategoriesAxis);
                 if(m_orientation == Qt::Vertical){
                     return 0;
                 }else{
                     return 0;
                 }
             }
             #include "moc_qintervalaxis.cpp"
             #include "moc_qintervalaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/qvaluesaxis.cpp +8 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 "qvaluesaxis.h"
             #include "qvaluesaxis_p.h"
             #include "chartvaluesaxisx_p.h"
             #include "chartvaluesaxisy_p.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QValuesAxis
                 \brief The QValuesAxis class is used for manipulating chart's axis.
                 \mainclass
                 ValuesAxis can be setup to show axis line with tick marks, grid lines and shades.
                 Values of axis are drawn to position of ticks
             */
             /*!
                 \qmlclass ValuesAxis QValuesAxis
                 \brief The ValuesAxis element is used for manipulating chart's axes
                 ValueAxis can be setup to show axis line with tick marks, grid lines and shades.
                 Values of axis are drawn to position of ticks
                 To access Axes you can use ChartView API. For example:
                 \code
                     ChartView {
                         ValuesAxis {
                             id: xAxis
                             min: 0
                             max: 10
                         }
                     // Add a few series...
                     }
                 \endcode
             */
             /*!
               \property QValuesAxis::min
               Defines the minimum value on the axis.
             */
             /*!
               \qmlproperty real ValuesAxis::min
               Defines the minimum value on the axis.
             */
             /*!
               \property QValuesAxis::max
               Defines the maximum value on the axis.
             */
             /*!
               \qmlproperty real ValuesAxis::max
               Defines the maximum value on the axis.
             */
             /*!
               \fn void QValuesAxis::minChanged(qreal min)
               Axis emits signal when \a min of axis has changed.
             */
+            /*!
+              \qmlsignal ValuesAxis::onMinChanged(real min)
+              Axis emits signal when \a min of axis has changed.
+            */
             /*!
               \fn void QValuesAxis::maxChanged(qreal max)
               Axis emits signal when \a max of axis has changed.
             */
+            /*!
+              \qmlsignal ValuesAxis::onMaxChanged(real max)
+              Axis emits signal when \a max of axis has changed.
+            */
             /*!
               \fn void QValuesAxis::rangeChanged(qreal min, qreal max)
               Axis emits signal when \a min or \a max of axis has changed.
             */
             /*!
               \property QValuesAxis::ticksCount
               The number of tick marks for the axis.
             */
             /*!
               \qmlproperty int ValuesAxis::ticksCount
               The number of tick marks for the axis.
             */
             /*!
               \property QValuesAxis::niceNumbersEnabled
               Whether the nice numbers algorithm is enabled or not for the axis.
             */
             /*!
               \qmlproperty bool ValuesAxis::niceNumbersEnabled
               Whether the nice numbers algorithm is enabled or not for the axis.
             */
             /*!
                 Constructs an axis object which is a child of \a parent.
             */
             QValuesAxis::QValuesAxis(QObject *parent) :
                 QAbstractAxis(*new QValuesAxisPrivate(this),parent)
             {
             }
             /*!
                 \internal
             */
             QValuesAxis::QValuesAxis(QValuesAxisPrivate &d,QObject *parent) : QAbstractAxis(d,parent)
             {
             }
             /*!
                 Destroys the object
             */
             QValuesAxis::~QValuesAxis()
             {
             }
             void QValuesAxis::setMin(qreal min)
             {
                 Q_D(QValuesAxis);
                 setRange(min,d->m_max);
             }
             qreal QValuesAxis::min() const
             {
                 Q_D(const QValuesAxis);
                 return d->m_min;
             }
             void QValuesAxis::setMax(qreal max)
             {
                 Q_D(QValuesAxis);
                 setRange(d->m_min,max);
             }
             qreal QValuesAxis::max() const
             {
                 Q_D(const QValuesAxis);
                 return d->m_max;
             }
             /*!
               Sets range from \a min to \a max on the axis.
             */
             void QValuesAxis::setRange(qreal min, qreal max)
             {
                 Q_D(QValuesAxis);
                 bool changed = false;
                 if (!qFuzzyIsNull(d->m_min - min)) {
                     d->m_min = min;
                     changed = true;
                     emit minChanged(min);
                 }
                 if (!qFuzzyIsNull(d->m_max - max)) {
                     d->m_max = max;
                     changed = true;
                     emit maxChanged(max);
                 }
                 if (changed) {
                 	d->emitRange();
                     emit rangeChanged(d->m_min,d->m_max);
                 }
             }
             /*!
               Sets \a count for ticks on the axis.
             */
             void QValuesAxis::setTicksCount(int count)
             {
                 Q_D(QValuesAxis);
                 if (d->m_ticksCount != count) {
                     d->m_ticksCount = count;
                     emit d->changed(d->m_min, d->m_max, d->m_ticksCount, d->m_niceNumbers);
                 }
             }
             /*!
               \fn int QValuesAxis::ticksCount() const
               Return number of ticks on the axis
             */
             int QValuesAxis::ticksCount() const
             {
                 Q_D(const QValuesAxis);
                 return d->m_ticksCount;
             }
             void QValuesAxis::setNiceNumbersEnabled(bool enable)
             {
                 Q_D(QValuesAxis);
                 if (d->m_niceNumbers != enable){
                     d->m_niceNumbers = enable;
                     emit d->changed(d->m_min, d->m_max, d->m_ticksCount, d->m_niceNumbers);
                 }
             }
             bool  QValuesAxis::niceNumbersEnabled() const
             {
                 Q_D(const QValuesAxis);
                 return d->m_niceNumbers;
             }
             /*!
               Returns the type of the axis
             */
             QAbstractAxis::AxisType QValuesAxis::type() const
             {
                 return AxisTypeValues;
             }
             /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QValuesAxisPrivate::QValuesAxisPrivate(QValuesAxis* q):
                 QAbstractAxisPrivate(q),
                 m_niceNumbers(false)
             {
             }
             QValuesAxisPrivate::~QValuesAxisPrivate()
             {
             }
             void QValuesAxisPrivate::handleAxisRangeChanged(qreal min, qreal max,int count)
             {
                Q_Q(QValuesAxis);
                q->setRange(min,max);
                q->setTicksCount(count);
             }
             void QValuesAxisPrivate::setMin(const QVariant &min)
             {
                 Q_Q(QValuesAxis);
                 bool ok;
                 qreal value = min.toReal(&ok);
                 if(ok) q->setMin(value);
             }
             void QValuesAxisPrivate::setMax(const QVariant &max)
             {
                 Q_Q(QValuesAxis);
                 bool ok;
                 qreal value = max.toReal(&ok);
                 if(ok) q->setMax(value);
             }
             void QValuesAxisPrivate::setRange(const QVariant &min, const QVariant &max)
             {
                 Q_Q(QValuesAxis);
                 bool ok1;
                 bool ok2;
                 qreal value1 = min.toReal(&ok1);
                 qreal value2 = max.toReal(&ok2);
                 if(ok1&&ok2) q->setRange(value1,value2);
             }
             int QValuesAxisPrivate::ticksCount() const
             {
                 return m_ticksCount;
             }
             ChartAxis* QValuesAxisPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QValuesAxis);
                 if(m_orientation == Qt::Vertical){
                     return new ChartValuesAxisY(q,presenter);
                 }else{
                     return new ChartValuesAxisX(q,presenter);
                 }
             }
             void QValuesAxisPrivate::emitRange()
             {
             	emit changed(m_min, m_max, m_ticksCount, m_niceNumbers);
             }
             #include "moc_qvaluesaxis.cpp"
             #include "moc_qvaluesaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/charttheme.cpp +1 -1

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "charttheme_p.h"
             #include "qchart.h"
             #include "qchart_p.h"
             #include "qchartview.h"
             #include "qlegend.h"
             #include "qabstractaxis.h"
             #include <QTime>
             //series
             #include "qbarset.h"
             #include "qabstractbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qlineseries.h"
             #include "qareaseries.h"
             #include "qscatterseries.h"
             #include "qpieseries.h"
             #include "qpieslice.h"
             #include "qpieslice_p.h"
             #include "qsplineseries.h"
             //items
             #include "chartaxis_p.h"
             #include "barchartitem_p.h"
             #include "stackedbarchartitem_p.h"
             #include "percentbarchartitem_p.h"
             #include "linechartitem_p.h"
             #include "areachartitem_p.h"
             #include "scatterchartitem_p.h"
             #include "piechartitem_p.h"
             #include "splinechartitem_p.h"
             //themes
             #include "chartthemesystem_p.h"
             #include "chartthemelight_p.h"
             #include "chartthemebluecerulean_p.h"
             #include "chartthemedark_p.h"
             #include "chartthemebrownsand_p.h"
             #include "chartthemebluencs_p.h"
             #include "chartthemehighcontrast_p.h"
             #include "chartthemeblueicy_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartTheme::ChartTheme(QChart::ChartTheme id) :
                 m_masterFont(QFont("arial", 14)),
                 m_labelFont(QFont("arial", 10)),
                 m_labelBrush(QColor(QRgb(0x000000))),
                 m_axisLinePen(QPen(QRgb(0x000000))),
                 m_backgroundShadesPen(Qt::NoPen),
                 m_backgroundShadesBrush(Qt::NoBrush),
                 m_backgroundShades(BackgroundShadesNone),
                 m_backgroundDropShadowEnabled(false),
                 m_gridLinePen(QPen(QRgb(0x000000))),
                 m_force(false)
             {
                 m_id = id;
                 qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));
             }
             ChartTheme* ChartTheme::createTheme(QChart::ChartTheme theme)
             {
                 switch(theme) {
                     case QChart::ChartThemeLight:
                         return new ChartThemeLight();
                     case QChart::ChartThemeBlueCerulean:
                         return new ChartThemeBlueCerulean();
                     case QChart::ChartThemeDark:
                         return new ChartThemeDark();
                     case QChart::ChartThemeBrownSand:
                         return new ChartThemeBrownSand();
                     case QChart::ChartThemeBlueNcs:
                         return new ChartThemeBlueNcs();
                     case QChart::ChartThemeHighContrast:
                         return new ChartThemeHighContrast();
                     case QChart::ChartThemeBlueIcy:
                         return new ChartThemeBlueIcy();
                     default:
                         return new ChartThemeSystem();
                 }
             }
             void ChartTheme::decorate(QChart *chart)
             {
                 QBrush brush;
                 if(brush == chart->backgroundBrush() ||  m_force)
                     chart->setBackgroundBrush(m_chartBackgroundGradient);
                 chart->setTitleFont(m_masterFont);
                 chart->setTitleBrush(m_labelBrush);
                 chart->setDropShadowEnabled(m_backgroundDropShadowEnabled);
             }
             void ChartTheme::decorate(QLegend *legend)
             {
                 QPen pen;
                 QBrush brush;
                 QFont font;
                 if (pen == legend->pen() || m_force)
                     legend->setPen(m_axisLinePen);
                 if (brush == legend->brush() || m_force)
                     legend->setBrush(m_chartBackgroundGradient);
                 if (font == legend->font() || m_force)
                     legend->setFont(m_labelFont);
                 if (brush == legend->labelBrush() || m_force)
                     legend->setLabelBrush(m_labelBrush);
             }
             void ChartTheme::decorate(QAreaSeries *series, int index)
             {
                 QPen pen;
                 QBrush brush;
                 if (pen == series->pen() ||  m_force){
                     pen.setColor(colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0.0));
                     pen.setWidthF(2);
                     series->setPen(pen);
                 }
                 if (brush == series->brush() ||  m_force) {
                    QBrush brush(m_seriesColors.at(index % m_seriesColors.size()));
                    series->setBrush(brush);
                 }
             }
             void ChartTheme::decorate(QLineSeries *series,int index)
             {
                 QPen pen;
                 if(pen == series->pen() ||  m_force ){
                     pen.setColor(m_seriesColors.at(index%m_seriesColors.size()));
                     pen.setWidthF(2);
                     series->setPen(pen);
                 }
             }
             void ChartTheme::decorate(QAbstractBarSeries *series, int index)
             {
                 QBrush brush;
                 QPen pen;
                 QList<QBarSet *> sets = series->barSets();
                 qreal takeAtPos = 0.5;
                 qreal step = 0.2;
                 if (sets.count() > 1 ) {
                     step = 1.0 / (qreal) sets.count();
                     if (sets.count() % m_seriesGradients.count())
                         step *= m_seriesGradients.count();
                     else
                         step *= (m_seriesGradients.count() - 1);
                 }
                 for (int i(0); i < sets.count(); i++) {
                     int colorIndex = (index + i) % m_seriesGradients.count();
                     if (i > 0 && i % m_seriesGradients.count() == 0) {
                         // There is no dedicated base color for each sets, generate more colors
                         takeAtPos += step;
                         if (takeAtPos == 1.0)
                             takeAtPos += step;
                         takeAtPos -= (int) takeAtPos;
                     }
                     if (brush == sets.at(i)->brush() ||  m_force )
                         sets.at(i)->setBrush(colorAt(m_seriesGradients.at(colorIndex), takeAtPos));
                     // Pick label color from the opposite end of the gradient.
                     // 0.3 as a boundary seems to work well.
                     if (takeAtPos < 0.3)
                         sets.at(i)->setLabelBrush(colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 1));
                     else
                         sets.at(i)->setLabelBrush(colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0));
                     if (pen == sets.at(i)->pen() ||  m_force) {
                         QColor c = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0.0);
                         sets.at(i)->setPen(c);
                     }
                 }
             }
             void ChartTheme::decorate(QScatterSeries *series, int index)
             {
                 QPen pen;
                 QBrush brush;
                 if (pen == series->pen() ||  m_force) {
                     pen.setColor(colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0.0));
                     pen.setWidthF(2);
                     series->setPen(pen);
                 }
                 if (brush == series->brush() ||  m_force) {
                     QBrush brush(m_seriesColors.at(index % m_seriesColors.size()));
                     series->setBrush(brush);
                 }
             }
             void ChartTheme::decorate(QPieSeries *series, int index)
             {
                 for (int i(0); i < series->slices().count(); i++) {
                     QColor penColor = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0.0);
                     // Get color for a slice from a gradient linearly, beginning from the start of the gradient
                     qreal pos = (qreal) (i + 1) / (qreal) series->count();
                     QColor brushColor = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), pos);
                     QPieSlice *s = series->slices().at(i);
                     QPieSlicePrivate *d = QPieSlicePrivate::fromSlice(s);
                     if (d->m_data.m_slicePen.isThemed() || m_force)
                         d->setPen(penColor, true);
                     if (d->m_data.m_sliceBrush.isThemed() || m_force)
                         d->setBrush(brushColor, true);
                     if (d->m_data.m_labelBrush.isThemed() || m_force)
                         d->setLabelBrush(m_labelBrush.color(), true);
                     if (d->m_data.m_labelFont.isThemed() || m_force)
                         d->setLabelFont(m_labelFont, true);
                 }
             }
             void ChartTheme::decorate(QSplineSeries *series, int index)
             {
                 QPen pen;
                 if(pen == series->pen() ||  m_force){
                     pen.setColor(m_seriesColors.at(index%m_seriesColors.size()));
                     pen.setWidthF(2);
                     series->setPen(pen);
                 }
             }
             void ChartTheme::decorate(QAbstractAxis *axis,bool axisX)
             {
                 QPen pen;
                 QBrush brush;
                 QFont font;
-                if (axis->isAxisVisible()) {
+                if (axis->isArrowVisible()) {
                     if(brush == axis->labelsBrush() ||  m_force){
                         axis->setLabelsBrush(m_labelBrush);
                     }
                     if(pen == axis->labelsPen() ||  m_force){
                         axis->setLabelsPen(Qt::NoPen); // NoPen for performance reasons
                     }
                    if (axis->shadesVisible() ||  m_force) {
                      if(brush == axis->shadesBrush() ||  m_force){
                          axis->setShadesBrush(m_backgroundShadesBrush);
                      }
                      if(pen == axis->shadesPen() ||  m_force){
                          axis->setShadesPen(m_backgroundShadesPen);
                      }
                      if( m_force && (m_backgroundShades == BackgroundShadesBoth
                                      || (m_backgroundShades == BackgroundShadesVertical && axisX)
                                      || (m_backgroundShades == BackgroundShadesHorizontal && !axisX))){
                          axis->setShadesVisible(true);
                      }
                    }
                     if(pen == axis->axisPen() ||  m_force){
                         axis->setAxisPen(m_axisLinePen);
                     }
                     if(pen == axis->gridLinePen() ||  m_force){
                         axis->setGridLinePen(m_gridLinePen);
                     }
                     if(font == axis->labelsFont() || m_force){
                         axis->setLabelsFont(m_labelFont);
                     }
                 }
             }
             void ChartTheme::generateSeriesGradients()
             {
                 // Generate gradients in HSV color space
                 foreach (const QColor& color, m_seriesColors) {
                     QLinearGradient g;
                     qreal h = color.hsvHueF();
                     qreal s = color.hsvSaturationF();
                     // TODO: tune the algorithm to give nice results with most base colors defined in
                     // most themes. The rest of the gradients we can define manually in theme specific
                     // implementation.
                     QColor start = color;
                     start.setHsvF(h, 0.0, 1.0);
                     g.setColorAt(0.0, start);
                     g.setColorAt(0.5, color);
                     QColor end = color;
                     end.setHsvF(h, s, 0.25);
                     g.setColorAt(1.0, end);
                     m_seriesGradients << g;
                 }
             }
             QColor ChartTheme::colorAt(const QColor &start, const QColor &end, qreal pos)
             {
                 Q_ASSERT(pos >= 0.0 && pos <= 1.0);
                 qreal r = start.redF() + ((end.redF() - start.redF()) * pos);
                 qreal g = start.greenF() + ((end.greenF() - start.greenF()) * pos);
                 qreal b = start.blueF() + ((end.blueF() - start.blueF()) * pos);
                 QColor c;
                 c.setRgbF(r, g, b);
                 return c;
             }
             QColor ChartTheme::colorAt(const QGradient &gradient, qreal pos)
             {
                 Q_ASSERT(pos >= 0 && pos <= 1.0);
                 QGradientStops stops = gradient.stops();
                 int count = stops.count();
                 // find previous stop relative to position
                 QGradientStop prev = stops.first();
                 for (int i = 0; i < count; i++) {
                     QGradientStop stop = stops.at(i);
                     if (pos > stop.first)
                         prev = stop;
                     // given position is actually a stop position?
                     if (pos == stop.first) {
                         //qDebug() << "stop color" << pos;
                         return stop.second;
                     }
                 }
                 // find next stop relative to position
                 QGradientStop next = stops.last();
                 for (int i = count - 1; i >= 0; i--) {
                     QGradientStop stop = stops.at(i);
                     if (pos < stop.first)
                         next = stop;
                 }
                 //qDebug() << "prev" << prev.first << "pos" << pos << "next" << next.first;
                 qreal range = next.first - prev.first;
                 qreal posDelta = pos - prev.first;
                 qreal relativePos = posDelta / range;
                 //qDebug() << "range" << range << "posDelta" << posDelta << "relativePos" << relativePos;
                 return colorAt(prev.second, next.second, relativePos);
             }
             void ChartTheme::setForced(bool enabled)
             {
                 m_force=enabled;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

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