HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1628:ae9ab27188c9

Add defualt show axis...

Michal Klocek -

r1628:ae9ab27188c9

parent child

Context file:

r1628:ae9ab27188c9

Collapse all files

demos/qmlcustommodel/qml/qmlcustommodel/main.qml +4 -14

             /****************************************************************************
             **
             ** 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$
             **
             ****************************************************************************/
             import QtQuick 1.0
             import QtCommercial.Chart 1.0
             import QmlCustomModel 1.0
             Rectangle {
                 anchors.fill: parent
                 //![1]
                 ChartView {
                     id: chartView
                     title: "Top-5 car brand shares in Finland"
                     anchors.fill: parent
                     animationOptions: ChartView.SeriesAnimations
                     BarCategoriesAxis {
                         id: categoryAxis
                         categories: ["2007", "2008", "2009", "2010", "2011", "2012", "2013", "2014" ]
                     }
                     ValuesAxis {
                         id: yAxis
                         min: 0
                         max: 60
                     }
                     // ...
                     //![1]
                     //![2]
                     CustomModel {
                         id: customModel
                         verticalHeaders: ["Manufacturer", "Volkswagen", "Toyota", "Ford", "Skoda", "Volvo", "Others"]
                         CustomModelElement { values: [0, "Manufacturer", 0, 1, 2, 3, 4] }
                         CustomModelElement { values: [1, "Volkswagen", 10.3, 12.0, 12.8, 13.0, 13.8] }
                         CustomModelElement { values: [2, "Toyota", 13.8, 13.5, 16.2, 13.7, 10.7] }
                         CustomModelElement { values: [3, "Ford", 6.4, 7.1, 8.9, 8.2, 8.6] }
                         CustomModelElement { values: [4, "Skoda", 4.7, 5.8, 6.9, 8.3, 8.2] }
                         CustomModelElement { values: [5, "Volvo", 7.1, 6.7, 6.5, 6.3, 7.0] }
                         CustomModelElement { values: [6, "Others", 57.7, 54.9, 48.7, 50.5, 51.7] }
                     }
                     //![2]
                     //![5]
                     BarSeries {
                         id: myBarSeries
                         name: "Others"
                         barWidth: 0.9
                         visible: false
                         HBarModelMapper {
                             model: customModel
                             firstBarSetRow: 6
                             lastBarSetRow: 6
                             firstColumn: 2
                         }
                     }
                     //![5]
                     //![4]
                     LineSeries {
                         id: lineSeries1
                         name: "Volkswagen"
                         visible: false
                         HXYModelMapper {
                             model: customModel
                             xRow: 0
                             yRow: 1
                             firstColumn: 2
                         }
                     }
                     //![4]
                     LineSeries {
                         id: lineSeries2
                         name: "Toyota"
                         visible: false
                         HXYModelMapper {
                             model: customModel
                             xRow: 0
                             yRow: 2
                             firstColumn: 2
                         }
                     }
                     LineSeries {
                         id: lineSeries3
                         name: "Ford"
                         visible: false
                         HXYModelMapper {
                             model: customModel
                             xRow: 0
                             yRow: 3
                             firstColumn: 2
                         }
                     }
                     LineSeries {
                         id: lineSeries4
                         name: "Skoda"
                         visible: false
                         HXYModelMapper {
                             model: customModel
                             xRow: 0
                             yRow: 4
                             firstColumn: 2
                         }
                     }
                     LineSeries {
                         id: lineSeries5
                         name: "Volvo"
                         visible: false
                         HXYModelMapper {
                             model: customModel
                             xRow: 0
                             yRow: 5
                             firstColumn: 2
                         }
                     }
                     //![3]
                     PieSeries {
                         id: pieSeries
                         size: 0.4
                         horizontalPosition: 0.85
                         verticalPosition: 0.4
                         onClicked: {
                             // Show the selection by exploding the slice
                             slice.exploded = !slice.exploded;
                             // Update the line series to show the yearly data for this slice
                             for (var i = 0; i < chartView.count; i++) {
                                 if (chartView.series(i).name == slice.label) {
                                     chartView.series(i).visible = slice.exploded;
                                 }
                             }
                         }
                         VPieModelMapper {
                             model: customModel
                             labelsColumn: 1
                             valuesColumn: 2
                             firstRow: 1
                         }
                     }
                     //![3]
                     Component.onCompleted: {
-                        setAxisX(categoryAxis,myBarSeries)
+                          createDefaultAxes();
-                        setAxisX(categoryAxis,lineSeries1)
+                          setAxisX(categoryAxis,myBarSeries)
-                        setAxisX(categoryAxis,lineSeries2)
+                          categoryAxis.min = "2007"
-                        setAxisX(categoryAxis,lineSeries3)
+                          categoryAxis.max = "2014"
-                        setAxisX(categoryAxis,lineSeries4)
-                        setAxisX(categoryAxis,lineSeries5)
-                        setAxisY(yAxis,myBarSeries)
-                        setAxisY(yAxis,lineSeries1)
-                        setAxisY(yAxis,lineSeries2)
-                        setAxisY(yAxis,lineSeries3)
-                        setAxisY(yAxis,lineSeries4)
-                        setAxisY(yAxis,lineSeries5)
-                        categoryAxis.min = "2007"
-                        categoryAxis.max = "2014"
                     }
                 }
             }

src/chartpresenter.cpp +30 -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 "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();
+                selectVisibleAxis();
-                axis->show();
             }
             void ChartPresenter::handleAxisRemoved(QAbstractAxis* axis)
             {
                 ChartAxis* item = m_axisItems.take(axis);
                 Q_ASSERT(item);
+                selectVisibleAxis();
                 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::selectVisibleAxis()
+            {
+                QMapIterator<QAbstractAxis*, ChartAxis*> i(m_axisItems);
+                while (i.hasNext()) {
+                    i.next();
+                    i.key()->hide();
+                }
+                i.toFront();
+                bool axisX=false;
+                bool axisY=false;
+                while (i.hasNext()) {
+                    i.next();
+                    if(i.key()->d_ptr->m_orientation==Qt::Vertical && !axisY) {
+                        axisY=true;
+                        i.key()->show();
+                    }
+                    if(i.key()->d_ptr->m_orientation==Qt::Horizontal && !axisX) {
+                        axisX=true;
+                        i.key()->show();
+                    }
+                }
+            }
             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();
+                void selectVisibleAxis();
             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