HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1187:5f42a207d0d0

Add gestures support for zoomlinechart example...

Jani Honkonen -

r1187:5f42a207d0d0

parent child

Context file:

r1187:5f42a207d0d0

Collapse all files

examples/zoomlinechart/chart.cpp created 644 +61 0

@@ -0,0 +1,61
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2012 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	#include "chart.h"
	22	#include <QGesture>
	23	#include <QGraphicsScene>
	24	#include <QGraphicsView>
	25
	26	Chart::Chart(QGraphicsItem *parent, Qt::WindowFlags wFlags)
	27	:QChart(parent, wFlags)
	28	{
	29	// Seems that QGraphicsView (QChartView) does not grab gestures.
	30	// They can only be grabbed here in the QGraphicsWidget (QChart).
	31	grabGesture(Qt::PanGesture);
	32	grabGesture(Qt::PinchGesture);
	33	}
	34
	35	Chart::~Chart()
	36	{
	37
	38	}
	39
	40	bool Chart::sceneEvent(QEvent *event)
	41	{
	42	if (event->type() == QEvent::Gesture)
	43	return gestureEvent(static_cast<QGestureEvent*>(event));
	44	return QChart::event(event);
	45	}
	46
	47	bool Chart::gestureEvent(QGestureEvent* event)
	48	{
	49	if (QGesture *gesture = event->gesture(Qt::PanGesture)) {
	50	QPanGesture pan = static_cast<QPanGesture >(gesture);
	51	scroll(pan->delta());
	52	}
	53
	54	if (QGesture *gesture = event->gesture(Qt::PinchGesture)) {
	55	QPinchGesture pinch = static_cast<QPinchGesture >(gesture);
	56	if (pinch->changeFlags() & QPinchGesture::ScaleFactorChanged)
	57	zoom(pinch->scaleFactor());
	58	}
	59
	60	return true;
	61	}

examples/zoomlinechart/chart.h created 644 +44 0

@@ -0,0 +1,44
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2012 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	#ifndef CHART_H
	22	#define CHART_H
	23
	24	#include <QChart>
	25
	26	QTCOMMERCIALCHART_USE_NAMESPACE
	27
	28	class Chart : public QChart
	29	{
	30	public:
	31	explicit Chart(QGraphicsItem *parent = 0, Qt::WindowFlags wFlags = 0);
	32	~Chart();
	33
	34	protected:
	35	bool sceneEvent(QEvent *event);
	36
	37	private:
	38	bool gestureEvent(QGestureEvent* event);
	39
	40	private:
	41
	42	};
	43
	44	#endif // CHART_H

examples/zoomlinechart/chartview.cpp +36 -25

             /****************************************************************************
             **
             ** 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 "chartview.h"
             #include <QMouseEvent>
             ChartView::ChartView(QChart *chart, QWidget *parent) :
-                QChartView(chart, parent), m_rubberBand(QRubberBand::Rectangle, this), m_chart(chart)
+                QChartView(chart, parent),
+                m_isTouching(false)
             {
+                setRubberBand(QChartView::RectangleRubberBand);
             }
-            void ChartView::mousePressEvent(QMouseEvent *event)
+            bool ChartView::viewportEvent(QEvent *event)
             {
-                if (event->button() != Qt::LeftButton)
+                if (event->type() == QEvent::TouchBegin) {
-                    return;
+                    // By default touch events are converted to mouse events. So
+                    // after this event we will get a mouse event also but we want
+                    // to handle touch events as gestures only. So we need this safeguard
+                    // to block mouse events that are actually generated from touch.
+                    m_isTouching = true;
-                m_origin = event->pos();
+                    // Turn off animations when handling gestures they
-                m_rubberBand.setGeometry(QRect(m_origin, QSize()));
+                    // will only slow us down.
-                m_rubberBand.show();
+                    chart()->setAnimationOptions(QChart::NoAnimation);
+                }
+                return QChartView::viewportEvent(event);
+            }
-                event->accept();
+            void ChartView::mousePressEvent(QMouseEvent *event)
+            {
+                if (m_isTouching)
+                    return;
+                QChartView::mousePressEvent(event);
             }
             void ChartView::mouseMoveEvent(QMouseEvent *event)
             {
-                if (m_rubberBand.isVisible())
+                if (m_isTouching)
-                    m_rubberBand.setGeometry(QRect(m_origin, event->pos()).normalized());
+                    return;
+                QChartView::mouseMoveEvent(event);
             }
             void ChartView::mouseReleaseEvent(QMouseEvent *event)
             {
-                if (event->button() == Qt::LeftButton && m_rubberBand.isVisible()) {
+                if (m_isTouching)
-                    m_rubberBand.hide();
+                    m_isTouching = false;
-                    QRect rect = m_rubberBand.geometry();
+                // Because we disabled animations when touch event was detected
-                    m_chart->zoomIn(rect);
+                // we must put them back on.
-                    event->accept();
+                chart()->setAnimationOptions(QChart::SeriesAnimations);
-                if (event->button() == Qt::RightButton) {
+                QChartView::mouseReleaseEvent(event);
-                    m_chart->zoomOut();
             }
             //![1]
             void ChartView::keyPressEvent(QKeyEvent *event)
             {
                 switch (event->key()) {
                 case Qt::Key_Plus:
-                    m_chart->zoomIn();
+                    chart()->zoomIn();
                     break;
                 case Qt::Key_Minus:
-                    m_chart->zoomOut();
+                    chart()->zoomOut();
                     break;
             //![1]
                 case Qt::Key_Left:
-                    m_chart->scrollLeft();
+                    chart()->scrollLeft();
                     break;
                 case Qt::Key_Right:
-                    m_chart->scrollRight();
+                    chart()->scrollRight();
                     break;
                 case Qt::Key_Up:
-                    m_chart->scrollUp();
+                    chart()->scrollUp();
                     break;
                 case Qt::Key_Down:
-                    m_chart->scrollDown();
+                    chart()->scrollDown();
                     break;
                 default:
                     QGraphicsView::keyPressEvent(event);
                     break;
                 }
             }

examples/zoomlinechart/chartview.h +3 -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$
             **
             ****************************************************************************/
             #ifndef CHARTVIEW_H
             #define CHARTVIEW_H
             #include <QChartView>
             #include <QRubberBand>
             QTCOMMERCIALCHART_USE_NAMESPACE
             //![1]
             class ChartView : public QChartView
             //![1]
             {
             public:
                 ChartView(QChart *chart, QWidget *parent = 0);
             //![2]
             protected:
+                bool viewportEvent(QEvent *event);
                 void mousePressEvent(QMouseEvent *event);
                 void mouseMoveEvent(QMouseEvent *event);
                 void mouseReleaseEvent(QMouseEvent *event);
                 void keyPressEvent(QKeyEvent *event);
             //![2]
             private:
-                QRubberBand m_rubberBand;
+                bool m_isTouching;
-                QPoint m_origin;
-                QChart* m_chart;
             };
             #endif

examples/zoomlinechart/main.cpp +5 -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 "chart.h"
             #include "chartview.h"
             #include <QApplication>
             #include <QMainWindow>
             #include <QLineSeries>
             QTCOMMERCIALCHART_USE_NAMESPACE
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
             //![1]
                 QLineSeries* series = new QLineSeries();
                 qreal yValue = 0.0;
                 for (int i(0); i < 500; i++) {
                     yValue = yValue + (qreal) (qrand() % 10) / 500.0;
                     QPointF value((i + (qreal) rand() / (qreal) RAND_MAX) * (10.0 / 500.0), yValue);
                     *series << value;
                 }
             //![1]
-                QChart* chart = new QChart();
+                Chart* chart = new Chart();
                 chart->addSeries(series);
                 chart->setTitle("Zoom in/out example");
-                chart->setAnimationOptions(QChart::AllAnimations);
+                chart->setAnimationOptions(QChart::SeriesAnimations);
                 ChartView* chartView = new ChartView(chart);
                 chartView->setRenderHint(QPainter::Antialiasing);
                 QMainWindow window;
                 window.setCentralWidget(chartView);
                 window.resize(400, 300);
+                window.grabGesture(Qt::PanGesture);
+                window.grabGesture(Qt::PinchGesture);
                 window.show();
                 return a.exec();
             }

examples/zoomlinechart/zoomlinechart.pro +3 -2

             !include( ../examples.pri ) {
              error( "Couldn't find the examples.pri file!" )
             }
             TARGET = zoomlinechart
-            HEADERS += chartview.h
+            HEADERS += chart.h chartview.h
-            SOURCES += main.cpp chartview.cpp
+            SOURCES += main.cpp chart.cpp chartview.cpp
             !system_build:mac: QMAKE_POST_LINK += "$$MAC_POST_LINK_PREFIX $$MAC_EXAMPLES_BIN_DIR"

src/chartpresenter.cpp +22 -19

             /****************************************************************************
              **
              ** 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 "qaxis.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             #include "qabstractseries_p.h"
             #include "qareaseries.h"
             #include "chartaxis_p.h"
             #include "areachartitem_p.h"
             #include "chartbackground_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartPresenter::ChartPresenter(QChart* chart,ChartDataSet* dataset):QObject(chart),
             m_chart(chart),
             m_animator(0),
             m_dataset(dataset),
             m_chartTheme(0),
             m_chartRect(QRectF(QPoint(0,0),m_chart->size())),
             m_options(QChart::NoAnimation),
             m_minLeftMargin(0),
             m_minBottomMargin(0),
             m_backgroundItem(0),
             m_titleItem(0),
             m_marginBig(60),
             m_marginSmall(20),
             m_marginTiny(10),
             m_chartMargins(QRect(m_marginBig,m_marginBig,0,0))
             {
             }
             ChartPresenter::~ChartPresenter()
             {
                 delete m_chartTheme;
             }
             void ChartPresenter::setGeometry(const QRectF& rect)
             {
                 m_rect = rect;
                 Q_ASSERT(m_rect.isValid());
                 updateLayout();
             }
             void ChartPresenter::setMinimumMarginWidth(ChartAxis* axis, qreal width)
             {
                 switch(axis->axisType()){
                 case ChartAxis::X_AXIS:
                 {
                     if(width>m_chartRect.width()+ m_chartMargins.left()) {
                         m_minLeftMargin= width - m_chartRect.width();
                         updateLayout();
                     }
                     break;
                 }
                 case ChartAxis::Y_AXIS:
                 {
                     if(m_minLeftMargin!=width){
                         m_minLeftMargin= width;
                         updateLayout();
                     }
                     break;
                 }
                 }
             }
             void ChartPresenter::setMinimumMarginHeight(ChartAxis* axis, qreal height)
             {
                 switch(axis->axisType()){
                 case ChartAxis::X_AXIS:
                 {
                     if(m_minBottomMargin!=height) {
                         m_minBottomMargin= height;
                         updateLayout();
                     }
                     break;
                 }
                 case ChartAxis::Y_AXIS:
                 {
                     if(height>m_chartMargins.bottom()+m_chartRect.height()){
                         m_minBottomMargin= height - m_chartRect.height();
                         updateLayout();
                     }
                     break;
                 }
                 }
             }
             void ChartPresenter::handleAxisAdded(QAxis* axis,Domain* domain)
             {
                 ChartAxis* item = new ChartAxis(axis,this,axis==m_dataset->axisX()?ChartAxis::X_AXIS : ChartAxis::Y_AXIS);
                 if(m_options.testFlag(QChart::GridAxisAnimations)){
                     m_animator->addAnimation(item);
                 }
                 if(axis==m_dataset->axisX()){
                     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)));
                 //initialize
                 item->handleGeometryChanged(m_chartRect);
                 m_axisItems.insert(axis, item);
             }
             void ChartPresenter::handleAxisRemoved(QAxis* axis)
             {
                 ChartAxis* item = m_axisItems.take(axis);
                 Q_ASSERT(item);
                 if(m_animator) m_animator->removeAnimation(item);
                 delete item;
             }
             void ChartPresenter::handleSeriesAdded(QAbstractSeries* series,Domain* domain)
             {
                 Chart *item = series->d_ptr->createGraphics(this);
                 Q_ASSERT(item);
                 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_chartRect.isValid()) item->handleGeometryChanged(m_chartRect);
                 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);
                 }
                 delete item;
             }
             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()
             {
                 QList<QAxis *> axisList = m_axisItems.uniqueKeys();
                 QList<QAbstractSeries *> seriesList = m_chartItems.uniqueKeys();
                 foreach(QAxis *axis, axisList) {
                     handleAxisRemoved(axis);
                     handleAxisAdded(axis,m_dataset->domain(axis));
                 }
                 foreach(QAbstractSeries *series, seriesList) {
                     handleSeriesRemoved(series);
                     handleSeriesAdded(series,m_dataset->domain(series));
             //        m_dataset->removeSeries(series);
             //        m_dataset->addSeries(series);
                 }
             }
-            void ChartPresenter::zoomIn()
+            void ChartPresenter::zoomIn(qreal factor)
             {
                 QRectF rect = chartGeometry();
-                rect.setWidth(rect.width()/2);
+                rect.setWidth(rect.width()/factor);
-                rect.setHeight(rect.height()/2);
+                rect.setHeight(rect.height()/factor);
                 rect.moveCenter(chartGeometry().center());
                 zoomIn(rect);
             }
             void ChartPresenter::zoomIn(const QRectF& rect)
             {
                 QRectF r = rect.normalized();
                 r.translate(-m_chartMargins.topLeft());
-                if(!r.isValid()) return;
+                if (!r.isValid())
-                if(m_animator) {
+                    return;
+                if (m_animator) {
                     QPointF point(r.center().x()/chartGeometry().width(),r.center().y()/chartGeometry().height());
                     m_animator->setState(ChartAnimator::ZoomInState,point);
                 }
                 m_dataset->zoomInDomain(r,chartGeometry().size());
-                if(m_animator) {
+                if (m_animator)
                     m_animator->setState(ChartAnimator::ShowState);
             }
-            void ChartPresenter::zoomOut()
+            void ChartPresenter::zoomOut(qreal factor)
             {
-                if(m_animator)
+                if (m_animator)
                     m_animator->setState(ChartAnimator::ZoomOutState);
-                QSizeF size = chartGeometry().size();
+                QRectF chartRect;
-                QRectF rect = chartGeometry();
+                chartRect.setSize(chartGeometry().size());
-                rect.translate(-m_chartMargins.topLeft());
-                if(!rect.isValid()) return;
-                m_dataset->zoomOutDomain(rect.adjusted(size.width()/4,size.height()/4,-size.width()/4,-size.height()/4),size);
-                //m_dataset->zoomOutDomain(m_zoomStack[m_zoomIndex-1],geometry().size());
-                if(m_animator){
+                QRectF rect;
+                rect.setSize(chartRect.size()/factor);
+                rect.moveCenter(chartRect.center());
+                if (!rect.isValid())
+                    return;
+                m_dataset->zoomOutDomain(rect, chartRect.size());
+                if (m_animator)
                     m_animator->setState(ChartAnimator::ShowState);
             }
             void ChartPresenter::scroll(int dx,int dy)
             {
                 if(m_animator){
                     if(dx<0) m_animator->setState(ChartAnimator::ScrollLeftState,QPointF());
                     if(dx>0) m_animator->setState(ChartAnimator::ScrollRightState,QPointF());
                     if(dy<0) m_animator->setState(ChartAnimator::ScrollUpState,QPointF());
                     if(dy>0) m_animator->setState(ChartAnimator::ScrollDownState,QPointF());
                 }
                 m_dataset->scrollDomain(dx,dy,chartGeometry().size());
                 if(m_animator){
                     m_animator->setState(ChartAnimator::ShowState);
                 }
             }
             QChart::AnimationOptions ChartPresenter::animationOptions() const
             {
                 return m_options;
             }
             void ChartPresenter::updateLayout()
             {
                 if (!m_rect.isValid()) return;
                 // recalculate title size
                 QSize titleSize;
                 int titlePadding=0;
                 if (m_titleItem) {
                     titleSize= m_titleItem->boundingRect().size().toSize();
                 }
                 //defaults
                 m_chartMargins = QRect(QPoint(m_minLeftMargin>m_marginBig?m_minLeftMargin:m_marginBig,m_marginBig),QPoint(m_marginBig,m_minBottomMargin>m_marginBig?m_minBottomMargin:m_marginBig));
                 titlePadding = m_chartMargins.top()/2;
                 QLegend* legend = m_chart->d_ptr->m_legend;
                 // recalculate legend position
                 if (legend->isAttachedToChart() && legend->isEnabled()) {
                     QRect legendRect;
                     // Reserve some space for legend
                     switch (legend->alignment()) {
                     case QLegend::AlignmentTop: {
                         int ledgendSize = legend->minHeight();
                         int topPadding = 2*m_marginTiny + titleSize.height() + ledgendSize + m_marginTiny;
                         m_chartMargins = QRect(QPoint(m_chartMargins.left(),topPadding),QPoint(m_chartMargins.right(),m_chartMargins.bottom()));
                         m_legendMargins = QRect(QPoint(m_chartMargins.left(),topPadding - (ledgendSize + m_marginTiny)),QPoint(m_chartMargins.right(),m_rect.height()-topPadding + m_marginTiny));
                         titlePadding = m_marginTiny + m_marginTiny;
                         break;
                     }
                     case QLegend::AlignmentBottom: {
                         int ledgendSize = legend->minHeight();
                         int bottomPadding = m_marginTiny + m_marginSmall + ledgendSize + m_marginTiny + m_minBottomMargin;
                         m_chartMargins = QRect(QPoint(m_chartMargins.left(),m_chartMargins.top()),QPoint(m_chartMargins.right(),bottomPadding));
                         m_legendMargins = QRect(QPoint(m_chartMargins.left(),m_rect.height()-bottomPadding + m_marginTiny + m_minBottomMargin),QPoint(m_chartMargins.right(),m_marginTiny + m_marginSmall));
                         titlePadding = m_chartMargins.top()/2;
                         break;
                     }
                     case QLegend::AlignmentLeft: {
                         int ledgendSize = legend->minWidth();
                         int leftPadding = m_marginTiny + m_marginSmall + ledgendSize + m_marginTiny + m_minLeftMargin;
                         m_chartMargins = QRect(QPoint(leftPadding,m_chartMargins.top()),QPoint(m_chartMargins.right(),m_chartMargins.bottom()));
                         m_legendMargins = QRect(QPoint(m_marginTiny + m_marginSmall,m_chartMargins.top()),QPoint(m_rect.width()-leftPadding + m_marginTiny + m_minLeftMargin,m_chartMargins.bottom()));
                         titlePadding = m_chartMargins.top()/2;
                         break;
                     }
                     case QLegend::AlignmentRight: {
                         int ledgendSize = legend->minWidth();
                         int rightPadding = m_marginTiny + m_marginSmall + ledgendSize + m_marginTiny;
                         m_chartMargins = QRect(QPoint(m_chartMargins.left(),m_chartMargins.top()),QPoint(rightPadding,m_chartMargins.bottom()));
                         m_legendMargins = QRect(QPoint(m_rect.width()- rightPadding+ m_marginTiny ,m_chartMargins.top()),QPoint(m_marginTiny + m_marginSmall,m_chartMargins.bottom()));
                         titlePadding = m_chartMargins.top()/2;
                         break;
                     }
                     default: {
                         break;
                     }
                     }
                 }
                 if(m_rect.width()<2*(m_chartMargins.top()+m_chartMargins.bottom()) || m_rect.height()< 2*(m_chartMargins.top() + m_chartMargins.bottom()))
                 {
                     m_chart->setMinimumSize(2*(m_chartMargins.top()+m_chartMargins.bottom()),2*(m_chartMargins.top() + m_chartMargins.bottom()));
                     return;
                 }
                 // recalculate title position
                 if (m_titleItem) {
                     QPointF center = m_rect.center() -m_titleItem->boundingRect().center();
                     m_titleItem->setPos(center.x(),titlePadding);
                 }
                 //recalculate background gradient
                 if (m_backgroundItem) {
                     m_backgroundItem->setRect(m_rect.adjusted(m_marginTiny,m_marginTiny, -m_marginTiny, -m_marginTiny));
                 }
                 QRectF chartRect = m_rect.adjusted(m_chartMargins.left(),m_chartMargins.top(),-m_chartMargins.right(),-m_chartMargins.bottom());
                 legend->setGeometry(m_rect.adjusted(m_legendMargins.left(),m_legendMargins.top(),-m_legendMargins.right(),-m_legendMargins.bottom()));
                 if(m_chartRect!=chartRect){
                     m_chartRect=chartRect;
                     emit geometryChanged(m_chartRect);
                 }
             }
             void ChartPresenter::createChartBackgroundItem()
             {
                 if (!m_backgroundItem) {
                     m_backgroundItem = new ChartBackground(rootItem());
                     m_backgroundItem->setPen(Qt::NoPen);
                     m_backgroundItem->setZValue(ChartPresenter::BackgroundZValue);
                 }
             }
             void ChartPresenter::createChartTitleItem()
             {
                 if (!m_titleItem) {
                     m_titleItem = new QGraphicsSimpleTextItem(rootItem());
                     m_titleItem->setZValue(ChartPresenter::BackgroundZValue);
                 }
             }
             #include "moc_chartpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartpresenter_p.h +2 -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$
             **
             ****************************************************************************/
             #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 ChartPresenter: public QObject
             {
                 Q_OBJECT
             public:
                 enum ZValues {
                     BackgroundZValue = -1,
                     ShadesZValue,
                     GridZValue,
                     LineChartZValue,
                     BarSeriesZValue,
                     ScatterSeriesZValue,
                     PieSeriesZValue,
                     AxisZValue,
                     LegendZValue
                 };
                 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; }
                 void setTheme(QChart::ChartTheme theme,bool force = true);
                 QChart::ChartTheme theme();
                 void setAnimationOptions(QChart::AnimationOptions options);
                 QChart::AnimationOptions animationOptions() const;
-                void zoomIn();
+                void zoomIn(qreal factor);
                 void zoomIn(const QRectF& rect);
-                void zoomOut();
+                void zoomOut(qreal factor);
                 void scroll(int dx,int dy);
                 void setGeometry(const QRectF& rect);
                 QRectF chartGeometry() const { return m_chartRect; }
                 void setMinimumMarginHeight(ChartAxis* axis, qreal height);
                 void setMinimumMarginWidth(ChartAxis* axis, qreal width);
                 qreal minimumLeftMargin() const { return m_minLeftMargin; }
                 qreal minimumBottomMargin() const { return m_minBottomMargin; }
             public: //TODO: fix me
                 void resetAllElements();
                 void createChartBackgroundItem();
                 void createChartTitleItem();
                 QRectF margins() const { return m_chartMargins;}
             public Q_SLOTS:
                 void handleSeriesAdded(QAbstractSeries* series,Domain* domain);
                 void handleSeriesRemoved(QAbstractSeries* series);
                 void handleAxisAdded(QAxis* axis,Domain* domain);
                 void handleAxisRemoved(QAxis* axis);
                 void updateLayout();
             Q_SIGNALS:
                 void geometryChanged(const QRectF& rect);
             private:
                 QChart* m_chart;
                 ChartAnimator* m_animator;
                 ChartDataSet* m_dataset;
                 ChartTheme *m_chartTheme;
                 QMap<QAbstractSeries *, Chart *> m_chartItems;
                 QMap<QAxis *, ChartAxis *> m_axisItems;
                 QRectF m_rect;
                 QRectF m_chartRect;
                 QChart::AnimationOptions m_options;
                 qreal m_minLeftMargin;
                 qreal m_minBottomMargin;
             public: //TODO: fixme
                 ChartBackground* m_backgroundItem;
                 QGraphicsSimpleTextItem* m_titleItem;
                 int m_marginBig;
                 int m_marginSmall;
                 int m_marginTiny;
                 QRectF m_chartMargins;
                 QRectF m_legendMargins;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* CHARTPRESENTER_H_ */

src/qchart.cpp +32 -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 "qchart.h"
             #include "qchart_p.h"
             #include "legendscroller_p.h"
             #include "qlegend_p.h"
             #include "chartbackground_p.h"
             #include "qaxis.h"
             #include <QGraphicsScene>
             #include <QGraphicsSceneResizeEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
              \enum QChart::ChartTheme
              This enum describes the theme used by the chart.
              \value ChartThemeLight The default theme
              \value ChartThemeBlueCerulean
              \value ChartThemeDark
              \value ChartThemeBrownSand
              \value ChartThemeBlueNcs
              \value ChartThemeHighContrast
              \value ChartThemeBlueIcy
              */
             /*!
              \enum QChart::AnimationOption
              For enabling/disabling animations. Defaults to NoAnimation.
              \value NoAnimation
              \value GridAxisAnimations
              \value SeriesAnimations
              \value AllAnimations
              */
             /*!
              \class QChart
              \brief QtCommercial chart API.
              QChart is a QGraphicsWidget that you can show in a QGraphicsScene. It manages the graphical
              representation of different types of series and other chart related objects like
              QAxis and QLegend. If you simply want to show a chart in a layout, you can use the
              convenience class QChartView instead of QChart.
              \sa QChartView
              */
             /*!
              Constructs a chart object which is a child of a\a parent. Parameter \a wFlags is passed to the QGraphicsWidget constructor.
              */
             QChart::QChart(QGraphicsItem *parent, Qt::WindowFlags wFlags) : QGraphicsWidget(parent,wFlags),
                 d_ptr(new QChartPrivate())
             {
                 d_ptr->m_dataset = new ChartDataSet(this);
                 d_ptr->m_presenter = new ChartPresenter(this,d_ptr->m_dataset);
                 d_ptr->createConnections();
                 d_ptr->m_legend = new LegendScroller(this);
                 d_ptr->m_presenter->setTheme(QChart::ChartThemeLight, false);
             }
             /*!
              Destroys the object and it's children, like series and axis objects added to it.
              */
             QChart::~QChart()
             {
                 //delete first presenter , since this is a root of all the graphical items
                 delete d_ptr->m_presenter;
                 d_ptr->m_presenter=0;
             }
             /*!
              Adds the \a series and optional \a axisY onto the chart and takes the ownership of the objects.
              If auto scaling is enabled, re-scales the axes the series is bound to (both the x axis and
              the y axis).
              */
             void QChart::addSeries(QAbstractSeries *series, QAxis *axisY)
             {
                 Q_ASSERT(series);
                 d_ptr->m_dataset->addSeries(series, axisY);
             }
             /*!
              Removes the \a series specified in a perameter from the QChartView.
              It releses its ownership of the specified QChartSeries object.
              It does not delete the pointed QChartSeries data object
              \sa addSeries(), removeAllSeries()
              */
             void QChart::removeSeries(QAbstractSeries *series)
             {
                 Q_ASSERT(series);
                 d_ptr->m_dataset->removeSeries(series);
             }
             /*!
              Removes all the QChartSeries that have been added to the QChartView
              It also deletes the pointed QChartSeries data objects
              \sa addSeries(), removeSeries()
              */
             void QChart::removeAllSeries()
             {
                 d_ptr->m_dataset->removeAllSeries();
             }
             /*!
              Sets the \a brush that is used for painting the background of the chart area.
              */
             void QChart::setBackgroundBrush(const QBrush& brush)
             {
                 //TODO: refactor me
                 d_ptr->m_presenter->createChartBackgroundItem();
                 d_ptr->m_presenter->m_backgroundItem->setBrush(brush);
                 d_ptr->m_presenter->m_backgroundItem->update();
             }
             /*!
                 Gets the brush that is used for painting the background of the chart area.
              */
             QBrush QChart::backgroundBrush() const
             {
                 //TODO: refactor me
                 if (!d_ptr->m_presenter->m_backgroundItem) return QBrush();
                 return (d_ptr->m_presenter->m_backgroundItem)->brush();
             }
             /*!
              Sets the \a pen that is used for painting the background of the chart area.
              */
             void QChart::setBackgroundPen(const QPen& pen)
             {
                 //TODO: refactor me
                 d_ptr->m_presenter->createChartBackgroundItem();
                 d_ptr->m_presenter->m_backgroundItem->setPen(pen);
                 d_ptr->m_presenter->m_backgroundItem->update();
             }
             /*!
                 Gets the pen that is used for painting the background of the chart area.
              */
             QPen QChart::backgroundPen() const
             {
                 //TODO: refactor me
                 if (!d_ptr->m_presenter->m_backgroundItem) return QPen();
                 return d_ptr->m_presenter->m_backgroundItem->pen();
             }
             /*!
              Sets the chart \a title. The description text that is drawn above the chart.
              */
             void QChart::setTitle(const QString& title)
             {
                 //TODO: refactor me
                 d_ptr->m_presenter->createChartTitleItem();
                 d_ptr->m_presenter->m_titleItem->setText(title);
                 d_ptr->m_presenter->updateLayout();
             }
             /*!
              Returns the chart title. The description text that is drawn above the chart.
              */
             QString QChart::title() const
             {
                 //TODO: refactor me
                 if (d_ptr->m_presenter->m_titleItem)
                     return d_ptr->m_presenter->m_titleItem->text();
                 else
                     return QString();
             }
             /*!
              Sets the \a font that is used for drawing the chart description text that is rendered above the chart.
              */
             void QChart::setTitleFont(const QFont& font)
             {
                 //TODO: refactor me
                 d_ptr->m_presenter->createChartTitleItem();
                 d_ptr->m_presenter->m_titleItem->setFont(font);
                 d_ptr->m_presenter->updateLayout();
             }
             /*!
                 Gets the font that is used for drawing the chart description text that is rendered above the chart.
              */
             QFont QChart::titleFont() const
             {
                 if (d_ptr->m_presenter->m_titleItem)
                     return d_ptr->m_presenter->m_titleItem->font();
                 else
                     return QFont();
             }
             /*!
              Sets the \a brush used for rendering the title text.
              */
             void QChart::setTitleBrush(const QBrush &brush)
             {
                 //TODO: refactor me
                 d_ptr->m_presenter->createChartTitleItem();
                 d_ptr->m_presenter->m_titleItem->setBrush(brush);
                 d_ptr->m_presenter->updateLayout();
             }
             /*!
              Returns the brush used for rendering the title text.
              */
             QBrush QChart::titleBrush() const
             {
                 //TODO: refactor me
                 if (!d_ptr->m_presenter->m_titleItem) return QBrush();
                 return d_ptr->m_presenter->m_titleItem->brush();
             }
             /*!
              Sets the \a theme used by the chart for rendering the graphical representation of the data
              \sa theme()
              */
             void QChart::setTheme(QChart::ChartTheme theme)
             {
                 d_ptr->m_presenter->setTheme(theme);
             }
             /*!
              Returns the theme enum used by the chart.
              \sa ChartTheme, setTheme()
              */
             QChart::ChartTheme QChart::theme() const
             {
                 return d_ptr->m_presenter->theme();
             }
             /*!
              Zooms in the view by a factor of 2
              */
             void QChart::zoomIn()
             {
-                d_ptr->m_presenter->zoomIn();
+                d_ptr->m_presenter->zoomIn(2.0);
             }
             /*!
              Zooms in the view to a maximum level at which \a rect is still fully visible.
              */
             void QChart::zoomIn(const QRectF& rect)
             {
                 if (!rect.isValid()) return;
                 d_ptr->m_presenter->zoomIn(rect);
             }
             /*!
              Restores the view zoom level to the previous one.
              */
             void QChart::zoomOut()
             {
-                d_ptr->m_presenter->zoomOut();
+                d_ptr->m_presenter->zoomOut(2.0);
+            }
+            /*!
+             Zooms in the view by a \a factor.
+             A factor over 1.0 zooms the view in and factor between 0.0 and 1.0 zooms out.
+             */
+            void QChart::zoom(qreal factor)
+            {
+                if (qFuzzyIsNull(factor))
+                    return;
+                if (qFuzzyCompare(factor, 1.0))
+                    return;
+                if (factor < 0)
+                    return;
+                if (factor > 1.0)
+                    d_ptr->m_presenter->zoomIn(factor);
+                else
+                    d_ptr->m_presenter->zoomOut(1.0 / factor);
             }
             /*!
              Returns the pointer to the x axis object of the chart
              */
             QAxis* QChart::axisX() const
             {
                 return d_ptr->m_dataset->axisX();
             }
             /*!
              Returns the pointer to the y axis object of the \a series
              If no \a series is provided then default Y axis of the chart is returned.
              */
             QAxis* QChart::axisY(QAbstractSeries *series) const
             {
                 return d_ptr->m_dataset->axisY(series);
             }
             /*!
              Returns the legend object of the chart. Ownership stays in chart.
              */
             QLegend* QChart::legend() const
             {
                 return d_ptr->m_legend;
             }
             /*!
                 Returns the rect that contains information about margins (distance between chart widget edge and axes).
                 Individual margins can be obtained by calling left, top, right, bottom on the returned rect.
              */
             QRectF QChart::margins() const
             {
                 return d_ptr->m_presenter->margins();
             }
             /*!
              Resizes and updates the chart area using the \a event data
              */
             void QChart::resizeEvent(QGraphicsSceneResizeEvent *event)
             {
                 d_ptr->m_rect = QRectF(QPoint(0,0),event->newSize());
                 QGraphicsWidget::resizeEvent(event);
                 d_ptr->m_presenter->setGeometry(d_ptr->m_rect);
             }
             /*!
              Sets animation \a options for the chart
              */
             void QChart::setAnimationOptions(AnimationOptions options)
             {
                 d_ptr->m_presenter->setAnimationOptions(options);
             }
             /*!
              Returns animation options for the chart
              */
             QChart::AnimationOptions QChart::animationOptions() const
             {
                 return d_ptr->m_presenter->animationOptions();
             }
             /*!
                 Scrolls the visible area of the chart to the left by the distance between two x axis ticks
              */
             void QChart::scrollLeft()
             {
                 d_ptr->m_presenter->scroll(-d_ptr->m_presenter->chartGeometry().width()/(axisX()->ticksCount()-1),0);
             }
             /*!
                 Scrolls the visible area of the chart to the right by the distance between two x axis ticks
              */
             void QChart::scrollRight()
             {
                 d_ptr->m_presenter->scroll(d_ptr->m_presenter->chartGeometry().width()/(axisX()->ticksCount()-1),0);
             }
             /*!
                 Scrolls the visible area of the chart up by the distance between two y axis ticks
              */
             void QChart::scrollUp()
             {
                 d_ptr->m_presenter->scroll(0,d_ptr->m_presenter->chartGeometry().width()/(axisY()->ticksCount()-1));
             }
             /*!
                 Scrolls the visible area of the chart down by the distance between two y axis ticks
              */
             void QChart::scrollDown()
             {
                 d_ptr->m_presenter->scroll(0,-d_ptr->m_presenter->chartGeometry().width()/(axisY()->ticksCount()-1));
             }
             /*!
+                Scrolls the visible area of the chart by the distance defined in the \a delta.
+             */
+            void QChart::scroll(const QPointF &delta)
+            {
+                d_ptr->m_presenter->scroll(-delta.x(), delta.y());
+            }
+            /*!
                 Sets the chart background visibility state to \a visible
              */
             void QChart::setBackgroundVisible(bool visible)
             {
                 //TODO: refactor me
                 d_ptr->m_presenter->createChartBackgroundItem();
                 d_ptr->m_presenter->m_backgroundItem->setVisible(visible);
             }
             /*!
                 Returns the chart's background visibility state
              */
             bool QChart::isBackgroundVisible() const
             {
                 //TODO: refactor me
                 if (!d_ptr->m_presenter->m_backgroundItem)
                     return false;
                 return d_ptr->m_presenter->m_backgroundItem->isVisible();
             }
             /*!
                 Sets the background drop shadow effect state to \a enabled.
             */
             void QChart::setBackgroundDropShadowEnabled(bool enabled)
             {
                 d_ptr->m_presenter->createChartBackgroundItem();
                 d_ptr->m_presenter->m_backgroundItem->setDropShadowEnabled(enabled);
             }
             /*!
                 Returns true if the drop shadow effect is enabled for the chart background.
             */
             bool QChart::isBackgroundDropShadowEnabled() const
             {
                 if (!d_ptr->m_presenter->m_backgroundItem)
                     return false;
                 return d_ptr->m_presenter->m_backgroundItem->isDropShadowEnabled();
             }
             QList<QAbstractSeries*> QChart::series() const
             {
                 return d_ptr->m_dataset->series();
             }
             //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QChartPrivate::QChartPrivate():
                 m_legend(0),
                 m_dataset(0),
                 m_presenter(0)
             {
             }
             QChartPrivate::~QChartPrivate()
             {
             }
             void QChartPrivate::createConnections()
             {
                 QObject::connect(m_dataset,SIGNAL(seriesAdded(QAbstractSeries*,Domain*)),m_presenter,SLOT(handleSeriesAdded(QAbstractSeries*,Domain*)));
                 QObject::connect(m_dataset,SIGNAL(seriesRemoved(QAbstractSeries*)),m_presenter,SLOT(handleSeriesRemoved(QAbstractSeries*)));
                 QObject::connect(m_dataset,SIGNAL(axisAdded(QAxis*,Domain*)),m_presenter,SLOT(handleAxisAdded(QAxis*,Domain*)));
                 QObject::connect(m_dataset,SIGNAL(axisRemoved(QAxis*)),m_presenter,SLOT(handleAxisRemoved(QAxis*)));
             }
             #include "moc_qchart.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchart.h +2 0

             /****************************************************************************
             **
             ** Copyright (C) 2012 Digia Plc
             ** All rights reserved.
             ** For any questions to Digia, please use contact form at http://qt.digia.com
             **
             ** This file is part of the Qt Commercial Charts Add-on.
             **
             ** $QT_BEGIN_LICENSE$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef QCHART_H
             #define QCHART_H
             #include <QAbstractSeries>
             #include <QLegend>
             #include <QGraphicsWidget>
             class QGraphicsSceneResizeEvent;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QAbstractSeries;
             class QAxis;
             class QLegend;
             struct QChartPrivate;
             class QTCOMMERCIALCHART_EXPORT QChart : public QGraphicsWidget
             {
                 Q_OBJECT
                 Q_ENUMS(ChartTheme)
                 Q_ENUMS(AnimationOption)
             public:
                 enum ChartTheme {
                     ChartThemeLight = 0,
                     ChartThemeBlueCerulean,
                     ChartThemeDark,
                     ChartThemeBrownSand,
                     ChartThemeBlueNcs,
                     ChartThemeHighContrast,
                     ChartThemeBlueIcy
                 };
                 enum AnimationOption {
                     NoAnimation = 0x0,
                     GridAxisAnimations = 0x1,
                     SeriesAnimations =0x2,
                     AllAnimations = 0x3
                 };
                 Q_DECLARE_FLAGS(AnimationOptions, AnimationOption)
             public:
                 explicit QChart(QGraphicsItem *parent = 0, Qt::WindowFlags wFlags = 0);
                 ~QChart();
                 void addSeries(QAbstractSeries *series, QAxis *axisY = 0);
                 void removeSeries(QAbstractSeries *series);
                 void removeAllSeries();
                 QList<QAbstractSeries*> series() const;
                 void setTheme(QChart::ChartTheme theme);
                 QChart::ChartTheme theme() 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 setBackgroundBrush(const QBrush &brush);
                 QBrush backgroundBrush() const;
                 void setBackgroundPen(const QPen &pen);
                 QPen backgroundPen() const;
                 void setBackgroundVisible(bool visible = true);
                 bool isBackgroundVisible() const;
                 void setBackgroundDropShadowEnabled(bool enabled = true);
                 bool isBackgroundDropShadowEnabled() const;
                 void setAnimationOptions(AnimationOptions options);
                 AnimationOptions animationOptions() const;
                 void zoomIn();
                 void zoomIn(const QRectF &rect);
                 void zoomOut();
+                void zoom(qreal factor);
                 void scrollLeft();
                 void scrollRight();
                 void scrollUp();
                 void scrollDown();
+                void scroll(const QPointF &delta);
                 QAxis* axisX() const;
                 QAxis* axisY(QAbstractSeries* series = 0) const;
                 QLegend* legend() const;
                 QRectF margins() const;
             protected:
                 void resizeEvent(QGraphicsSceneResizeEvent *event);
             protected:
                 QScopedPointer<QChartPrivate> d_ptr;
                 friend class QLegend;
                 friend class ChartPresenter;
                 Q_DISABLE_COPY(QChart)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             Q_DECLARE_OPERATORS_FOR_FLAGS(QTCOMMERCIALCHART_NAMESPACE::QChart::AnimationOptions)
             #endif

General Comments 0

Write
Preview

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

No TODOs yet

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

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