HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r1883:fa0e7a49da94

Implements minimumMargins...

Michal Klocek -

r1883:fa0e7a49da94

parent child

Context file:

r1883:fa0e7a49da94

Collapse all files

plugins/declarative/declarativechart.cpp +12 -10

             {
                 setFlag(QGraphicsItem::ItemHasNoContents, false);
             //    m_chart->axisX()->setNiceNumbersEnabled(false);
-                m_chartMargins = m_chart->margins();
+                //TODO: check what should be really here margins or platArea ?!
+                m_chartMargins = m_chart->minimumMargins();
                 connect(m_chart, SIGNAL(marginsChanged(QRectF)), this, SLOT(handleMarginsChanged(QRectF)));
             }
             void DeclarativeChart::handleMarginsChanged(QRectF newMargins)
             {
+                //TODO: check what should be really here margins or platArea ?!
                 if (m_chartMargins.top() != newMargins.top())
-                    topMarginChanged(m_chart->margins().top());
+                    topMarginChanged(m_chart->minimumMargins().top());
                 if (m_chartMargins.bottom() != newMargins.bottom())
-                    bottomMarginChanged(m_chart->margins().bottom());
+                    bottomMarginChanged(m_chart->minimumMargins().bottom());
                 if (m_chartMargins.left() != newMargins.left())
-                    leftMarginChanged(m_chart->margins().left());
+                    leftMarginChanged(m_chart->minimumMargins().left());
                 if (m_chartMargins.right() != newMargins.right())
-                    rightMarginChanged(m_chart->margins().right());
+                    rightMarginChanged(m_chart->minimumMargins().right());
-                m_chartMargins = m_chart->margins();
+                m_chartMargins = m_chart->minimumMargins();
             }
             DeclarativeChart::~DeclarativeChart()
             qreal DeclarativeChart::topMargin()
             {
-                return m_chart->margins().top();
+                return m_chart->minimumMargins().top();
             }
             qreal DeclarativeChart::bottomMargin()
             {
-                return m_chart->margins().bottom();
+                return m_chart->minimumMargins().bottom();
             }
             qreal DeclarativeChart::leftMargin()
             {
-                return m_chart->margins().left();
+                return m_chart->minimumMargins().left();
             }
             qreal DeclarativeChart::rightMargin()
             {
-                return m_chart->margins().right();
+                return m_chart->minimumMargins().right();
             }
             void DeclarativeChart::zoom(qreal factor)

plugins/declarative/declarativechart.h +1 -1

                 // Extending QChart with DeclarativeChart is not possible because QObject does not support
                 // multi inheritance, so we now have a QChart as a member instead
                 QChart *m_chart;
-                QRectF m_chartMargins;
+                QMargins m_chartMargins;
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartlayout.cpp +20 -14

             #include "chartpresenter_p.h"
             #include "qlegend_p.h"
             #include "chartaxis_p.h"
+            #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             m_marginBig(60),
             m_marginSmall(20),
             m_marginTiny(10),
-            m_chartMargins(QPointF(m_marginBig,m_marginBig),QPointF(m_marginBig,m_marginBig)),
+            m_chartMargins(m_marginBig,m_marginBig,m_marginBig,m_marginBig),
             m_intialized(false)
             {
                 }
                 QLegend* legend = m_presenter->legend();
                 Q_ASSERT(legend);
                 qreal titlePadding = m_chartMargins.top()/2;
-                QRectF chartMargins = m_chartMargins;
+                QMargins chartMargins = m_chartMargins;
+                //TODO multiple axis handling;
+                chartMargins.setLeft(qMax(m_chartMargins.left(),int(axisWidth + 2*m_marginTiny)));
+                chartMargins.setBottom(qMax(m_chartMargins.bottom(),int(axisHeight + 2* m_marginTiny)));
                 // recalculate legend position
                 if ((legend->isAttachedToChart() && legend->isVisible())) {
                     switch (legend->alignment()) {
                     case Qt::AlignTop: {
                     	QSizeF legendSize = legend->effectiveSizeHint(Qt::PreferredSize,QSizeF(rect.width(),-1));
                         int topMargin = 2*m_marginTiny + titleSize.height() + legendSize.height() + m_marginTiny;
-                        chartMargins = QRect(QPoint(m_chartMargins.left(),topMargin),QPoint(m_chartMargins.right(),m_chartMargins.bottom()));
+                        chartMargins = QMargins(chartMargins.left(),topMargin,chartMargins.right(),chartMargins.bottom());
-                        m_legendMargins = QRect(QPoint(chartMargins.left(),topMargin - (legendSize.height() + m_marginTiny)),QPoint(chartMargins.right(),rect.height()-topMargin + m_marginTiny));
+                        m_legendMargins = QMargins(chartMargins.left(),topMargin - (legendSize.height() + m_marginTiny),chartMargins.right(),rect.height()-topMargin + m_marginTiny);
                         titlePadding = m_marginTiny + m_marginTiny;
                         break;
                     }
                     case Qt::AlignBottom: {
                     	QSizeF legendSize = legend->effectiveSizeHint(Qt::PreferredSize,QSizeF(rect.width(),-1));
                         int bottomMargin = m_marginTiny + legendSize.height() + m_marginTiny + axisHeight;
-                        chartMargins = QRect(QPoint(m_chartMargins.left(),m_chartMargins.top()),QPoint(m_chartMargins.right(),bottomMargin));
+                        chartMargins = QMargins(chartMargins.left(),chartMargins.top(),chartMargins.right(),bottomMargin);
-                        m_legendMargins = QRect(QPoint(chartMargins.left(),rect.height()-bottomMargin + m_marginTiny + axisHeight),QPoint(chartMargins.right(),m_marginTiny + m_marginSmall));
+                        m_legendMargins = QMargins(chartMargins.left(),rect.height()-bottomMargin + m_marginTiny + axisHeight,chartMargins.right(),m_marginTiny + m_marginSmall);
                         titlePadding = chartMargins.top()/2;
                         break;
                     }
                     case Qt::AlignLeft: {
                     	QSizeF legendSize = legend->effectiveSizeHint(Qt::PreferredSize,QSizeF(-1,rect.height()));
                         int leftPadding = m_marginTiny + legendSize.width() + m_marginTiny + axisWidth;
+                        chartMargins = QMargins(leftPadding,chartMargins.top(),chartMargins.right(),chartMargins.bottom());
-                        chartMargins = QRect(QPoint(leftPadding,m_chartMargins.top()),QPoint(m_chartMargins.right(),m_chartMargins.bottom()));
+                        m_legendMargins = QMargins(m_marginTiny + m_marginSmall,chartMargins.top(),rect.width()-leftPadding + m_marginTiny + axisWidth,chartMargins.bottom());
-                        m_legendMargins = QRect(QPoint(m_marginTiny + m_marginSmall,chartMargins.top()),QPoint(rect.width()-leftPadding + m_marginTiny + axisWidth,chartMargins.bottom()));
                         titlePadding = chartMargins.top()/2;
                         break;
                     }
                     case Qt::AlignRight: {
                     	QSizeF legendSize = legend->effectiveSizeHint(Qt::PreferredSize,QSizeF(-1,rect.height()));
                         int rightPadding = m_marginTiny + legendSize.width() + m_marginTiny;
-                        chartMargins = QRect(QPoint(m_chartMargins.left(),m_chartMargins.top()),QPoint(rightPadding,m_chartMargins.bottom()));
+                        chartMargins = QMargins(chartMargins.left(),chartMargins.top(),rightPadding,chartMargins.bottom());
-                        m_legendMargins = QRect(QPoint(rect.width()- rightPadding+ m_marginTiny ,chartMargins.top()),QPoint(m_marginTiny + m_marginSmall,chartMargins.bottom()));
+                        m_legendMargins = QMargins(rect.width()- rightPadding+ m_marginTiny ,chartMargins.top(),m_marginTiny + m_marginSmall,chartMargins.bottom());
                         titlePadding = chartMargins.top()/2;
                         break;
                     }
                     return QSize(-1,-1);
             }
-            void ChartLayout::setMarginsMinimum(const QRectF& margins)
+            void ChartLayout::setMinimumMargins(const QMargins& margins)
             {
                 if(m_chartMargins != margins){
                     m_chartMargins = margins;
                     updateGeometry();
                 }
             }
-            QRectF ChartLayout::margins() const
+            QMargins ChartLayout::minimumMargins() const
             {
                 return m_chartMargins;
             }

src/chartlayout_p.h +5 -4

             #ifndef CHARTLAYOUT_H_
             #define CHARTLAYOUT_H_
             #include <QGraphicsLayout>
+            #include <QMargins>
             #include "qchartglobal.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
                 ChartLayout(ChartPresenter* presenter);
                 virtual ~ChartLayout();
-                void setMarginsMinimum(const QRectF& margins);
+                void setMinimumMargins(const QMargins& margins);
-                QRectF margins() const;
+                QMargins minimumMargins() const;
                 void setGeometry(const QRectF& rect);
                 int m_marginBig;
                 int m_marginSmall;
                 int m_marginTiny;
-                QRectF m_chartMargins;
+                QMargins m_chartMargins;
-                QRectF m_legendMargins;
+                QMargins m_legendMargins;
                 bool m_intialized;

src/chartpresenter.cpp +4 -5

                 return m_layout;
             }
-            void ChartPresenter::setMarginsMinimum(const QRectF& margins)
+            void ChartPresenter::setMinimumMargins(const QMargins& margins)
             {
-                Q_UNUSED(margins);
+                m_layout->setMinimumMargins(margins);
-              //  m_layout->setMarginsMinimum(margins);
             }
-            QRectF ChartPresenter::margins() const
+            QMargins ChartPresenter::minimumMargins() const
             {
-                return m_layout->margins();
+                return m_layout->minimumMargins();
             }
             QLegend* ChartPresenter::legend()

src/chartpresenter_p.h +3 -2

             #include "qchartglobal.h"
             #include "qchart.h" //becouse of QChart::ChartThemeId //TODO
             #include <QRectF>
+            #include <QMargins>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
                 void resetAllElements();
-                void setMarginsMinimum(const QRectF& margins);
+                void setMinimumMargins(const QMargins& margins);
-                QRectF margins() const;
+                QMargins minimumMargins() const;
                 QGraphicsLayout* layout();
             private:

src/qchart.cpp +10 -9

             }
             /*!
+              Sets the minimum \a margins between the plot area (axes) and the edge of the chart widget.
+            */
+            void QChart::setMinimumMargins(const QMargins& margins)
+            {
+                d_ptr->m_presenter->setMinimumMargins(margins);
+            }
+            /*!
                 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
+            QMargins QChart::minimumMargins() const
             {
-                return d_ptr->m_presenter->margins();
+                return d_ptr->m_presenter->minimumMargins();
             }
             /*!
             {
                 return d_ptr->m_dataset->series();
             }
-            /*!
-              Sets the minimum \a margins between the plot area (axes) and the edge of the chart widget.
-            */
-            void QChart::setMarginsMinimum(const QRectF& margins)
-                d_ptr->m_presenter->setMarginsMinimum(margins);
             /*!
               Sets \a axis to the chart, which will control the presentation of the \a series

src/qchart.h +5 -3

             #include <QAbstractSeries>
             #include <QLegend>
             #include <QGraphicsWidget>
+            #include <QMargins>
             class QGraphicsSceneResizeEvent;
                 Q_PROPERTY(bool backgroundVisible READ isBackgroundVisible WRITE setBackgroundVisible)
                 Q_PROPERTY(bool dropShadowEnabled READ isDropShadowEnabled WRITE setDropShadowEnabled)
                 Q_PROPERTY(QChart::AnimationOptions animationOptions READ animationOptions WRITE setAnimationOptions)
-                Q_PROPERTY(QRectF margins READ margins NOTIFY marginsChanged)
+                Q_PROPERTY(QMargins minimumMargins READ minimumMargins WRITE setMinimumMargins)
                 Q_ENUMS(ChartTheme)
                 Q_ENUMS(AnimationOption)
                 QLegend* legend() const;
-                void setMarginsMinimum(const QRectF& margins);
+                void setMinimumMargins(const QMargins& margins);
-                QRectF margins() const;
+                QMargins minimumMargins() const;
                 QRectF plotArea() const;
             Q_SIGNALS:

src/qchartview.cpp +3 -6

             {
                 if(d_ptr->m_rubberBand && d_ptr->m_rubberBand->isEnabled() && event->button() == Qt::LeftButton) {
-                    int padding = d_ptr->m_chart->margins().top();
+                    QRectF plotArea = d_ptr->m_chart->plotArea();
-                    QRect rect(padding, padding, width() - 2 * padding, height() - 2 * padding);
-                    if (rect.contains(event->pos())) {
+                    if (plotArea.contains(event->pos())) {
                         d_ptr->m_rubberBandOrigin = event->pos();
                         d_ptr->m_rubberBand->setGeometry(QRect(d_ptr->m_rubberBandOrigin, QSize()));
                         d_ptr->m_rubberBand->show();
             void QChartView::mouseMoveEvent(QMouseEvent *event)
             {
                 if(d_ptr->m_rubberBand && d_ptr->m_rubberBand->isVisible()) {
-                    QRectF margins = d_ptr->m_chart->margins();
+                    QRectF rect = d_ptr->m_chart->plotArea();
-                    QRectF geometry = d_ptr->m_chart->geometry();
-                    QRectF rect =geometry.adjusted(margins.left(),margins.top(),-margins.right(),-margins.bottom());
                     int width = event->pos().x() - d_ptr->m_rubberBandOrigin.x();
                     int height = event->pos().y() - d_ptr->m_rubberBandOrigin.y();
                     if (!d_ptr->m_rubberBandFlags.testFlag(VerticalRubberBand)) {

tests/auto/qchart/tst_qchart.cpp +19 -13

                 void isBackgroundVisible();
                 void legend_data();
                 void legend();
-                void margins_data();
+                void plotArea_data();
-                void margins();
+                void plotArea();
                 void removeAllSeries_data();
                 void removeAllSeries();
                 void removeSeries_data();
                 QVERIFY(m_chart->backgroundBrush()!=QBrush());
                 QVERIFY(m_chart->backgroundPen()!=QPen());
                 QCOMPARE(m_chart->isBackgroundVisible(), true);
+                QVERIFY(m_chart->plotArea().top()==0);
-                QVERIFY(m_chart->margins().top()>0);
+                QVERIFY(m_chart->plotArea().left()==0);
-                QVERIFY(m_chart->margins().left()>0);
+                QVERIFY(m_chart->plotArea().right()==0);
-                QVERIFY(m_chart->margins().right()>0);
+                QVERIFY(m_chart->plotArea().bottom()==0);
-                QVERIFY(m_chart->margins().bottom()>0);
                 QCOMPARE(m_chart->theme(), QChart::ChartThemeLight);
                 QCOMPARE(m_chart->title(), QString());
                 m_chart->zoomIn();
                 m_chart->zoomIn(QRectF());
                 m_chart->zoomOut();
+                m_view->show();
+                QVERIFY(m_chart->plotArea().top()>0);
+                QVERIFY(m_chart->plotArea().left()>0);
+                QVERIFY(m_chart->plotArea().right()>0);
+                QVERIFY(m_chart->plotArea().bottom()>0);
             }
             void tst_QChart::addSeries_data()
                 QCOMPARE(fontSpy.count(), 1);
             }
-            void tst_QChart::margins_data()
+            void tst_QChart::plotArea_data()
             {
             }
-            void tst_QChart::margins()
+            void tst_QChart::plotArea()
             {
                 createTestData();
                 QRectF rect = m_chart->geometry();
-                QVERIFY(m_chart->margins().top()+m_chart->margins().bottom() < rect.height());
+                QVERIFY(m_chart->plotArea().isValid());
-                QVERIFY(m_chart->margins().left()+m_chart->margins().right() < rect.width());
+                QVERIFY(m_chart->plotArea().height() < rect.height());
+                QVERIFY(m_chart->plotArea().width() < rect.width());
             }
             void tst_QChart::removeAllSeries_data()
                 QFETCH(QRectF, rect);
                 createTestData();
                 m_chart->createDefaultAxes();
-                QRectF marigns = m_chart->margins();
+                QRectF marigns = m_chart->plotArea();
                 rect.adjust(marigns.left(),marigns.top(),-marigns.right(),-marigns.bottom());
                 QValueAxis* axisX = qobject_cast<QValueAxis*>(m_chart->axisX());
                 QVERIFY(axisX!=0);

tests/auto/qchartview/tst_qchartview.cpp +30 -25

                 QTest::addColumn<int>("Xcount");
                 QTest::addColumn<int>("Ycount");
-                QTest::addColumn<int>("minX");
+                QTest::addColumn<QPoint>("min");
-                QTest::addColumn<int>("maxX");
+                QTest::addColumn<QPoint>("max");
-                QTest::addColumn<int>("minY");
-                QTest::addColumn<int>("maxY");
+                QTest::newRow("HorizonalRubberBand") << QChartView::RubberBands(QChartView::HorizonalRubberBand) << 0 << 1 << QPoint(5,5) << QPoint(5,5);
+                QTest::newRow("VerticalRubberBand") <<  QChartView::RubberBands(QChartView::VerticalRubberBand) << 1 << 0 << QPoint(5,5) << QPoint(5,5);
-                QTest::newRow("HorizonalRubberBand") << QChartView::RubberBands(QChartView::HorizonalRubberBand) << 0 << 1 << 20 << 180 << 0<< 200;
+                QTest::newRow("RectangleRubberBand") <<  QChartView::RubberBands(QChartView::RectangleRubberBand) << 1 << 1 << QPoint(5,5) << QPoint(5,5);
-                QTest::newRow("VerticalRubberBand") <<  QChartView::RubberBands(QChartView::VerticalRubberBand) << 1 << 0 << 0 << 200 << 20<< 180;
-                QTest::newRow("RectangleRubberBand") <<  QChartView::RubberBands(QChartView::RectangleRubberBand) << 1 << 1 <<20 << 180 << 20<< 180;
             }
             void tst_QChartView::rubberBand()
                 QFETCH(QChartView::RubberBands, rubberBand);
                 QFETCH(int, Xcount);
                 QFETCH(int, Ycount);
-                QFETCH(int, minX);
+                QFETCH(QPoint, min);
-                QFETCH(int, maxX);
+                QFETCH(QPoint, max);
-                QFETCH(int, minY);
-                QFETCH(int, maxY);
                 m_view->setRubberBand(rubberBand);
-                QRectF padding = m_view->chart()->margins();
                 QCOMPARE(m_view->rubberBand(), rubberBand);
                 QLineSeries* line = new QLineSeries();
                 m_view->chart()->addSeries(line);
                 m_view->chart()->createDefaultAxes();
-                m_view->resize(200 + padding.left() + padding.right(), 200 +  padding.top()+ padding.bottom());
                 m_view->show();
+                QRectF plotArea = m_view->chart()->plotArea();
                 //this is hack since view does not get events otherwise
                 m_view->setMouseTracking(true);
                 QAbstractAxis* axisX = m_view->chart()->axisX();
                 QSignalSpy spy1(axisX, SIGNAL(rangeChanged(qreal,qreal)));
+                QValueAxis* vaxisX = qobject_cast<QValueAxis*>(axisX);
+                QValueAxis* vaxisY = qobject_cast<QValueAxis*>(axisY);
+                int minX = vaxisX->min();
+                int minY = vaxisY->min();
+                int maxX = vaxisX->max();
+                int maxY = vaxisY->max();
                 QTest::qWaitForWindowShown(m_view);
-                QTest::mouseMove(m_view->viewport(),  QPoint(minX, minY) + padding.topLeft().toPoint());
+                QTest::mouseMove(m_view->viewport(),  min + plotArea.topLeft().toPoint());
-                QTest::mousePress(m_view->viewport(), Qt::LeftButton, 0,  QPoint(minX, minY) + padding.topLeft().toPoint());
+                QTest::qWait(2000);
-                QTest::mouseMove(m_view->viewport(), QPoint(maxX, maxY) + padding.topLeft().toPoint());
+                QTest::mousePress(m_view->viewport(), Qt::LeftButton, 0,  min + plotArea.topLeft().toPoint());
-                QTest::mouseRelease(m_view->viewport(), Qt::LeftButton, 0, QPoint(maxX, maxY)+ padding.topLeft().toPoint());
+                QTest::qWait(2000);
+                QTest::mouseMove(m_view->viewport(),  plotArea.bottomRight().toPoint() - max);
+                QTest::qWait(2000);
+                QTest::mouseRelease(m_view->viewport(), Qt::LeftButton, 0, plotArea.bottomRight().toPoint() - max);
                 TRY_COMPARE(spy0.count(), Xcount);
                 TRY_COMPARE(spy1.count(), Ycount);
                 //this is hack since view does not get events otherwise
                 m_view->setMouseTracking(false);
-                QValueAxis* vaxisX = qobject_cast<QValueAxis*>(axisX);
+                QVERIFY(vaxisX->min() >= minX );
-                QValueAxis* vaxisY = qobject_cast<QValueAxis*>(axisY);
+                QVERIFY(vaxisX->max() <= maxX );
+                QVERIFY(vaxisY->min() >= minY );
-                QVERIFY(vaxisX->min() - minX < 1);
+                QVERIFY(vaxisY->max() <= maxY );
-                QVERIFY(vaxisX->max() - maxX < 1);
-                QVERIFY(vaxisY->min() - minY < 1);
-                QVERIFY(vaxisY->max() - maxY < 1);
             }

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