HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2133:8c175959daec

Updates axis drawing code...

Michal Klocek -

r2133:8c175959daec

parent child

Context file:

r2133:8c175959daec

Collapse all files

demos/chartviewer/charts/axis/barcategoryaxisx.cpp +4 -2

                     int count = series->barSets().first()->count();
-                    for (int i = 0; i < count; i++)
-                        barcategory->append(QString::number(i));
+                    for (int i = 0; i < count; i++) {
+                        barcategory->append("BarSet " + QString::number(i));
+                    }
                     chart->setAxisY(valueaxis, series);
                     chart->setAxisX(barcategory, series);

demos/chartviewer/charts/axis/barcategoryaxisy.cpp +3 -2

                     int count = series->barSets().first()->count();
-                    for (int i = 0; i < count; i++)
+                    for (int i = 0; i < count; i++) {
-                        barcategory->append(QString::number(i));
+                        barcategory->append("BarSet " + QString::number(i));
+                    }
                     chart->setAxisX(valueaxis, series);
                     chart->setAxisY(barcategory, series);

src/axis/barcategoryaxis/chartbarcategoryaxisx.cpp +18 -17

             QVector<qreal> ChartBarCategoryAxisX::calculateLayout() const
             {
-                int count = m_categoriesAxis->d_ptr->count();
-                Q_ASSERT(count >= 1);
                 QVector<qreal> points;
-                points.resize(count + 2);
                 const QRectF& gridRect = gridGeometry();
+                qreal range = max() - min();
+                const qreal delta = gridRect.width()/range;
+                if(delta<2) return points;
-                const qreal delta = gridRect.width() / (count);
                 qreal offset =-min()-0.5;
-                if (delta < 1)
+                offset = int(offset * delta)%int(delta);
-                    return points;
+                int count = qFloor(range);
-                if (offset < 0)
+                if(count < 1 ) return points;
-                    offset = int(offset * gridRect.width() / (max() - min())) % int(delta) + delta;
-                else
-                    offset = int(offset * gridRect.width() / (max() - min())) % int(delta);
-                for (int i = -1; i < count + 1; ++i) {
+                points.resize(count+2);
+                for (int i = 0; i < count+2; ++i) {
                     qreal x = offset + i * delta + gridRect.left();
-                    points[i + 1] = x;
+                    points[i] = x;
                 }
                 return points;
             }
                 QSizeF sh;
                 QSizeF base = ChartAxis::sizeHint(which, constraint);
                 QStringList ticksList = createCategoryLabels(ChartAxis::layout());
                 qreal width=0;
                 qreal height=0;
                         break;
                     case Qt::PreferredSize:{
-                    for (int i = 0; i < ticksList.size(); ++i) {
+                        for (int i = 0; i < ticksList.size(); ++i)
+                        {
                             QRectF rect = fn.boundingRect(ticksList.at(i));
                             width += rect.width();
-                        height = qMax(rect.height() + labelPadding(), height);
                         }
+                        height = fn.height()+labelPadding();
                         width = qMax(width,base.width());
                         height += base.height();
                         sh = QSizeF(width,height);
                     default:
                       break;
                   }
                   return sh;
             }

src/axis/barcategoryaxis/chartbarcategoryaxisy.cpp +5 -3

             #include "qbarcategoryaxis_p.h"
             #include <qmath.h>
             #include <QFontMetrics>
+            #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
                 QSizeF sh;
                 QSizeF base = ChartAxis::sizeHint(which, constraint);
                 QStringList ticksList = createCategoryLabels(ChartAxis::layout());
                 qreal width=0;
                 qreal height=0;
                         break;
                     case Qt::PreferredSize:{
-                    for (int i = 0; i < ticksList.size(); ++i) {
+                        for (int i = 0; i < ticksList.size(); ++i)
+                        {
                             QRectF rect = fn.boundingRect(ticksList.at(i));
                             height+=rect.height();
-                        width = qMax(rect.width() + labelPadding(), width);
+                            width=qMax(rect.width()+labelPadding() +1 ,width); //one pixel torelance
                         }
                         height=qMax(height,base.height());
                         width+=base.width();
                     default:
                       break;
                   }
                   return sh;
             }

src/axis/chartaxis.cpp +2 -3

                         QVector<qreal> layout = calculateLayout();
                         updateLayout(layout);
-                        QSizeF before = effectiveSizeHint(Qt::MinimumSize);
+                        QSizeF before = effectiveSizeHint(Qt::PreferredSize);
+                        QSizeF after = sizeHint(Qt::PreferredSize);
-                        QSizeF after = sizeHint(Qt::MinimumSize);
                         if (before != after) {
                             QGraphicsLayoutItem::updateGeometry();

src/axis/horizontalaxis.cpp +35 -13

             #include "horizontalaxis_p.h"
             #include "qabstractaxis.h"
             #include <QFontMetrics>
+            #include <qmath.h>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
                 if (layout.isEmpty())
                     return;
-                QStringList ticksList = labels();
+                QStringList labelList = labels();
                 QList<QGraphicsItem *> lines = lineItems();
                 QList<QGraphicsItem *> labels = labelItems();
                 QList<QGraphicsItem *> shades = shadeItems();
                 QList<QGraphicsItem *> axis = arrowItems();
-                Q_ASSERT(labels.size() == ticksList.size());
+                Q_ASSERT(labels.size() == labelList.size());
-                Q_ASSERT(layout.size() == ticksList.size());
+                Q_ASSERT(layout.size() == labelList.size());
                 const QRectF &axisRect = axisGeometry();
                 const QRectF &gridRect = gridGeometry();
                     arrowItem->setLine(gridRect.left(), axisRect.top(), gridRect.right(), axisRect.top());
                 qreal width = 0;
+                QFontMetrics fn(font());
                 for (int i = 0; i < layout.size(); ++i) {
+                    //items
                     QGraphicsLineItem *gridItem = static_cast<QGraphicsLineItem*>(lines.at(i));
                     QGraphicsLineItem *tickItem = static_cast<QGraphicsLineItem*>(axis.at(i + 1));
                     QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem *>(labels.at(i));
                     //grid line
                     gridItem->setLine(layout[i], gridRect.top(), layout[i], gridRect.bottom());
-                    //label text
+                    //label text wrapping
-                    labelItem->setText(ticksList.at(i));
+                    if(intervalAxis()&& i+1!=layout.size()) {
+                        //wrapping in case of interval axis
+                        const qreal delta = layout[i+1] - layout[i];
+                        QString text = labelList.at(i);
+                        if (fn.boundingRect(text).width() > delta )
+                        {
+                            QString label = text + "...";
+                            while (fn.boundingRect(label).width() > delta && label.length() > 3)
+                            label.remove(label.length() - 4, 1);
+                            labelItem->setText(label);
+                        }
+                        else {
+                            labelItem->setText(text);
+                        }
+                    }else{
+                        labelItem->setText(labelList.at(i));
+                    }
+                    //label transformation origin point
                     const QRectF& rect = labelItem->boundingRect();
                     QPointF center = rect.center();
                     labelItem->setTransformOriginPoint(center.x(), center.y());
                         tickItem->setLine(layout[i], axisRect.top(), layout[i], axisRect.top() + labelPadding());
                     }
+                    //label in beetwen
                     if(intervalAxis()&& i+1!=layout.size()) {
                         const qreal delta = (layout[i+1] - layout[i])/2;
                         labelItem->setPos(layout[i] + delta - center.x(), labelItem->pos().y());
                     }
-                    //overlap detection
+                    //label overlap detection
                     if(labelItem->pos().x() <= width ||
                         labelItem->pos().x() < axisRect.left() ||
                         labelItem->pos().x() + rect.width() > axisRect.right()) {
                         labelItem->setVisible(false);
-                        gridItem->setVisible(false);
-                        tickItem->setVisible(false);
+                    else {
-                    } else {
                         labelItem->setVisible(true);
-                        gridItem->setVisible(true);
-                        tickItem->setVisible(true);
                         width=rect.width()+labelItem->pos().x();
                     }
                     if (x < gridRect.left() || x > gridRect.right()) {
                         gridItem->setVisible(false);
                         tickItem->setVisible(false);
-                        if (intervalAxis() && (labelItem->pos().x() < gridRect.left() || labelItem->pos().x() + rect.width() > gridRect.right()))
+                    }else{
-                            labelItem->setVisible(false);
+                        gridItem->setVisible(true);
+                        tickItem->setVisible(true);
                     }
                 }
                     QGraphicsLineItem *gridLine;
                     gridLine = static_cast<QGraphicsLineItem *>(lines.at(layout.size()));
                     gridLine->setLine(gridRect.right(), gridRect.top(), gridRect.right(), gridRect.bottom());
+                    gridLine->setVisible(true);
                     gridLine = static_cast<QGraphicsLineItem*>(lines.at(layout.size()+1));
                     gridLine->setLine(gridRect.left(), gridRect.top(), gridRect.left(), gridRect.bottom());
+                    gridLine->setVisible(true);
                 }
             }

src/axis/valueaxis/chartvalueaxisx.cpp +3 -3

                 switch (which) {
                 case Qt::MinimumSize:{
                     int count = qMax(ticksList.last().count(),ticksList.first().count());
+                    count = qMin(count,5);
                     width = fn.averageCharWidth() * count;
                     height = fn.height() + labelPadding();
                     width = qMax(width,base.width());
                     break;
                 }
                 case Qt::PreferredSize:{
-                    for (int i = 0; i < ticksList.size(); ++i) {
+                    int count = qMax(ticksList.last().count(),ticksList.first().count());
-                        width += fn.averageCharWidth() * ticksList.at(i).count();
+                    width=fn.averageCharWidth() * count;
                     height=fn.height()+labelPadding();
                     width=qMax(width,base.width());
                     height+=base.height();

src/axis/valueaxis/chartvalueaxisy.cpp +9 -9

             #include <QGraphicsLayout>
             #include <QFontMetrics>
             #include <qmath.h>
+            #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
                 switch (which) {
                 case Qt::MinimumSize: {
-                    int count = qMax(ticksList.first().count() , ticksList.last().count());
+                    width = fn.boundingRect("...").width() + labelPadding();
-                    width = fn.averageCharWidth() * count + labelPadding();
+                    width += base.width();
                     height = fn.height();
                     height = qMax(height,base.height());
-                    width += base.width();
                     sh = QSizeF(width,height);
                     break;
                 }
-                case Qt::PreferredSize: {
+                case Qt::PreferredSize:
-                    for (int i = 0; i < ticksList.size(); ++i) {
-                        width = qMax(qreal(fn.averageCharWidth() * ticksList.at(i).count()) + labelPadding(), width);
+                    int count = qMax(ticksList.first().count() , ticksList.last().count());
-                        height += fn.height();
+                    width = count*fn.averageCharWidth() + labelPadding() + 2; //two pixels of tolerance
-                    height = qMax(height, base.height());
                     width += base.width();
+                    height = fn.height() * ticksList.count();
+                    height = qMax(height,base.height());
                     sh = QSizeF(width,height);
                     break;
                 }

src/axis/verticalaxis.cpp +24 -14

                 qreal height = axisRect.bottom();
-                QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem *>(axis.at(0));
+                //arrow
+                QGraphicsLineItem *arrowItem = static_cast<QGraphicsLineItem*>(axis.at(0));
+                //arrow position
                 if (alignment()==Qt::AlignLeft)
-                    lineItem->setLine(axisRect.right() , gridRect.top(), axisRect.right(), gridRect.bottom());
+                    arrowItem->setLine( axisRect.right() , gridRect.top(), axisRect.right(), gridRect.bottom());
                 else if(alignment()==Qt::AlignRight)
-                    lineItem->setLine(axisRect.left() , gridRect.top(), axisRect.left(), gridRect.bottom());
+                    arrowItem->setLine( axisRect.left() , gridRect.top(), axisRect.left(), gridRect.bottom());
                 QFontMetrics fn(font());
                 for (int i = 0; i < layout.size(); ++i) {
+                    //items
                     QGraphicsLineItem *gridItem = static_cast<QGraphicsLineItem *>(lines.at(i));
                     QGraphicsLineItem *tickItem = static_cast<QGraphicsLineItem *>(axis.at(i + 1));
                     QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem *>(labels.at(i));
                     //grid line
                     gridItem->setLine(gridRect.left() , layout[i], gridRect.right(), layout[i]);
-                    //label text
+                    //label text wrapping
                     QString text = labelList.at(i);
                     if (fn.boundingRect(text).width() > axisRect.right() - axisRect.left() - labelPadding()) {
                         QString label = text + "...";
                     } else {
                         labelItem->setText(text);
                     }
+                    //label transformation origin point
                     const QRectF &rect = labelItem->boundingRect();
                     QPointF center = rect.center();
                     labelItem->setTransformOriginPoint(center.x(), center.y());
                         labelItem->setPos(axisRect.left() + labelPadding() , layout[i] - center.y());
                         tickItem->setLine(axisRect.left(), layout[i], axisRect.left() + labelPadding(), layout[i]);
                     }
+                    //label in beetwen
                     if(intervalAxis()&& i+1!=layout.size()) {
                         const qreal delta = (layout[i+1] - layout[i])/2;
                         labelItem->setPos(labelItem->pos().x() , layout[i] + delta - center.y());
                     }
-                    //overlap detection
+                    //label overlap detection
                     if(labelItem->pos().y() + rect.height() > height ||
-                        labelItem->pos().y() + rect.height() > axisRect.bottom() ||
+                        labelItem->pos().y() + rect.height()/2 > gridRect.bottom() ||
-                        labelItem->pos().y() < axisRect.top()) {
+                        labelItem->pos().y() + rect.height()/2 < gridRect.top()) {
                         labelItem->setVisible(false);
-                        gridItem->setVisible(false);
-                        tickItem->setVisible(false);
+                    else {
-                    } else {
                         labelItem->setVisible(true);
-                        gridItem->setVisible(true);
                         height=labelItem->pos().y();
                     }
                     // check if the grid line and the axis tick should be shown
                     qreal y = gridItem->line().p1().y();
-                    if (y < gridRect.top() || y > gridRect.bottom()) {
+                    if ((y < gridRect.top() || y > gridRect.bottom()))
+                    {
                         gridItem->setVisible(false);
                         tickItem->setVisible(false);
-                        if (intervalAxis() && (labelItem->pos().y() < gridRect.top() || labelItem->pos().y() + rect.height() > gridRect.bottom()))
+                    }else{
-                            labelItem->setVisible(false);
+                        gridItem->setVisible(true);
+                        tickItem->setVisible(true);
                     }
                 }
                     QGraphicsLineItem *gridLine;
                     gridLine = static_cast<QGraphicsLineItem *>(lines.at(layout.size()));
                     gridLine->setLine(gridRect.left(), gridRect.top(), gridRect.right(), gridRect.top());
+                    gridLine->setVisible(true);
                     gridLine = static_cast<QGraphicsLineItem*>(lines.at(layout.size()+1));
                     gridLine->setLine(gridRect.left(), gridRect.bottom(), gridRect.right(), gridRect.bottom());
+                    gridLine->setVisible(true);
                 }
             }

src/chartlayout.cpp +39 -19

             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            static const qreal golden_ratio = 0.25;
+            static const qreal golden_ratio = 0.4;
             ChartLayout::ChartLayout(ChartPresenter *presenter)
                 : m_presenter(presenter),
             QRectF ChartLayout::calculateAxisGeometry(const QRectF &geometry, const QList<ChartAxis *>& axes) const
             {
-                QSizeF left;
+                QSizeF left(0,0);
-                QSizeF right;
+                QSizeF minLeft(0,0);
-                QSizeF bottom;
+                QSizeF right(0,0);
-                QSizeF top;
+                QSizeF minRight(0,0);
+                QSizeF bottom(0,0);
+                QSizeF minBottom(0,0);
+                QSizeF top(0,0);
+                QSizeF minTop(0,0);
                 int leftCount = 0;
                 int rightCount = 0;
                 int topCount = 0;
                     if (!axis->isVisible())
                         continue;
-                    QSizeF size = axis->effectiveSizeHint(Qt::MinimumSize);
+                    QSizeF size = axis->effectiveSizeHint(Qt::PreferredSize);
+                    //this is used to get single thick font size
+                    QSizeF minSize = axis->effectiveSizeHint(Qt::MinimumSize);
                     switch (axis->alignment()) {
                     case Qt::AlignLeft:
                        left.setWidth(left.width()+size.width());
                        left.setHeight(qMax(left.height(),size.height()));
+                       minLeft.setWidth(minLeft.width()+minSize.width());
+                       minLeft.setHeight(qMax(minLeft.height(),minSize.height()));
                        leftCount++;
                        break;
                     case Qt::AlignRight:
                         right.setWidth(right.width()+size.width());
                         right.setHeight(qMax(right.height(),size.height()));
+                        minRight.setWidth(minRight.width()+minSize.width());
+                        minRight.setHeight(qMax(minRight.height(),minSize.height()));
                         rightCount++;
                         break;
                     case Qt::AlignTop:
                         top.setWidth(qMax(top.width(),size.width()));
                         top.setHeight(top.height()+size.height());
+                        minTop.setWidth(qMax(minTop.width(),minSize.width()));
+                        minTop.setHeight(minTop.height()+minSize.height());
                         topCount++;
                         break;
                     case Qt::AlignBottom:
                         bottom.setWidth(qMax(bottom.width(), size.width()));
                         bottom.setHeight(bottom.height() + size.height());
+                        minBottom.setWidth(qMax(minBottom.width(),minSize.width()));
+                        minBottom.setHeight(minBottom.height() + minSize.height());
                         bottomCount++;
                         break;
                     }
                 }
-                left.setWidth(qMax(qMax(top.width() / 2, bottom.width() / 2), left.width()));
+                int horizontal = leftCount + rightCount;
-                left.setWidth(qMin(left.width(), golden_ratio * geometry.width()));
+                qreal hratio = 0 ;
-                right.setWidth(qMax(qMax(top.width() / 2, bottom.width() / 2), right.width()));
+                if(horizontal>0)
-                right.setWidth(qMin(right.width(), golden_ratio * geometry.width()));
+                    hratio = (golden_ratio*geometry.width())/horizontal;
-                top.setHeight(qMax(qMax(left.height() / 2, right.height() / 2), top.height()));
-                bottom.setHeight(qMax(qMax(left.height() / 2, right.height() / 2), bottom.height()));
+                if(leftCount>0)
+                    left.setWidth(qMin(left.width(),hratio*leftCount));
+                if(rightCount>0)
+                    right.setWidth(qMin(right.width(),hratio*rightCount));
-                QRectF chartRect = geometry.adjusted(left.width(), top.height(), -right.width(), -bottom.height());
+                qreal minHeight = qMax(minLeft.height(),minRight.height());
+                qreal minWidth = qMax(minTop.width(),minBottom.width());
+                QRectF chartRect = geometry.adjusted(qMax(left.width(),minWidth/2), qMax(top.height(), minHeight/2),-qMax(right.width(),minWidth/2),-qMax(bottom.height(),minHeight/2));
                 qreal leftOffset = 0;
                 qreal rightOffset = 0;
                     if (!axis->isVisible())
                         continue;
-                    QSizeF size = axis->effectiveSizeHint(Qt::MinimumSize);
+                    QSizeF size = axis->effectiveSizeHint(Qt::PreferredSize);
                     switch(axis->alignment()){
                     case Qt::AlignLeft:{
-                        qreal width = qMin(size.width(), left.width() / leftCount);
+                        qreal width =  qMin(size.width(),(left.width()/leftCount));
                         leftOffset+=width;
-                        axis->setGeometry(QRect(chartRect.left() - leftOffset, chartRect.top() - (size.height() + 1) / 2, width, chartRect.height() + size.height() + 2), chartRect);
+                        axis->setGeometry(QRect(chartRect.left()-leftOffset, geometry.top(),width, geometry.bottom()),chartRect);
                         break;
                     }
                     case Qt::AlignRight:{
-                        qreal width = qMin(size.width(), right.width() / rightCount);
+                        qreal width = qMin(size.width(),(right.width()/rightCount));
-                        axis->setGeometry(QRect(chartRect.right() + rightOffset, chartRect.top() - (size.height() + 1) / 2, width, chartRect.height() + size.height() + 2), chartRect);
+                        axis->setGeometry(QRect(chartRect.right()+rightOffset,geometry.top(),width,geometry.bottom()),chartRect);
                         rightOffset+=width;
                         break;
                     }
                 title->setGeometry(geometry);
                 QPointF center = geometry.center() - title->boundingRect().center();
                 title->setPos(center.x(),title->pos().y());
-                return geometry.adjusted(0, title->boundingRect().height(), 0, 0);
+                return geometry.adjusted(0,title->boundingRect().height()+1,0,0);
             }
             QRectF ChartLayout::calculateTitleMinimum(const QRectF &minimum, ChartTitle *title) const

src/charttitle.cpp +2 -2

                     sh = QSizeF(fn.boundingRect("...").width(), fn.height());
                     break;
                 case Qt::PreferredSize:
-                    sh = QSizeF(fn.boundingRect(m_text).width(), fn.height());
+                    sh = fn.boundingRect(m_text).size();
                     break;
                 case Qt::MaximumSize:
-                    sh = QSizeF(fn.boundingRect(m_text).width(), fn.height());
+                    sh = fn.boundingRect(m_text).size();
                     break;
                 case Qt::MinimumDescent:
                     sh = QSizeF(0, fn.descent());

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