HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1626:7d4c8a772239

Adds logic to fix overlaping axes

Michal Klocek -

r1626:7d4c8a772239

parent child

Context file:

r1626:7d4c8a772239

Collapse all files

src/axis/qabstractaxis.cpp +6 -3

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

src/chartpresenter.cpp +26 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 "chartpresenter_p.h"
             #include "qchart.h"
             #include "qchart_p.h"
             #include "qabstractaxis.h"
             #include "qabstractaxis_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             #include "chartanimation_p.h"
             #include "qabstractseries_p.h"
             #include "qareaseries.h"
             #include "chartaxis_p.h"
             //#include "chartaxisx_p.h"
             //#include "chartaxisy_p.h"
             #include "areachartitem_p.h"
             #include "chartbackground_p.h"
             #include "chartlayout_p.h"
             #include <QTimer>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartPresenter::ChartPresenter(QChart* chart,ChartDataSet* dataset):QObject(chart),
             m_chart(chart),
             m_animator(0),
             m_dataset(dataset),
             m_chartTheme(0),
             m_options(QChart::NoAnimation),
             m_state(ShowState),
             m_layout(new ChartLayout(this)),
             m_backgroundItem(0),
             m_titleItem(0)
             {
             }
             ChartPresenter::~ChartPresenter()
             {
                 delete m_chartTheme;
             }
             void ChartPresenter::setGeometry(const QRectF& rect)
             {
                 Q_ASSERT(rect.isValid());
                 if(m_rect!=rect) {
                        m_rect=rect;
                        emit geometryChanged(m_rect);
                 }
             }
             void ChartPresenter::handleAxisAdded(QAbstractAxis* axis,Domain* domain)
             {
                 ChartAxis* item = axis->d_ptr->createGraphics(this);
                 item->setDomain(domain);
                 if(m_options.testFlag(QChart::GridAxisAnimations)){
                     item->setAnimator(m_animator);
                     item->setAnimation(new AxisAnimation(item));
                 }
                 if(item->axisType()==ChartAxis::X_AXIS){
                     m_chartTheme->decorate(axis,true);
                     QObject::connect(domain,SIGNAL(rangeXChanged(qreal,qreal,int)),item,SLOT(handleRangeChanged(qreal,qreal,int)));
                     //initialize
                     item->handleRangeChanged(domain->minX(),domain->maxX(),domain->tickXCount());
                 }
                 else{
                     m_chartTheme->decorate(axis,false);
                     QObject::connect(domain,SIGNAL(rangeYChanged(qreal,qreal,int)),item,SLOT(handleRangeChanged(qreal,qreal,int)));
                     //initialize
                     item->handleRangeChanged(domain->minY(),domain->maxY(),domain->tickYCount());
                 }
                 QObject::connect(this,SIGNAL(geometryChanged(QRectF)),item,SLOT(handleGeometryChanged(QRectF)));
+                QObject::connect(axis,SIGNAL(visibleChanged(bool)),this,SLOT(handleAxisVisibleChanged(bool)));
                 //initialize
                 if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
+                //reload visiblity
                 m_axisItems.insert(axis, item);
+                if(axis->isVisible()) axis->hide();
+                axis->show();
             }
             void ChartPresenter::handleAxisRemoved(QAbstractAxis* axis)
             {
                 ChartAxis* item = m_axisItems.take(axis);
                 Q_ASSERT(item);
                 if(m_animator) m_animator->removeAnimation(item);
                 item->deleteLater();
             }
             void ChartPresenter::handleSeriesAdded(QAbstractSeries* series,Domain* domain)
             {
                 Chart *item = series->d_ptr->createGraphics(this);
                 Q_ASSERT(item);
                 item->setDomain(domain);
                 QObject::connect(this,SIGNAL(geometryChanged(QRectF)),item,SLOT(handleGeometryChanged(QRectF)));
                 QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),item,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                 //initialize
                 item->handleDomainChanged(domain->minX(),domain->maxX(),domain->minY(),domain->maxY());
                 if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
                 m_chartItems.insert(series,item);
             }
             void ChartPresenter::handleSeriesRemoved(QAbstractSeries* series)
             {
                 Chart* item = m_chartItems.take(series);
                 Q_ASSERT(item);
                 if(m_animator) {
                     //small hack to handle area animations
                     if(series->type() == QAbstractSeries::SeriesTypeArea){
                         QAreaSeries* areaSeries = static_cast<QAreaSeries*>(series);
                         AreaChartItem* area = static_cast<AreaChartItem*>(item);
                         m_animator->removeAnimation(area->upperLineItem());
                         if(areaSeries->lowerSeries())  m_animator->removeAnimation(area->lowerLineItem());
                     }else
                         m_animator->removeAnimation(item);
                 }
                 item->deleteLater();
             }
+            void ChartPresenter::handleAxisVisibleChanged(bool visible)
+            {
+                QAbstractAxis* axis = static_cast<QAbstractAxis*> (sender());
+                Q_ASSERT(axis);
+                if(visible){
+                    QMapIterator<QAbstractAxis*, ChartAxis*> i(m_axisItems);
+                    while (i.hasNext()) {
+                    i.next();
+                    if(i.key()==axis) {
+                        continue;
+                    }
+                    if(i.key()->d_ptr->m_orientation==axis->d_ptr->m_orientation) {
+                        i.key()->setVisible(false);
+                    }
+                    }
+                }
+            }
             void ChartPresenter::setTheme(QChart::ChartTheme theme,bool force)
             {
                 if(m_chartTheme && m_chartTheme->id() == theme) return;
                 delete m_chartTheme;
                 m_chartTheme = ChartTheme::createTheme(theme);
                 m_chartTheme->setForced(force);
                 m_chartTheme->decorate(m_chart);
                 m_chartTheme->decorate(m_chart->legend());
                 resetAllElements();
                 // We do not want "force" to stay on.
                 // Bar/pie are calling decorate when adding/removing slices/bars which means
                 // that to preserve users colors "force" must not be on.
                 m_chartTheme->setForced(false);
             }
             QChart::ChartTheme ChartPresenter::theme()
             {
                 return m_chartTheme->id();
             }
             void ChartPresenter::setAnimationOptions(QChart::AnimationOptions options)
             {
                 if(m_options!=options) {
                     m_options=options;
                     if(m_options!=QChart::NoAnimation && !m_animator) {
                         m_animator= new ChartAnimator(this);
                     }
                     resetAllElements();
                 }
             }
             void ChartPresenter::resetAllElements()
             {
                 QMapIterator<QAbstractAxis*, ChartAxis*> i(m_axisItems);
                 while (i.hasNext()) {
                        i.next();
                        Domain* domain = i.value()->domain();
                        QAbstractAxis* axis = i.key();
                        handleAxisRemoved(axis);
                        handleAxisAdded(axis,domain);
                 }
                 QMapIterator<QAbstractSeries*, Chart*> j(m_chartItems);
                    while (j.hasNext()) {
                           j.next();
                           Domain* domain = j.value()->domain();
                           QAbstractSeries* series = j.key();
                           handleSeriesRemoved(series);
                           handleSeriesAdded(series,domain);
                    }
             }
             void ChartPresenter::zoomIn(qreal factor)
             {
                 QRectF rect = geometry();
                 rect.setWidth(rect.width()/factor);
                 rect.setHeight(rect.height()/factor);
                 rect.moveCenter(geometry().center());
                 zoomIn(rect);
             }
             void ChartPresenter::zoomIn(const QRectF& rect)
             {
                 QRectF r = rect.normalized();
                 r.translate(-geometry().topLeft());
                 if (!r.isValid())
                     return;
                 m_state = ZoomInState;
                 m_statePoint = QPointF(r.center().x()/geometry().width(),r.center().y()/geometry().height());
                 m_dataset->zoomInDomain(r,geometry().size());
                 m_state = ShowState;
             }
             void ChartPresenter::zoomOut(qreal factor)
             {
                 m_state = ZoomOutState;
                 QRectF chartRect;
                 chartRect.setSize(geometry().size());
                 QRectF rect;
                 rect.setSize(chartRect.size()/factor);
                 rect.moveCenter(chartRect.center());
                 if (!rect.isValid())
                     return;
                 m_statePoint = QPointF(rect.center().x()/geometry().width(),rect.center().y()/geometry().height());
                 m_dataset->zoomOutDomain(rect, chartRect.size());
                 m_state = ShowState;
             }
             void ChartPresenter::scroll(qreal dx,qreal dy)
             {
                 if(dx<0) m_state=ScrollLeftState;
                 if(dx>0) m_state=ScrollRightState;
                 if(dy<0) m_state=ScrollUpState;
                 if(dy>0) m_state=ScrollDownState;
                 m_dataset->scrollDomain(dx,dy,geometry().size());
                 m_state = ShowState;
             }
             QChart::AnimationOptions ChartPresenter::animationOptions() const
             {
                 return m_options;
             }
             void ChartPresenter::createBackgroundItem()
             {
                 if (!m_backgroundItem) {
                     m_backgroundItem = new ChartBackground(rootItem());
                     m_backgroundItem->setPen(Qt::NoPen);
                     m_backgroundItem->setZValue(ChartPresenter::BackgroundZValue);
                 }
             }
             void ChartPresenter::createTitleItem()
             {
                 if (!m_titleItem) {
                     m_titleItem = new QGraphicsSimpleTextItem(rootItem());
                     m_titleItem->setZValue(ChartPresenter::BackgroundZValue);
                 }
             }
             void ChartPresenter::handleAnimationFinished()
             {
                m_animations.removeAll(qobject_cast<ChartAnimation*>(sender()));
                if(m_animations.empty()) emit animationsFinished();
             }
             void ChartPresenter::startAnimation(ChartAnimation* animation)
             {
                 if (animation->state() != QAbstractAnimation::Stopped) animation->stop();
                 QObject::connect(animation, SIGNAL(finished()),this,SLOT(handleAnimationFinished()),Qt::UniqueConnection);
                 if(!m_animations.isEmpty()){
                     m_animations.append(animation);
                 }
                 QTimer::singleShot(0, animation, SLOT(start()));
             }
             QGraphicsRectItem* ChartPresenter::backgroundItem()
             {
                 return m_backgroundItem;
             }
             void ChartPresenter::setBackgroundBrush(const QBrush& brush)
             {
                 createBackgroundItem();
                 m_backgroundItem->setBrush(brush);
                 m_layout->invalidate();
             }
             QBrush ChartPresenter::backgroundBrush() const
             {
                 if (!m_backgroundItem) return QBrush();
                 return m_backgroundItem->brush();
             }
             void ChartPresenter::setBackgroundPen(const QPen& pen)
             {
                 createBackgroundItem();
                 m_backgroundItem->setPen(pen);
                 m_layout->invalidate();
             }
             QPen ChartPresenter::backgroundPen() const
             {
                 if (!m_backgroundItem) return QPen();
                 return m_backgroundItem->pen();
             }
             QGraphicsItem* ChartPresenter::titleItem()
             {
                 return m_titleItem;
             }
             void ChartPresenter::setTitle(const QString& title)
             {
                 createTitleItem();
                 m_titleItem->setText(title);
                 m_layout->invalidate();
             }
             QString ChartPresenter::title() const
             {
                 if (!m_titleItem) return QString();
                 return m_titleItem->text();
             }
             void ChartPresenter::setTitleFont(const QFont& font)
             {
                 createTitleItem();
                 m_titleItem->setFont(font);
                 m_layout->invalidate();
             }
             QFont ChartPresenter::titleFont() const
             {
                 if (!m_titleItem)  return QFont();
                 return m_titleItem->font();
             }
             void ChartPresenter::setTitleBrush(const QBrush &brush)
             {
                 createTitleItem();
                 m_titleItem->setBrush(brush);
                 m_layout->invalidate();
             }
             QBrush ChartPresenter::titleBrush() const
             {
                 if (!m_titleItem) return QBrush();
                 return m_titleItem->brush();
             }
             void ChartPresenter::setBackgroundVisible(bool visible)
             {
                 createBackgroundItem();
                 m_backgroundItem->setVisible(visible);
             }
             bool ChartPresenter::isBackgroundVisible() const
             {
                 if (!m_backgroundItem) return false;
                 return m_backgroundItem->isVisible();
             }
             void ChartPresenter::setBackgroundDropShadowEnabled(bool enabled)
             {
                 createBackgroundItem();
                 m_backgroundItem->setDropShadowEnabled(enabled);
             }
             bool ChartPresenter::isBackgroundDropShadowEnabled() const
             {
                 if (!m_backgroundItem) return false;
                 return m_backgroundItem->isDropShadowEnabled();
             }
             QGraphicsLayout* ChartPresenter::layout()
             {
                 return m_layout;
             }
             void ChartPresenter::setMarginsMinimum(const QRectF& margins)
             {
                 Q_UNUSED(margins);
               //  m_layout->setMarginsMinimum(margins);
             }
             QRectF ChartPresenter::margins() const
             {
                 return QRectF();//m_layout->margins();
             }
             QLegend* ChartPresenter::legend()
             {
                 return m_chart->legend();
             }
             QList<ChartAxis*>  ChartPresenter::axisItems() const
             {
                 return m_axisItems.values();
             }
             void ChartPresenter::setVisible(bool visible)
             {
                 m_chart->setVisible(visible);
             }
             #include "moc_chartpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartpresenter_p.h +1 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  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 CHARTPRESENTER_H
             #define CHARTPRESENTER_H
             #include "qchartglobal.h"
             #include "qchart.h" //becouse of QChart::ChartThemeId //TODO
             #include <QRectF>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class Chart;
             class QAbstractSeries;
             class ChartDataSet;
             class Domain;
             class ChartAxis;
             class ChartTheme;
             class ChartAnimator;
             class ChartBackground;
             class ChartAnimation;
             class ChartLayout;
             class ChartPresenter: public QObject
             {
                 Q_OBJECT
             public:
                 enum ZValues {
                     BackgroundZValue = -1,
                     ShadesZValue,
                     GridZValue,
                     SeriesZValue,
                     LineChartZValue = SeriesZValue,
                     BarSeriesZValue = SeriesZValue,
                     ScatterSeriesZValue = SeriesZValue,
                     PieSeriesZValue = SeriesZValue,
                     AxisZValue,
                     LegendZValue
                 };
                 enum State {
                     ShowState,
                     ScrollUpState,
                     ScrollDownState,
                     ScrollLeftState,
                     ScrollRightState,
                     ZoomInState,
                     ZoomOutState
                 };
                 ChartPresenter(QChart* chart,ChartDataSet *dataset);
                 virtual ~ChartPresenter();
                 ChartAnimator* animator() const { return m_animator; }
                 ChartTheme *chartTheme() const { return m_chartTheme; }
                 ChartDataSet *dataSet() const { return m_dataset; }
                 QGraphicsItem* rootItem() const { return m_chart; }
                 QGraphicsRectItem* backgroundItem();
                 QGraphicsItem* titleItem();
                 QList<ChartAxis*> axisItems() const;
                 QLegend* legend();
                 void setBackgroundBrush(const QBrush& brush);
                 QBrush backgroundBrush() const;
                 void setBackgroundPen(const QPen& pen);
                 QPen backgroundPen() const;
                 void setTitle(const QString& title);
                 QString title() const;
                 void setTitleFont(const QFont& font);
                 QFont titleFont() const;
                 void setTitleBrush(const QBrush &brush);
                 QBrush titleBrush() const;
                 void setBackgroundVisible(bool visible);
                 bool isBackgroundVisible() const;
                 void setBackgroundDropShadowEnabled(bool enabled);
                 bool isBackgroundDropShadowEnabled() const;
                 void setVisible(bool visible);
                 void setTheme(QChart::ChartTheme theme,bool force = true);
                 QChart::ChartTheme theme();
                 void setAnimationOptions(QChart::AnimationOptions options);
                 QChart::AnimationOptions animationOptions() const;
                 void zoomIn(qreal factor);
                 void zoomIn(const QRectF& rect);
                 void zoomOut(qreal factor);
                 void scroll(qreal dx,qreal dy);
                 void setGeometry(const QRectF& rect);
                 QRectF geometry() { return m_rect; }
                 void startAnimation(ChartAnimation* animation);
                 State state() const { return m_state; }
                 QPointF statePoint() const { return m_statePoint; }
                 void resetAllElements();
                 void setMarginsMinimum(const QRectF& margins);
                 QRectF margins() const;
                 QGraphicsLayout* layout();
             private:
                 void createBackgroundItem();
                 void createTitleItem();
             public Q_SLOTS:
                 void handleSeriesAdded(QAbstractSeries* series,Domain* domain);
                 void handleSeriesRemoved(QAbstractSeries* series);
                 void handleAxisAdded(QAbstractAxis* axis,Domain* domain);
                 void handleAxisRemoved(QAbstractAxis* axis);
+                void handleAxisVisibleChanged(bool visible);
             private Q_SLOTS:
                 void handleAnimationFinished();
             Q_SIGNALS:
                 void geometryChanged(const QRectF& rect);
                 void animationsFinished();
                 void marginsChanged(QRectF margins);
             private:
                 QChart* m_chart;
                 ChartAnimator* m_animator;
                 ChartDataSet* m_dataset;
                 ChartTheme *m_chartTheme;
                 QMap<QAbstractSeries*, Chart*> m_chartItems;
                 QMap<QAbstractAxis*, ChartAxis*> m_axisItems;
                 QRectF m_rect;
                 QChart::AnimationOptions m_options;
                 State m_state;
                 QPointF m_statePoint;
                 QList<ChartAnimation*> m_animations;
                 ChartLayout* m_layout;
                 ChartBackground* m_backgroundItem;
                 QGraphicsSimpleTextItem* m_titleItem;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* CHARTPRESENTER_H_ */

General Comments 0

Write
Preview

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

No TODOs yet

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

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