HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r742:c04f89af81a0

Polishing qchart class

Michal Klocek -

r742:c04f89af81a0

parent child

Context file:

r742:c04f89af81a0

Collapse all files

src/chartpresenter.cpp +6 -10

                 m_chartTheme(0),
                 m_rect(QRectF(QPoint(0,0),m_chart->size())),
                 m_options(QChart::NoAnimation),
-                m_themeForce(false)
+                m_themeForce(false),
+                m_padding(50),
+                m_backgroundPadding(10)
             {
                 createConnections();
                 setTheme(QChart::ChartThemeDefault,false);
                 QObject::connect(m_dataset,SIGNAL(axisRemoved(QChartAxis*)),this,SLOT(handleAxisRemoved(QChartAxis*)));
             }
-            QRectF ChartPresenter::geometry() const
-                return m_rect;
             void ChartPresenter::handleGeometryChanged()
             {
                 QRectF rect(QPoint(0,0),m_chart->size());
-                rect.adjust(m_chart->padding(),m_chart->padding(), -m_chart->padding(), -m_chart->padding());
+                rect.adjust(m_padding,m_padding,-m_padding,-m_padding);
                 //rewrite zoom stack
                 /*
             void ChartPresenter::zoomIn(const QRectF& rect)
             {
             	QRectF r = rect.normalized();
-            	r.translate(-m_chart->padding(), -m_chart->padding());
+            	r.translate(-m_padding, -m_padding);
             	if(m_animator) {
             		QPointF point(r.center().x()/geometry().width(),r.center().y()/geometry().height());
             	QSizeF size = geometry().size();
             	QRectF rect = geometry();
-            	rect.translate(-m_chart->padding(), -m_chart->padding());
+            	rect.translate(-m_padding, -m_padding);
             	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());

src/chartpresenter_p.h +9 -10

                 ChartPresenter(QChart* chart,ChartDataSet *dataset);
                 virtual ~ChartPresenter();
-                void setMargin(int margin);
+                int padding() const { return m_padding; }
-                int margin() const;
+                int backgroundPadding() const { return m_backgroundPadding; }
+                QRectF geometry() const { return m_rect; }
-                QRectF geometry() const;
+                ChartAnimator* animator() const { return m_animator; }
+                ChartTheme *chartTheme() const { return m_chartTheme; }
-                ChartAnimator* animator() const {return m_animator;}
+                ChartDataSet *dataSet() const { return m_dataset; }
-                ChartTheme *chartTheme() { return m_chartTheme; }
+                QGraphicsItem* rootItem() const { return m_chart; }
-                ChartDataSet *dataSet() { return m_dataset; }
                 void setTheme(QChart::ChartTheme theme,bool force = true);
                 QChart::ChartTheme theme();
                 void setAnimationOptions(QChart::AnimationOptions options);
                 QChart::AnimationOptions animationOptions() const;
-                QGraphicsItem* rootItem() const {return m_chart;};
                 void zoomIn();
                 void zoomIn(const QRectF& rect);
                 void zoomOut();
                 QRectF m_rect;
                 QChart::AnimationOptions m_options;
                 bool m_themeForce;
+                int m_padding;
+                int m_backgroundPadding;
             };

src/qchart.cpp +22 -50

             QChart::QChart(QGraphicsItem *parent, Qt::WindowFlags wFlags) : QGraphicsWidget(parent,wFlags),
             d_ptr(new QChartPrivate(this))
             {
                 d_ptr->m_legend = new QLegend(this);
                 d_ptr->m_dataset = new ChartDataSet(this);
                 d_ptr->m_presenter = new ChartPresenter(this,d_ptr->m_dataset);
             QBrush QChart::backgroundBrush() const
             {
-                if(!d_ptr->m_backgroundItem) return QBrush();
+                if (!d_ptr->m_backgroundItem) return QBrush();
                 return (d_ptr->m_backgroundItem)->brush();
             }
             QPen QChart::backgroundPen() const
             {
-                if(!d_ptr->m_backgroundItem) return QPen();
+                if (!d_ptr->m_backgroundItem) return QPen();
                 return d_ptr->m_backgroundItem->pen();
             }
              */
             QString QChart::title() const
             {
-                if(d_ptr->m_titleItem)
+                if (d_ptr->m_titleItem)
                 return d_ptr->m_titleItem->text();
                 else
                 return QString();
              */
             QBrush QChart::titleBrush() const
             {
-                if(!d_ptr->m_titleItem) return QBrush();
+                if (!d_ptr->m_titleItem) return QBrush();
                 return d_ptr->m_titleItem->brush();
             }
              */
             void QChart::zoomIn(const QRectF& rect)
             {
-                if(!rect.isValid()) return;
+                if (!rect.isValid()) return;
                 d_ptr->m_presenter->zoomIn(rect);
             }
                 d_ptr->m_presenter->scroll(0,-d_ptr->m_presenter->geometry().width()/(axisY()->ticksCount()-1));
             }
-            void QChart::setPadding(int padding)
-                if(d_ptr->m_padding==padding) {
-                    d_ptr->m_padding = padding;
-                    d_ptr->m_presenter->handleGeometryChanged();
-                    d_ptr->updateLayout();
-            int QChart::padding() const
-                return d_ptr->m_padding;
-            void QChart::setBackgroundPadding(int padding)
-                if(d_ptr->m_backgroundPadding!=padding) {
-                    d_ptr->m_backgroundPadding = padding;
-                    d_ptr->updateLayout();
-            void QChart::setBackgroundDiameter(int diameter)
-                d_ptr->createChartBackgroundItem();
-                d_ptr->m_backgroundItem->setDimeter(diameter);
-                d_ptr->m_backgroundItem->update();
             void QChart::setBackgroundVisible(bool visible)
             {
                 d_ptr->createChartBackgroundItem();
             bool QChart::isBackgroundVisible() const
             {
-                if(!d_ptr->m_backgroundItem) return false;
+                if (!d_ptr->m_backgroundItem) return false;
                 return d_ptr->m_backgroundItem->isVisible();
             }
             m_titleItem(0),
             m_legend(0),
             m_dataset(0),
-            m_presenter(0),
+            m_presenter(0)
-            m_padding(50),
-            m_backgroundPadding(10)
             {
             }
             void QChartPrivate::createChartBackgroundItem()
             {
-                if(!m_backgroundItem) {
+                if (!m_backgroundItem) {
                     m_backgroundItem = new ChartBackground(q_ptr);
                     m_backgroundItem->setPen(Qt::NoPen);
                     m_backgroundItem->setZValue(ChartPresenter::BackgroundZValue);
             void QChartPrivate::createChartTitleItem()
             {
-                if(!m_titleItem) {
+                if (!m_titleItem) {
                     m_titleItem = new QGraphicsSimpleTextItem(q_ptr);
                     m_titleItem->setZValue(ChartPresenter::BackgroundZValue);
                 }
             void QChartPrivate::updateLegendLayout()
             {
-                QRectF plotRect = m_rect.adjusted(m_padding,m_padding, -m_padding, -m_padding);
+                int padding = m_presenter->padding();
+                QRectF plotRect = m_rect.adjusted(padding,padding,-padding,-padding);
                 QRectF legendRect;
                 switch (m_legend->preferredLayout())
                 {
                     case QLegend::PreferredLayoutTop: {
                         //        legendRect = plotRect.adjusted(m_padding,0,-m_padding,-m_padding - plotRect.height());
-                        legendRect = plotRect.adjusted(0,0,0,-m_padding - plotRect.height());
+                        legendRect = plotRect.adjusted(0,0,0,-padding - plotRect.height());
                         break;
                     }
                     case QLegend::PreferredLayoutBottom: {
-                        legendRect = plotRect.adjusted(m_padding,m_padding + plotRect.height(),-m_padding,0);
+                        legendRect = plotRect.adjusted(padding,padding + plotRect.height(),-padding,0);
                         break;
                     }
                     case QLegend::PreferredLayoutLeft: {
-                        legendRect = plotRect.adjusted(0,m_padding,-m_padding - plotRect.width(),-m_padding);
+                        legendRect = plotRect.adjusted(0,padding,-padding - plotRect.width(),-padding);
                         break;
                     }
                     case QLegend::PreferredLayoutRight: {
-                        legendRect = plotRect.adjusted(m_padding + plotRect.width(),m_padding,0,-m_padding);
+                        legendRect = plotRect.adjusted(padding + plotRect.width(),padding,0,-padding);
                         break;
                     }
                     default: {
             void QChartPrivate::updateLayout()
             {
-                if(!m_rect.isValid()) return;
+                if (!m_rect.isValid()) return;
+                int padding = m_presenter->padding();
+                int backgroundPadding = m_presenter->backgroundPadding();
-                QRectF rect = m_rect.adjusted(m_padding,m_padding, -m_padding, -m_padding);
+                QRectF rect = m_rect.adjusted(padding,padding,-padding,-padding);
                 // recalculate title position
                 if (m_titleItem) {
                     QPointF center = m_rect.center() -m_titleItem->boundingRect().center();
-                    m_titleItem->setPos(center.x(),m_rect.top()/2 + m_padding/2);
+                    m_titleItem->setPos(center.x(),m_rect.top()/2 + padding/2);
                 }
                 //recalculate background gradient
                 if (m_backgroundItem) {
-                    m_backgroundItem->setRect(m_rect.adjusted(m_backgroundPadding,m_backgroundPadding, -m_backgroundPadding, -m_backgroundPadding));
+                    m_backgroundItem->setRect(m_rect.adjusted(backgroundPadding,backgroundPadding, -backgroundPadding, -backgroundPadding));
                 }
                 // recalculate legend position

src/qchart.h +25 -13

+            /****************************************************************************
+            **
+            ** 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
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class Axis;
             class QSeries;
             class QChartAxis;
             class QLegend;
                     ChartThemeCount
                 };
-                enum  AnimationOption {
+                enum AnimationOption {
                     NoAnimation = 0x0,
                     GridAxisAnimations = 0x1,
                     SeriesAnimations =0x2,
                     AllAnimations = 0x3
-                    };
+                };
-                    Q_DECLARE_FLAGS(AnimationOptions, AnimationOption)
+                Q_DECLARE_FLAGS(AnimationOptions, AnimationOption)
             public:
                 QChart(QGraphicsItem *parent = 0, Qt::WindowFlags wFlags = 0);
                 QLegend* takeLegend();
                 void giveLegend(QLegend* legend);
-                int padding() const;
             protected:
                 void resizeEvent(QGraphicsSceneResizeEvent *event);
             protected:
                 QScopedPointer<QChartPrivate> d_ptr;
+                friend class QChartView;
-            private:
-                void setPadding(int padding);
-                void setBackgroundPadding(int padding);
-                void setBackgroundDiameter(int diameter);
-            private:
                 Q_DISABLE_COPY(QChart);
             };

src/qchart_p.h 0 -2

                 QLegend* m_legend;
                 ChartDataSet *m_dataset;
                 ChartPresenter *m_presenter;
-                int m_padding;
-                int m_backgroundPadding;
                 Q_DECLARE_PUBLIC(QChart);
             };

src/qchartview.cpp +3 -3

             #include "qchartview.h"
             #include "qchart.h"
+            #include "qchart_p.h"
             #include "qchartaxis.h"
             #include <QGraphicsView>
             #include <QGraphicsScene>
             #include <QRubberBand>
             #include <QResizeEvent>
-            #include <QDebug>
             /*!
                 \enum QChartView::RubberBandPolicy
             {
                 if(m_rubberBand && m_rubberBand->isEnabled() && event->button() == Qt::LeftButton) {
-                    int padding = m_chart->padding();
+                    int padding = m_chart->d_ptr->m_presenter->padding();
                     QRect rect(padding, padding, width() - 2 * padding, height() - 2 * padding);
                     if (rect.contains(event->pos())) {
             void QChartView::mouseMoveEvent(QMouseEvent *event)
             {
                 if(m_rubberBand && m_rubberBand->isVisible()) {
-                    int padding = m_chart->padding();
+                    int padding = m_chart->d_ptr->m_presenter->padding();
                     QRect rect(padding, padding, width() - 2 * padding, height() - 2 * padding);
                     int width = event->pos().x() - m_rubberBandOrigin.x();
                     int height = event->pos().y() - m_rubberBandOrigin.y();

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