HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2828:7557d1ea51b5

Fix label clipping issues using QOpenGLWidget as ChartView viewport...

Miikka Heikkinen -

r2828:7557d1ea51b5

parent child

Context file:

r2828:7557d1ea51b5

Collapse all files

src/charts/axis/horizontalaxis.cpp +12 -9

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include <private/horizontalaxis_p.h>
             #include <private/qabstractaxis_p.h>
             #include <private/chartpresenter_p.h>
             #include <QtCharts/QCategoryAxis>
             #include <QtCore/QtMath>
             #include <QtCore/QDebug>
             QT_CHARTS_BEGIN_NAMESPACE
             HorizontalAxis::HorizontalAxis(QAbstractAxis *axis, QGraphicsItem *item, bool intervalAxis)
                 : CartesianChartAxis(axis, item, intervalAxis)
             {
             }
             HorizontalAxis::~HorizontalAxis()
             {
             }
             void HorizontalAxis::updateGeometry()
             {
                 const QVector<qreal> &layout = ChartAxisElement::layout();
                 if (layout.isEmpty() && axis()->type() != QAbstractAxis::AxisTypeLogValue)
                     return;
                 QStringList labelList = labels();
                 QList<QGraphicsItem *> labels = labelItems();
                 QList<QGraphicsItem *> arrow = arrowItems();
                 QGraphicsTextItem *title = titleItem();
                 Q_ASSERT(labels.size() == labelList.size());
                 Q_ASSERT(layout.size() == labelList.size());
                 const QRectF &axisRect = axisGeometry();
                 const QRectF &gridRect = gridGeometry();
                 //arrow
                 QGraphicsLineItem *arrowItem = static_cast<QGraphicsLineItem *>(arrow.at(0));
                 if (axis()->alignment() == Qt::AlignTop)
                     arrowItem->setLine(gridRect.left(), axisRect.bottom(), gridRect.right(), axisRect.bottom());
                 else if (axis()->alignment() == Qt::AlignBottom)
                     arrowItem->setLine(gridRect.left(), axisRect.top(), gridRect.right(), axisRect.top());
                 qreal width = 0;
                 const QLatin1String ellipsis("...");
                 //title
                 QRectF titleBoundingRect;
                 QString titleText = axis()->titleText();
                 qreal availableSpace = axisRect.height() - labelPadding();
                 if (!titleText.isEmpty() && titleItem()->isVisible()) {
                     availableSpace -= titlePadding() * 2.0;
                     qreal minimumLabelHeight = ChartPresenter::textBoundingRect(axis()->labelsFont(),
                                                                                 QStringLiteral("...")).height();
                     qreal titleSpace = availableSpace - minimumLabelHeight;
                     title->setHtml(ChartPresenter::truncatedText(axis()->titleFont(), titleText, qreal(0.0),
                                                                  gridRect.width(), titleSpace,
                                                                  titleBoundingRect));
                     title->setTextWidth(titleBoundingRect.width());
                     titleBoundingRect = title->boundingRect();
                     QPointF center = gridRect.center() - titleBoundingRect.center();
                     if (axis()->alignment() == Qt::AlignTop)
                         title->setPos(center.x(), axisRect.top() + titlePadding());
                     else  if (axis()->alignment() == Qt::AlignBottom)
                         title->setPos(center.x(), axisRect.bottom() - titleBoundingRect.height() - titlePadding());
                     availableSpace -= titleBoundingRect.height();
                 }
                 if (layout.isEmpty() && axis()->type() == QAbstractAxis::AxisTypeLogValue)
                     return;
                 QList<QGraphicsItem *> lines = gridItems();
                 QList<QGraphicsItem *> shades = shadeItems();
                 QList<QGraphicsItem *> minorLines = minorGridItems();
                 QList<QGraphicsItem *> minorArrows = minorArrowItems();
                 for (int i = 0; i < layout.size(); ++i) {
                     //items
                     QGraphicsLineItem *gridItem = static_cast<QGraphicsLineItem*>(lines.at(i));
                     QGraphicsLineItem *tickItem = static_cast<QGraphicsLineItem*>(arrow.at(i + 1));
                     QGraphicsTextItem *labelItem = static_cast<QGraphicsTextItem *>(labels.at(i));
                     //grid line
                     if (axis()->isReverse()) {
                         gridItem->setLine(gridRect.right() - layout[i] + gridRect.left(), gridRect.top(),
                                 gridRect.right() - layout[i] + gridRect.left(), gridRect.bottom());
                     } else {
                         gridItem->setLine(layout[i], gridRect.top(), layout[i], gridRect.bottom());
                     }
                     //label text wrapping
                     QString text;
                     if (axis()->isReverse() && axis()->type() != QAbstractAxis::AxisTypeCategory)
                         text = labelList.at(labelList.count() - i - 1);
                     else
                         text = labelList.at(i);
                     QRectF boundingRect;
                     // don't truncate empty labels
                     if (text.isEmpty()) {
                         labelItem->setHtml(text);
                     } else  {
                         qreal labelWidth = axisRect.width() / layout.count() - (2 * labelPadding());
                         QString truncatedText = ChartPresenter::truncatedText(axis()->labelsFont(), text,
                                                                               axis()->labelsAngle(),
                                                                               labelWidth,
                                                                               availableSpace, boundingRect);
                         labelItem->setTextWidth(ChartPresenter::textBoundingRect(axis()->labelsFont(),
                                                                                  truncatedText).width());
                         labelItem->setHtml(truncatedText);
                     }
                     //label transformation origin point
                     const QRectF& rect = labelItem->boundingRect();
                     QPointF center = rect.center();
                     labelItem->setTransformOriginPoint(center.x(), center.y());
                     qreal heightDiff = rect.height() - boundingRect.height();
                     qreal widthDiff = rect.width() - boundingRect.width();
                     //ticks and label position
+                    QPointF labelPos;
                     if (axis()->alignment() == Qt::AlignTop) {
                         if (axis()->isReverse()) {
-                            labelItem->setPos(gridRect.right() - layout[layout.size() - i - 1]
+                            labelPos = QPointF(gridRect.right() - layout[layout.size() - i - 1]
                                     + gridRect.left() - center.x(),
                                     axisRect.bottom() - rect.height()
                                     + (heightDiff / 2.0) - labelPadding());
                             tickItem->setLine(gridRect.right() + gridRect.left() - layout[i],
                                               axisRect.bottom(),
                                               gridRect.right() + gridRect.left() - layout[i],
                                               axisRect.bottom() - labelPadding());
                         } else {
-                            labelItem->setPos(layout[i] - center.x(), axisRect.bottom() - rect.height()
+                            labelPos = QPointF(layout[i] - center.x(), axisRect.bottom() - rect.height()
                                               + (heightDiff / 2.0) - labelPadding());
                             tickItem->setLine(layout[i], axisRect.bottom(),
                                               layout[i], axisRect.bottom() - labelPadding());
                         }
                     } else if (axis()->alignment() == Qt::AlignBottom) {
                         if (axis()->isReverse()) {
-                            labelItem->setPos(gridRect.right() - layout[layout.size() - i - 1]
+                            labelPos = QPointF(gridRect.right() - layout[layout.size() - i - 1]
                                     + gridRect.left() - center.x(),
                                     axisRect.top() - (heightDiff / 2.0) + labelPadding());
                             tickItem->setLine(gridRect.right() + gridRect.left() - layout[i], axisRect.top(),
                                               gridRect.right() + gridRect.left() - layout[i],
                                               axisRect.top() + labelPadding());
                         } else {
-                            labelItem->setPos(layout[i] - center.x(), axisRect.top() - (heightDiff / 2.0)
+                            labelPos = QPointF(layout[i] - center.x(), axisRect.top() - (heightDiff / 2.0)
                                               + labelPadding());
                             tickItem->setLine(layout[i], axisRect.top(),
                                               layout[i], axisRect.top() + labelPadding());
                         }
                     }
                     //label in between
                     bool forceHide = false;
                     if (intervalAxis() && (i + 1) != layout.size()) {
                         qreal leftBound;
                         qreal rightBound;
                         if (axis()->isReverse()) {
                             leftBound = qMax(gridRect.right() + gridRect.left() - layout[i + 1],
                                     gridRect.left());
                             rightBound = qMin(gridRect.right() + gridRect.left() - layout[i], gridRect.right());
                         } else {
                             leftBound = qMax(layout[i], gridRect.left());
                             rightBound = qMin(layout[i + 1], gridRect.right());
                         }
                         const qreal delta = rightBound - leftBound;
                         if (axis()->type() != QAbstractAxis::AxisTypeCategory) {
                             // Hide label in case visible part of the category at the grid edge is too narrow
                             if (delta < boundingRect.width()
                                 && (leftBound == gridRect.left() || rightBound == gridRect.right())) {
                                 forceHide = true;
                             } else {
-                                labelItem->setPos(leftBound + (delta / 2.0) - center.x(), labelItem->pos().y());
+                                labelPos.setX(leftBound + (delta / 2.0) - center.x());
                             }
                         } else {
                             QCategoryAxis *categoryAxis = static_cast<QCategoryAxis *>(axis());
                             if (categoryAxis->labelsPosition() == QCategoryAxis::AxisLabelsPositionCenter) {
                                 if (delta < boundingRect.width()
                                     && (leftBound == gridRect.left() || rightBound == gridRect.right())) {
                                     forceHide = true;
                                 } else {
-                                    labelItem->setPos(leftBound + (delta / 2.0) - center.x(),
+                                    labelPos.setX(leftBound + (delta / 2.0) - center.x());
-                                                      labelItem->pos().y());
                                 }
                             } else if (categoryAxis->labelsPosition()
                                        == QCategoryAxis::AxisLabelsPositionOnValue) {
                                 if (axis()->isReverse())
-                                    labelItem->setPos(leftBound - center.x(), labelItem->pos().y());
+                                    labelPos.setX(leftBound - center.x());
                                 else
-                                    labelItem->setPos(rightBound - center.x(), labelItem->pos().y());
+                                    labelPos.setX(rightBound - center.x());
                             }
                         }
                     }
+                    // Round to full pixel via QPoint to avoid one pixel clipping on the edge in some cases
+                    labelItem->setPos(labelPos.toPoint());
                     //label overlap detection - compensate one pixel for rounding errors
                     if ((labelItem->pos().x() < width && labelItem->toPlainText() == ellipsis) || forceHide ||
                         (labelItem->pos().x() + (widthDiff / 2.0)) < (axisRect.left() - 1.0) ||
                         (labelItem->pos().x() + (widthDiff / 2.0) - 1.0) > axisRect.right()) {
                         labelItem->setVisible(false);
                     } else {
                         labelItem->setVisible(true);
                         width = boundingRect.width() + labelItem->pos().x();
                     }
                     //shades
                     QGraphicsRectItem *shadeItem = 0;
                     if (i == 0)
                         shadeItem = static_cast<QGraphicsRectItem *>(shades.at(0));
                     else if (i % 2)
                         shadeItem = static_cast<QGraphicsRectItem *>(shades.at((i / 2) + 1));
                     if (shadeItem) {
                         qreal leftBound;
                         qreal rightBound;
                         if (i == 0) {
                             if (axis()->isReverse()) {
                                 leftBound = gridRect.right() + gridRect.left() - layout[i];
                                 rightBound = gridRect.right();
                             } else {
                                 leftBound = gridRect.left();
                                 rightBound = layout[0];
                             }
                         } else {
                             if (axis()->isReverse()) {
                                 rightBound = gridRect.right() + gridRect.left() - layout[i];
                                 if (i == layout.size() - 1) {
                                     leftBound = gridRect.left();
                                 } else {
                                     leftBound = qMax(gridRect.right() + gridRect.left() - layout[i + 1],
                                             gridRect.left());
                                 }
                             } else {
                                 leftBound = layout[i];
                                 if (i == layout.size() - 1)
                                     rightBound = gridRect.right();
                                 else
                                     rightBound = qMin(layout[i + 1], gridRect.right());
                             }
                         }
                         if (leftBound < gridRect.left())
                             leftBound = gridRect.left();
                         if (rightBound > gridRect.right())
                             rightBound = gridRect.right();
                         shadeItem->setRect(leftBound, gridRect.top(), rightBound - leftBound,
                                            gridRect.height());
                         if (shadeItem->rect().width() <= 0.0)
                             shadeItem->setVisible(false);
                         else
                             shadeItem->setVisible(true);
                     }
                     // check if the grid line and the axis tick should be shown
                     qreal x = gridItem->line().p1().x();
                     if (x < gridRect.left() || x > gridRect.right()) {
                         gridItem->setVisible(false);
                         tickItem->setVisible(false);
                     } else {
                         gridItem->setVisible(true);
                         tickItem->setVisible(true);
                     }
                     // add minor ticks
                     QValueAxis *valueAxis = qobject_cast<QValueAxis *>(axis());
                     if ((i + 1) != layout.size() && valueAxis) {
                         int minorTickCount = valueAxis->minorTickCount();
                         if (minorTickCount != 0) {
                             qreal minorTickDistance = (layout[i] - layout[i + 1]) / qreal(minorTickCount + 1);
                             for (int j = 0; j < minorTickCount; j++) {
                                 QGraphicsLineItem *minorGridItem =
                                     static_cast<QGraphicsLineItem *>(minorLines.at(i * minorTickCount + j));
                                 QGraphicsLineItem *minorArrowItem =
                                     static_cast<QGraphicsLineItem *>(minorArrows.at(i * minorTickCount + j));
                                 if (i == 0) {
                                     minorGridItem->setLine(gridRect.left() - minorTickDistance * qreal(j + 1),
                                                            gridRect.top(),
                                                            gridRect.left() - minorTickDistance * qreal(j + 1),
                                                            gridRect.bottom());
                                 } else {
                                     minorGridItem->setLine(gridItem->line().p1().x()
                                                            - minorTickDistance * qreal(j + 1),
                                                            gridRect.top(),
                                                            gridItem->line().p1().x()
                                                            - minorTickDistance * qreal(j + 1),
                                                            gridRect.bottom());
                                 }
                                 if (axis()->alignment() == Qt::AlignTop) {
                                     minorArrowItem->setLine(minorGridItem->line().p1().x(),
                                                             axisRect.bottom(),
                                                             minorGridItem->line().p1().x(),
                                                             axisRect.bottom() - labelPadding() / 2);
                                 } else if (axis()->alignment() == Qt::AlignBottom){
                                     minorArrowItem->setLine(minorGridItem->line().p1().x(),
                                                             axisRect.top(),
                                                             minorGridItem->line().p1().x(),
                                                             axisRect.top() + labelPadding() / 2);
                                 }
                                 // check if the minor grid line and the axis tick should be shown
                                 qreal minorXPos = minorGridItem->line().p1().x();
                                 if (minorXPos < gridRect.left() || minorXPos > gridRect.right()) {
                                     minorGridItem->setVisible(false);
                                     minorArrowItem->setVisible(false);
                                 } else {
                                     minorGridItem->setVisible(true);
                                     minorArrowItem->setVisible(true);
                                 }
                             }
                         }
                     }
                 }
                 //begin/end grid line in case labels between
                 if (intervalAxis()) {
                     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);
                 }
             }
             QSizeF HorizontalAxis::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(constraint);
                 QSizeF sh(0,0);
                 if (axis()->titleText().isEmpty() || !titleItem()->isVisible())
                     return sh;
                 switch (which) {
                 case Qt::MinimumSize: {
                     QRectF titleRect = ChartPresenter::textBoundingRect(axis()->titleFont(),
                                                                         QStringLiteral("..."));
                     sh = QSizeF(titleRect.width(), titleRect.height() + (titlePadding() * 2.0));
                     break;
                 }
                 case Qt::MaximumSize:
                 case Qt::PreferredSize: {
                     QRectF titleRect = ChartPresenter::textBoundingRect(axis()->titleFont(), axis()->titleText());
                     sh = QSizeF(titleRect.width(), titleRect.height() + (titlePadding() * 2.0));
                     break;
                 }
                 default:
                     break;
                 }
                 return sh;
             }
             QT_CHARTS_END_NAMESPACE

src/charts/axis/verticalaxis.cpp +12 -10

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include <private/verticalaxis_p.h>
             #include <QtCharts/QAbstractAxis>
             #include <private/chartpresenter_p.h>
             #include <QtCharts/QCategoryAxis>
             #include <QtCore/QDebug>
             QT_CHARTS_BEGIN_NAMESPACE
             VerticalAxis::VerticalAxis(QAbstractAxis *axis, QGraphicsItem *item, bool intervalAxis)
                 : CartesianChartAxis(axis, item, intervalAxis)
             {
             }
             VerticalAxis::~VerticalAxis()
             {
             }
             void VerticalAxis::updateGeometry()
             {
                 const QVector<qreal> &layout = ChartAxisElement::layout();
                 if (layout.isEmpty() && axis()->type() != QAbstractAxis::AxisTypeLogValue)
                     return;
                 QStringList labelList = labels();
                 QList<QGraphicsItem *> labels = labelItems();
                 QList<QGraphicsItem *> arrow = arrowItems();
                 QGraphicsTextItem *title = titleItem();
                 Q_ASSERT(labels.size() == labelList.size());
                 Q_ASSERT(layout.size() == labelList.size());
                 const QRectF &axisRect = axisGeometry();
                 const QRectF &gridRect = gridGeometry();
                 qreal height = axisRect.bottom();
                 //arrow
                 QGraphicsLineItem *arrowItem = static_cast<QGraphicsLineItem*>(arrow.at(0));
                 //arrow position
                 if (axis()->alignment() == Qt::AlignLeft)
                     arrowItem->setLine(axisRect.right(), gridRect.top(), axisRect.right(), gridRect.bottom());
                 else if (axis()->alignment() == Qt::AlignRight)
                     arrowItem->setLine(axisRect.left(), gridRect.top(), axisRect.left(), gridRect.bottom());
                 //title
                 QRectF titleBoundingRect;
                 QString titleText = axis()->titleText();
                 qreal availableSpace = axisRect.width() - labelPadding();
                 if (!titleText.isEmpty() && titleItem()->isVisible()) {
                     availableSpace -= titlePadding() * 2.0;
                     qreal minimumLabelWidth = ChartPresenter::textBoundingRect(axis()->labelsFont(),
                                                                                QStringLiteral("...")).width();
                     qreal titleSpace = availableSpace - minimumLabelWidth;
                     title->setHtml(ChartPresenter::truncatedText(axis()->titleFont(), titleText, qreal(90.0),
                                                                  titleSpace, gridRect.height(),
                                                                  titleBoundingRect));
                     title->setTextWidth(titleBoundingRect.height());
                     titleBoundingRect = title->boundingRect();
                     QPointF center = gridRect.center() - titleBoundingRect.center();
                     if (axis()->alignment() == Qt::AlignLeft)
                         title->setPos(axisRect.left() - titleBoundingRect.width() / 2.0 + titleBoundingRect.height() / 2.0 + titlePadding(), center.y());
                     else if (axis()->alignment() == Qt::AlignRight)
                         title->setPos(axisRect.right() - titleBoundingRect.width() / 2.0 - titleBoundingRect.height() / 2.0 - titlePadding(), center.y());
                     title->setTransformOriginPoint(titleBoundingRect.center());
                     title->setRotation(270);
                     availableSpace -= titleBoundingRect.height();
                 }
                 if (layout.isEmpty() && axis()->type() == QAbstractAxis::AxisTypeLogValue)
                     return;
                 QList<QGraphicsItem *> lines = gridItems();
                 QList<QGraphicsItem *> shades = shadeItems();
                 QList<QGraphicsItem *> minorLines = minorGridItems();
                 QList<QGraphicsItem *> minorArrows = minorArrowItems();
                 for (int i = 0; i < layout.size(); ++i) {
                     //items
                     QGraphicsLineItem *gridItem = static_cast<QGraphicsLineItem *>(lines.at(i));
                     QGraphicsLineItem *tickItem = static_cast<QGraphicsLineItem *>(arrow.at(i + 1));
                     QGraphicsTextItem *labelItem = static_cast<QGraphicsTextItem *>(labels.at(i));
                     //grid line
                     if (axis()->isReverse()) {
                         gridItem->setLine(gridRect.left(), gridRect.top() + gridRect.bottom() - layout[i],
                                           gridRect.right(), gridRect.top() + gridRect.bottom() - layout[i]);
                     } else {
                         gridItem->setLine(gridRect.left(), layout[i], gridRect.right(), layout[i]);
                     }
                     //label text wrapping
                     QString text;
                     if (axis()->isReverse() && axis()->type() != QAbstractAxis::AxisTypeCategory)
                         text = labelList.at(labelList.count() - i - 1);
                     else
                         text = labelList.at(i);
                     QRectF boundingRect;
                     // don't truncate empty labels
                     if (text.isEmpty()) {
                         labelItem->setHtml(text);
                     } else {
                         qreal labelHeight = (axisRect.height() / layout.count()) - (2 * labelPadding());
                         QString truncatedText = ChartPresenter::truncatedText(axis()->labelsFont(), text,
                                                                               axis()->labelsAngle(),
                                                                               availableSpace,
                                                                               labelHeight, boundingRect);
                         labelItem->setTextWidth(ChartPresenter::textBoundingRect(axis()->labelsFont(),
                                                                                  truncatedText).width());
                         labelItem->setHtml(truncatedText);
                     }
                     //label transformation origin point
                     const QRectF &rect = labelItem->boundingRect();
                     QPointF center = rect.center();
                     labelItem->setTransformOriginPoint(center.x(), center.y());
                     qreal widthDiff = rect.width() - boundingRect.width();
                     qreal heightDiff = rect.height() - boundingRect.height();
                     //ticks and label position
+                    QPointF labelPos;
                     if (axis()->alignment() == Qt::AlignLeft) {
                         if (axis()->isReverse()) {
-                            labelItem->setPos(axisRect.right() - rect.width() + (widthDiff / 2.0)
+                            labelPos = QPointF(axisRect.right() - rect.width() + (widthDiff / 2.0)
                                               - labelPadding(),
                                               gridRect.top() + gridRect.bottom()
                                               - layout[layout.size() - i - 1] - center.y());
                             tickItem->setLine(axisRect.right() - labelPadding(),
                                               gridRect.top() + gridRect.bottom() - layout[i],
                                               axisRect.right(),
                                               gridRect.top() + gridRect.bottom() - layout[i]);
                         } else {
-                            labelItem->setPos(axisRect.right() - rect.width() + (widthDiff / 2.0)
+                            labelPos = QPointF(axisRect.right() - rect.width() + (widthDiff / 2.0)
                                               - labelPadding(),
                                               layout[i] - center.y());
                             tickItem->setLine(axisRect.right() - labelPadding(), layout[i],
                                               axisRect.right(), layout[i]);
                         }
                     } else if (axis()->alignment() == Qt::AlignRight) {
                         if (axis()->isReverse()) {
                             tickItem->setLine(axisRect.left(),
                                               gridRect.top() + gridRect.bottom() - layout[i],
                                               axisRect.left() + labelPadding(),
                                               gridRect.top() + gridRect.bottom() - layout[i]);
-                            labelItem->setPos(axisRect.left() + labelPadding() - (widthDiff / 2.0),
+                            labelPos = QPointF(axisRect.left() + labelPadding() - (widthDiff / 2.0),
                                               gridRect.top() + gridRect.bottom()
                                               - layout[layout.size() - i - 1] - center.y());
                         } else {
-                            labelItem->setPos(axisRect.left() + labelPadding() - (widthDiff / 2.0),
+                            labelPos = QPointF(axisRect.left() + labelPadding() - (widthDiff / 2.0),
                                               layout[i] - center.y());
                             tickItem->setLine(axisRect.left(), layout[i],
                                               axisRect.left() + labelPadding(), layout[i]);
                         }
                     }
                     //label in between
                     bool forceHide = false;
                     bool labelOnValue = false;
                     if (intervalAxis() && (i + 1) != layout.size()) {
                         qreal lowerBound;
                         qreal upperBound;
                         if (axis()->isReverse()) {
                             lowerBound = qMax(gridRect.top() + gridRect.bottom() - layout[i + 1],
                                     gridRect.top());
                             upperBound = qMin(gridRect.top() + gridRect.bottom() - layout[i],
                                               gridRect.bottom());
                         } else {
                             lowerBound = qMin(layout[i], gridRect.bottom());
                             upperBound = qMax(layout[i + 1], gridRect.top());
                         }
                         const qreal delta = lowerBound - upperBound;
                         if (axis()->type() != QAbstractAxis::AxisTypeCategory) {
                             // Hide label in case visible part of the category at the grid edge is too narrow
                             if (delta < boundingRect.height()
                                 && (lowerBound == gridRect.bottom() || upperBound == gridRect.top())) {
                                 forceHide = true;
                             } else {
-                                labelItem->setPos(labelItem->pos().x(),
+                                labelPos.setY(lowerBound - (delta / 2.0) - center.y());
-                                                  lowerBound - (delta / 2.0) - center.y());
                             }
                         } else {
                             QCategoryAxis *categoryAxis = static_cast<QCategoryAxis *>(axis());
                             if (categoryAxis->labelsPosition() == QCategoryAxis::AxisLabelsPositionCenter) {
                                 if (delta < boundingRect.height()
                                     && (lowerBound == gridRect.bottom() || upperBound == gridRect.top())) {
                                     forceHide = true;
                                 } else {
-                                    labelItem->setPos(labelItem->pos().x(),
+                                    labelPos.setY(lowerBound - (delta / 2.0) - center.y());
-                                                      lowerBound - (delta / 2.0) - center.y());
                                 }
                             } else if (categoryAxis->labelsPosition()
                                        == QCategoryAxis::AxisLabelsPositionOnValue) {
                                 labelOnValue = true;
                                 if (axis()->isReverse()) {
-                                    labelItem->setPos(labelItem->pos().x(), gridRect.top() + gridRect.bottom()
+                                    labelPos.setY(gridRect.top() + gridRect.bottom()
                                                       - layout[i + 1] - center.y());
                                 } else {
-                                    labelItem->setPos(labelItem->pos().x(), upperBound - center.y());
+                                    labelPos.setY(upperBound - center.y());
                                 }
                             }
                         }
                     }
+                    // Round to full pixel via QPoint to avoid one pixel clipping on the edge in some cases
+                    labelItem->setPos(labelPos.toPoint());
                     //label overlap detection - compensate one pixel for rounding errors
                     if (axis()->isReverse()) {
                         if (forceHide)
                             labelItem->setVisible(false);
                     } else if (labelItem->pos().y() + boundingRect.height() > height || forceHide ||
                         ((labelItem->pos().y() + (heightDiff / 2.0) - 1.0) > axisRect.bottom()
                          && !labelOnValue) ||
                         (labelItem->pos().y() + (heightDiff / 2.0) < (axisRect.top() - 1.0) && !labelOnValue)) {
                         labelItem->setVisible(false);
                     }
                     else {
                         labelItem->setVisible(true);
                         height=labelItem->pos().y();
                     }
                     //shades
                     QGraphicsRectItem *shadeItem = 0;
                     if (i == 0)
                         shadeItem = static_cast<QGraphicsRectItem *>(shades.at(0));
                     else if (i % 2)
                         shadeItem = static_cast<QGraphicsRectItem *>(shades.at((i / 2) + 1));
                     if (shadeItem) {
                         qreal lowerBound;
                         qreal upperBound;
                         if (i == 0) {
                             if (axis()->isReverse()) {
                                 upperBound = gridRect.top();
                                 lowerBound = gridRect.top() + gridRect.bottom() - layout[i];
                             } else {
                                 lowerBound = gridRect.bottom();
                                 upperBound = layout[0];
                             }
                         } else {
                             if (axis()->isReverse()) {
                                     upperBound = gridRect.top() + gridRect.bottom() - layout[i];
                                 if (i == layout.size() - 1) {
                                     lowerBound = gridRect.bottom();
                                 } else {
                                     lowerBound = qMax(gridRect.top() + gridRect.bottom() - layout[i + 1],
                                             gridRect.top());
                                 }
                             } else {
                                 lowerBound = layout[i];
                                 if (i == layout.size() - 1)
                                     upperBound = gridRect.top();
                                 else
                                     upperBound = qMax(layout[i + 1], gridRect.top());
                             }
                         }
                         if (lowerBound > gridRect.bottom())
                             lowerBound = gridRect.bottom();
                         if (upperBound < gridRect.top())
                             upperBound = gridRect.top();
                         shadeItem->setRect(gridRect.left(), upperBound, gridRect.width(),
                                            lowerBound - upperBound);
                         if (shadeItem->rect().height() <= 0.0)
                             shadeItem->setVisible(false);
                         else
                             shadeItem->setVisible(true);
                     }
                     // 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()))
                     {
                         gridItem->setVisible(false);
                         tickItem->setVisible(false);
                     }else{
                         gridItem->setVisible(true);
                         tickItem->setVisible(true);
                     }
                     // add minor ticks
                     QValueAxis *valueAxis = qobject_cast<QValueAxis *>(axis());
                     if ((i + 1) != layout.size() && valueAxis) {
                         int minorTickCount = valueAxis->minorTickCount();
                         if (minorTickCount != 0) {
                             qreal minorTickDistance = (layout[i] - layout[i + 1]) / qreal(minorTickCount + 1);
                             for (int j = 0; j < minorTickCount; j++) {
                                 QGraphicsLineItem *minorGridItem =
                                     static_cast<QGraphicsLineItem *>(minorLines.at(i * minorTickCount + j));
                                 QGraphicsLineItem *minorArrowItem =
                                     static_cast<QGraphicsLineItem *>(minorArrows.at(i * minorTickCount + j));
                                 if (i == 0) {
                                     minorGridItem->setLine(gridRect.left(),
                                                            gridRect.bottom() - minorTickDistance * qreal(j + 1),
                                                            gridRect.right(),
                                                            gridRect.bottom() - minorTickDistance * qreal(j + 1));
                                 } else {
                                     minorGridItem->setLine(gridRect.left(),
                                                            gridItem->line().p1().y()
                                                            - minorTickDistance * qreal(j + 1),
                                                            gridRect.right(),
                                                            gridItem->line().p1().y()
                                                            - minorTickDistance * qreal(j + 1));
                                 }
                                 if (axis()->alignment() == Qt::AlignLeft) {
                                     minorArrowItem->setLine(gridRect.left() - labelPadding() / 2,
                                                             minorGridItem->line().p1().y(),
                                                             gridRect.left(),
                                                             minorGridItem->line().p1().y());
                                 } else if (axis()->alignment() == Qt::AlignRight){
                                     minorArrowItem->setLine(gridRect.right(),
                                                             minorGridItem->line().p1().y(),
                                                             gridRect.right() + labelPadding() / 2,
                                                             minorGridItem->line().p1().y());
                                 }
                                 // check if the minor grid line and the axis tick should be shown
                                 qreal minorYPos = minorGridItem->line().p1().y();
                                 if (minorYPos < gridRect.top() || minorYPos > gridRect.bottom()) {
                                     minorGridItem->setVisible(false);
                                     minorArrowItem->setVisible(false);
                                 } else {
                                     minorGridItem->setVisible(true);
                                     minorArrowItem->setVisible(true);
                                 }
                             }
                         }
                     }
                 }
                 //begin/end grid line in case labels between
                 if (intervalAxis()) {
                     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);
                 }
             }
             QSizeF VerticalAxis::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(constraint);
                 QSizeF sh(0, 0);
                 if (axis()->titleText().isEmpty() || !titleItem()->isVisible())
                     return sh;
                 switch (which) {
                 case Qt::MinimumSize: {
                     QRectF titleRect = ChartPresenter::textBoundingRect(axis()->titleFont(),
                                                                         QStringLiteral("..."));
                     sh = QSizeF(titleRect.height() + (titlePadding() * 2.0), titleRect.width());
                     break;
                 }
                 case Qt::MaximumSize:
                 case Qt::PreferredSize: {
                     QRectF titleRect = ChartPresenter::textBoundingRect(axis()->titleFont(), axis()->titleText());
                     sh = QSizeF(titleRect.height() + (titlePadding() * 2.0), titleRect.width());
                     break;
                 }
                 default:
                     break;
                 }
                 return sh;
             }
             QT_CHARTS_END_NAMESPACE

src/charts/layout/abstractchartlayout.cpp +3 -1

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include <private/abstractchartlayout_p.h>
             #include <private/chartpresenter_p.h>
             #include <private/qlegend_p.h>
             #include <private/chartaxiselement_p.h>
             #include <private/charttitle_p.h>
             #include <private/chartbackground_p.h>
             #include <QtCore/QDebug>
             QT_CHARTS_BEGIN_NAMESPACE
             static const qreal golden_ratio = 0.4;
             AbstractChartLayout::AbstractChartLayout(ChartPresenter *presenter)
                 : m_presenter(presenter),
                   m_margins(20, 20, 20, 20),
                   m_minChartRect(0, 0, 200, 200)
             {
             }
             AbstractChartLayout::~AbstractChartLayout()
             {
             }
             void AbstractChartLayout::setGeometry(const QRectF &rect)
             {
                 if (!rect.isValid())
                     return;
                 if (m_presenter->chart()->isVisible()) {
                     QList<ChartAxisElement *> axes = m_presenter->axisItems();
                     ChartTitle *title = m_presenter->titleElement();
                     QLegend *legend = m_presenter->legend();
                     ChartBackground *background = m_presenter->backgroundElement();
                     QRectF contentGeometry = calculateBackgroundGeometry(rect, background);
                     contentGeometry = calculateContentGeometry(contentGeometry);
                     if (title && title->isVisible() && !title->text().isEmpty())
                         contentGeometry = calculateTitleGeometry(contentGeometry, title);
                     if (legend->isAttachedToChart() && legend->isVisible())
                         contentGeometry = calculateLegendGeometry(contentGeometry, legend);
                     contentGeometry = calculateAxisGeometry(contentGeometry, axes);
                     m_presenter->setGeometry(contentGeometry);
                     if (m_presenter->chart()->chartType() == QChart::ChartTypeCartesian)
                         static_cast<QGraphicsRectItem *>(m_presenter->plotAreaElement())->setRect(contentGeometry);
                     else
                         static_cast<QGraphicsEllipseItem *>(m_presenter->plotAreaElement())->setRect(contentGeometry);
                 }
                 QGraphicsLayout::setGeometry(rect);
             }
             QRectF AbstractChartLayout::calculateContentGeometry(const QRectF &geometry) const
             {
                 return geometry.adjusted(m_margins.left(), m_margins.top(), -m_margins.right(), -m_margins.bottom());
             }
             QRectF AbstractChartLayout::calculateContentMinimum(const QRectF &minimum) const
             {
                 return  minimum.adjusted(0, 0, m_margins.left() + m_margins.right(), m_margins.top() + m_margins.bottom());
             }
             QRectF AbstractChartLayout::calculateBackgroundGeometry(const QRectF &geometry, ChartBackground *background) const
             {
                 qreal left;
                 qreal top;
                 qreal right;
                 qreal bottom;
                 getContentsMargins(&left, &top, &right, &bottom);
                 QRectF backgroundGeometry = geometry.adjusted(left, top, -right, -bottom);
                 if (background)
                     background->setRect(backgroundGeometry);
                 return backgroundGeometry;
             }
             QRectF AbstractChartLayout::calculateBackgroundMinimum(const QRectF &minimum) const
             {
                 qreal left;
                 qreal top;
                 qreal right;
                 qreal bottom;
                 getContentsMargins(&left, &top, &right, &bottom);
                 return minimum.adjusted(0, 0, left + right, top + bottom);
             }
             QRectF AbstractChartLayout::calculateLegendGeometry(const QRectF &geometry, QLegend *legend) const
             {
                 QSizeF size = legend->effectiveSizeHint(Qt::PreferredSize, QSizeF(-1, -1));
                 QRectF legendRect;
                 QRectF result;
                 switch (legend->alignment()) {
                 case Qt::AlignTop: {
                     legendRect = QRectF(geometry.topLeft(), QSizeF(geometry.width(), size.height()));
                     result = geometry.adjusted(0, legendRect.height(), 0, 0);
                     break;
                 }
                 case Qt::AlignBottom: {
                     legendRect = QRectF(QPointF(geometry.left(), geometry.bottom() - size.height()), QSizeF(geometry.width(), size.height()));
                     result = geometry.adjusted(0, 0, 0, -legendRect.height());
                     break;
                 }
                 case Qt::AlignLeft: {
                     qreal width = qMin(size.width(), geometry.width() * golden_ratio);
                     legendRect = QRectF(geometry.topLeft(), QSizeF(width, geometry.height()));
                     result = geometry.adjusted(width, 0, 0, 0);
                     break;
                 }
                 case Qt::AlignRight: {
                     qreal width = qMin(size.width(), geometry.width() * golden_ratio);
                     legendRect = QRectF(QPointF(geometry.right() - width, geometry.top()), QSizeF(width, geometry.height()));
                     result = geometry.adjusted(0, 0, -width, 0);
                     break;
                 }
                 default: {
                     legendRect = QRectF(0, 0, 0, 0);
                     result = geometry;
                     break;
                 }
                 }
                 legend->setGeometry(legendRect);
                 return result;
             }
             QRectF AbstractChartLayout::calculateLegendMinimum(const QRectF &geometry, QLegend *legend) const
             {
                 QSizeF minSize = legend->effectiveSizeHint(Qt::MinimumSize, QSizeF(-1, -1));
                 return geometry.adjusted(0, 0, minSize.width(), minSize.height());
             }
             QRectF AbstractChartLayout::calculateTitleGeometry(const QRectF &geometry, ChartTitle *title) const
             {
                 title->setGeometry(geometry);
-                QPointF center = geometry.center() - title->boundingRect().center();
+                // Round to full pixel via QPoint to avoid one pixel clipping on the edge in some cases
+                QPointF center((geometry.center() - title->boundingRect().center()).toPoint());
                 title->setPos(center.x(), title->pos().y());
                 return geometry.adjusted(0, title->boundingRect().height()+1, 0, 0);
             }
             QRectF AbstractChartLayout::calculateTitleMinimum(const QRectF &minimum, ChartTitle *title) const
             {
                 QSizeF min = title->sizeHint(Qt::MinimumSize);
                 return  minimum.adjusted(0, 0, min.width(), min.height());
             }
             QSizeF AbstractChartLayout::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(constraint);
                 if (which == Qt::MinimumSize) {
                     QList<ChartAxisElement *> axes = m_presenter->axisItems();
                     ChartTitle *title = m_presenter->titleElement();
                     QLegend *legend = m_presenter->legend();
                     QRectF minimumRect(0, 0, 0, 0);
                     minimumRect = calculateBackgroundMinimum(minimumRect);
                     minimumRect = calculateContentMinimum(minimumRect);
                     minimumRect = calculateTitleMinimum(minimumRect, title);
                     minimumRect = calculateLegendMinimum(minimumRect, legend);
                     minimumRect = calculateAxisMinimum(minimumRect, axes);
                     return  minimumRect.united(m_minChartRect).size().toSize();
                 }
                 return QSize(-1, -1);
             }
             void AbstractChartLayout::setMargins(const QMargins &margins)
             {
                 if (m_margins != margins) {
                     m_margins = margins;
                     updateGeometry();
                 }
             }
             QMargins AbstractChartLayout::margins() const
             {
                 return m_margins;
             }
             QT_CHARTS_END_NAMESPACE

src/charts/legend/legendlayout.cpp +14 -8

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include <private/legendlayout_p.h>
             #include <private/chartpresenter_p.h>
             #include <private/qlegend_p.h>
             #include <private/abstractchartlayout_p.h>
             #include <private/qlegendmarker_p.h>
             #include <private/legendmarkeritem_p.h>
             #include <QtCharts/QLegendMarker>
             QT_CHARTS_BEGIN_NAMESPACE
             LegendLayout::LegendLayout(QLegend *legend)
                 : m_legend(legend),
                   m_offsetX(0),
                   m_offsetY(0)
             {
             }
             LegendLayout::~LegendLayout()
             {
             }
             void LegendLayout::setOffset(qreal x, qreal y)
             {
                 bool scrollHorizontal = true;
                 switch (m_legend->alignment()) {
                 case Qt::AlignTop:
                 case Qt::AlignBottom:
                     scrollHorizontal = true;
                     break;
                 case Qt::AlignLeft:
                 case Qt::AlignRight:
                     scrollHorizontal = false;
                     break;
                 }
                 // If detached, the scrolling direction is vertical instead of horizontal and vice versa.
                 if (!m_legend->isAttachedToChart())
                     scrollHorizontal = !scrollHorizontal;
                 QRectF boundingRect = geometry();
                 qreal left, top, right, bottom;
                 getContentsMargins(&left, &top, &right, &bottom);
                 boundingRect.adjust(left, top, -right, -bottom);
                 // Limit offset between m_minOffset and m_maxOffset
                 if (scrollHorizontal) {
                     if (m_width <= boundingRect.width())
                         return;
                     if (x != m_offsetX) {
                         m_offsetX = qBound(m_minOffsetX, x, m_maxOffsetX);
                         m_legend->d_ptr->items()->setPos(-m_offsetX, boundingRect.top());
                     }
                 } else {
                     if (m_height <= boundingRect.height())
                         return;
                     if (y != m_offsetY) {
                         m_offsetY = qBound(m_minOffsetY, y, m_maxOffsetY);
                         m_legend->d_ptr->items()->setPos(boundingRect.left(), -m_offsetY);
                     }
                 }
             }
             QPointF LegendLayout::offset() const
             {
                 return QPointF(m_offsetX, m_offsetY);
             }
             void LegendLayout::invalidate()
             {
                 QGraphicsLayout::invalidate();
                 if (m_legend->isAttachedToChart())
                     m_legend->d_ptr->m_presenter->layout()->invalidate();
             }
             void LegendLayout::setGeometry(const QRectF &rect)
             {
                 m_legend->d_ptr->items()->setVisible(m_legend->isVisible());
                 QGraphicsLayout::setGeometry(rect);
                 if (m_legend->isAttachedToChart())
                     setAttachedGeometry(rect);
                 else
                     setDettachedGeometry(rect);
             }
             void LegendLayout::setAttachedGeometry(const QRectF &rect)
             {
                 if (!rect.isValid())
                     return;
                 qreal oldOffsetX = m_offsetX;
                 qreal oldOffsetY = m_offsetY;
                 m_offsetX = 0;
                 m_offsetY = 0;
                 QSizeF size(0, 0);
                 if (m_legend->d_ptr->markers().isEmpty()) {
                     return;
                 }
                 m_width = 0;
                 m_height = 0;
                 qreal left, top, right, bottom;
                 getContentsMargins(&left, &top, &right, &bottom);
                 QRectF geometry = rect.adjusted(left, top, -right, -bottom);
                 switch(m_legend->alignment()) {
                 case Qt::AlignTop:
                 case Qt::AlignBottom: {
                         // Calculate the space required for items and add them to a sorted list.
                         qreal markerItemsWidth = 0;
                         qreal itemMargins = 0;
                         QList<LegendWidthStruct *> legendWidthList;
                         foreach (QLegendMarker *marker, m_legend->d_ptr->markers()) {
                             LegendMarkerItem *item = marker->d_ptr->item();
                             if (item->isVisible()) {
                                 QSizeF dummySize;
                                 qreal itemWidth = item->sizeHint(Qt::PreferredSize, dummySize).width();
                                 LegendWidthStruct *structItem = new LegendWidthStruct;
                                 structItem->item = item;
                                 structItem->width = itemWidth;
                                 legendWidthList.append(structItem);
                                 markerItemsWidth += itemWidth;
                                 itemMargins += marker->d_ptr->item()->m_margin;
                             }
                         }
                         std::sort(legendWidthList.begin(), legendWidthList.end(), widthLongerThan);
                         // If the items would occupy more space than is available, start truncating them
                         // from the longest one.
                         qreal availableGeometry = geometry.width() - right - left * 2 - itemMargins;
                         if (markerItemsWidth >= availableGeometry && legendWidthList.count() > 0) {
                             bool truncated(false);
                             int count = legendWidthList.count();
                             for (int i = 1; i < count; i++) {
                                 int truncateIndex = i - 1;
                                 while (legendWidthList.at(truncateIndex)->width >= legendWidthList.at(i)->width
                                        && !truncated) {
                                     legendWidthList.at(truncateIndex)->width--;
                                     markerItemsWidth--;
                                     if (i > 1) {
                                         // Truncate the items that are before the truncated one in the list.
                                         for (int j = truncateIndex - 1; j >= 0; j--) {
                                             if (legendWidthList.at(truncateIndex)->width
                                                     < legendWidthList.at(j)->width) {
                                                 legendWidthList.at(j)->width--;
                                                 markerItemsWidth--;
                                             }
                                         }
                                     }
                                     if (markerItemsWidth < availableGeometry)
                                         truncated = true;
                                 }
                                 // Truncate the last item if needed.
                                 if (i == count - 1) {
                                     if (legendWidthList.at(count - 1)->width
                                             > legendWidthList.at(truncateIndex)->width) {
                                         legendWidthList.at(count - 1)->width--;
                                         markerItemsWidth--;
                                     }
                                 }
                                 if (truncated)
                                     break;
                             }
                             // Items are of same width and all of them need to be truncated
                             // or there is just one item that is truncated.
                             while (markerItemsWidth >= availableGeometry) {
                                 for (int i = 0; i < count; i++) {
                                     legendWidthList.at(i)->width--;
                                     markerItemsWidth--;
                                 }
                             }
                         }
                         QPointF point(0,0);
                         int markerCount = m_legend->d_ptr->markers().count();
                         for (int i = 0; i < markerCount; i++) {
                             QLegendMarker *marker;
                             if (m_legend->d_ptr->m_reverseMarkers)
                                 marker = m_legend->d_ptr->markers().at(markerCount - 1 - i);
                             else
                                 marker = m_legend->d_ptr->markers().at(i);
                             LegendMarkerItem *item = marker->d_ptr->item();
                             if (item->isVisible()) {
                                 QRectF itemRect = geometry;
                                 qreal availableWidth = 0;
                                 for (int i = 0; i < legendWidthList.size(); ++i) {
                                     if (legendWidthList.at(i)->item == item) {
                                         availableWidth = legendWidthList.at(i)->width;
                                         break;
                                     }
                                 }
                                 itemRect.setWidth(availableWidth);
                                 item->setGeometry(itemRect);
                                 item->setPos(point.x(),geometry.height()/2 - item->boundingRect().height()/2);
                                 const QRectF &rect = item->boundingRect();
                                 size = size.expandedTo(rect.size());
                                 qreal w = rect.width();
                                 m_width = m_width + w - item->m_margin;
                                 point.setX(point.x() + w);
                             }
                         }
                         // Delete structs from the container
                         qDeleteAll(legendWidthList);
-                        if (m_width < geometry.width())
+                        // Round to full pixel via QPoint to avoid one pixel clipping on the edge in some cases
-                            m_legend->d_ptr->items()->setPos(geometry.width() / 2 - m_width / 2, geometry.top());
+                        if (m_width < geometry.width()) {
-                        else
+                            m_legend->d_ptr->items()->setPos(QPoint(geometry.width() / 2 - m_width / 2,
-                            m_legend->d_ptr->items()->setPos(geometry.topLeft());
+                                                                    geometry.top()));
+                        } else {
+                            m_legend->d_ptr->items()->setPos(geometry.topLeft().toPoint());
+                        }
                         m_height = size.height();
                     }
                     break;
                 case Qt::AlignLeft:
                 case Qt::AlignRight: {
                         QPointF point(0,0);
                         int markerCount = m_legend->d_ptr->markers().count();
                         for (int i = 0; i < markerCount; i++) {
                             QLegendMarker *marker;
                             if (m_legend->d_ptr->m_reverseMarkers)
                                 marker = m_legend->d_ptr->markers().at(markerCount - 1 - i);
                             else
                                 marker = m_legend->d_ptr->markers().at(i);
                             LegendMarkerItem *item = marker->d_ptr->item();
                             if (item->isVisible()) {
                                 item->setGeometry(geometry);
                                 item->setPos(point);
                                 const QRectF &rect = item->boundingRect();
                                 qreal h = rect.height();
                                 size = size.expandedTo(rect.size());
                                 m_height+=h;
                                 point.setY(point.y() + h);
                             }
                         }
-                        if (m_height < geometry.height())
+                        // Round to full pixel via QPoint to avoid one pixel clipping on the edge in some cases
-                            m_legend->d_ptr->items()->setPos(geometry.left(), geometry.height() / 2 - m_height / 2);
+                        if (m_height < geometry.height()) {
-                        else
+                            m_legend->d_ptr->items()->setPos(QPoint(geometry.left(),
-                            m_legend->d_ptr->items()->setPos(geometry.topLeft());
+                                                                    geometry.height() / 2 - m_height / 2));
+                        } else {
+                            m_legend->d_ptr->items()->setPos(geometry.topLeft().toPoint());
+                        }
                         m_width = size.width();
                         break;
                         }
                     }
                 m_minOffsetX = -left;
                 m_minOffsetY = - top;
                 m_maxOffsetX = m_width - geometry.width() - right;
                 m_maxOffsetY = m_height - geometry.height() - bottom;
                 setOffset(oldOffsetX, oldOffsetY);
             }
             void LegendLayout::setDettachedGeometry(const QRectF &rect)
             {
                 if (!rect.isValid())
                     return;
                 // Detached layout is different.
                 // In detached mode legend may have multiple rows and columns, so layout calculations
                 // differ a log from attached mode.
                 // Also the scrolling logic is bit different.
                 qreal oldOffsetX = m_offsetX;
                 qreal oldOffsetY = m_offsetY;
                 m_offsetX = 0;
                 m_offsetY = 0;
                 qreal left, top, right, bottom;
                 getContentsMargins(&left, &top, &right, &bottom);
                 QRectF geometry = rect.adjusted(left, top, -right, -bottom);
                 QSizeF size(0, 0);
                 QList<QLegendMarker *> markers = m_legend->d_ptr->markers();
                 if (markers.isEmpty())
                     return;
                 switch (m_legend->alignment()) {
                 case Qt::AlignTop: {
                     QPointF point(0, 0);
                     m_width = 0;
                     m_height = 0;
                     for (int i = 0; i < markers.count(); i++) {
                         LegendMarkerItem *item = markers.at(i)->d_ptr->item();
                         if (item->isVisible()) {
                             item->setGeometry(geometry);
                             item->setPos(point.x(),point.y());
                             const QRectF &boundingRect = item->boundingRect();
                             qreal w = boundingRect.width();
                             qreal h = boundingRect.height();
                             m_width = qMax(m_width,w);
                             m_height = qMax(m_height,h);
                             point.setX(point.x() + w);
                             if (point.x() + w > geometry.left() + geometry.width() - right) {
                                 // Next item would go off rect.
                                 point.setX(0);
                                 point.setY(point.y() + h);
                                 if (i+1 < markers.count()) {
                                     m_height += h;
                                 }
                             }
                         }
                     }
                     m_legend->d_ptr->items()->setPos(geometry.topLeft());
                     m_minOffsetX = -left;
                     m_minOffsetY = -top;
                     m_maxOffsetX = m_width - geometry.width() - right;
                     m_maxOffsetY = m_height - geometry.height() - bottom;
                 }
                 break;
                 case Qt::AlignBottom: {
                     QPointF point(0, geometry.height());
                     m_width = 0;
                     m_height = 0;
                     for (int i = 0; i < markers.count(); i++) {
                         LegendMarkerItem *item = markers.at(i)->d_ptr->item();
                         if (item->isVisible()) {
                             item->setGeometry(geometry);
                             const QRectF &boundingRect = item->boundingRect();
                             qreal w = boundingRect.width();
                             qreal h = boundingRect.height();
                             m_width = qMax(m_width,w);
                             m_height = qMax(m_height,h);
                             item->setPos(point.x(),point.y() - h);
                             point.setX(point.x() + w);
                             if (point.x() + w > geometry.left() + geometry.width() - right) {
                                 // Next item would go off rect.
                                 point.setX(0);
                                 point.setY(point.y() - h);
                                 if (i+1 < markers.count()) {
                                     m_height += h;
                                 }
                             }
                         }
                     }
                     m_legend->d_ptr->items()->setPos(geometry.topLeft());
                     m_minOffsetX = -left;
                     m_minOffsetY = -m_height + geometry.height() - top;
                     m_maxOffsetX = m_width - geometry.width() - right;
                     m_maxOffsetY = -bottom;
                 }
                 break;
                 case Qt::AlignLeft: {
                     QPointF point(0, 0);
                     m_width = 0;
                     m_height = 0;
                     qreal maxWidth = 0;
                     for (int i = 0; i < markers.count(); i++) {
                         LegendMarkerItem *item = markers.at(i)->d_ptr->item();
                         if (item->isVisible()) {
                             item->setGeometry(geometry);
                             const QRectF &boundingRect = item->boundingRect();
                             qreal w = boundingRect.width();
                             qreal h = boundingRect.height();
                             m_height = qMax(m_height,h);
                             maxWidth = qMax(maxWidth,w);
                             item->setPos(point.x(),point.y());
                             point.setY(point.y() + h);
                             if (point.y() + h > geometry.bottom() - bottom) {
                                 // Next item would go off rect.
                                 point.setX(point.x() + maxWidth);
                                 point.setY(0);
                                 if (i+1 < markers.count()) {
                                     m_width += maxWidth;
                                     maxWidth = 0;
                                 }
                             }
                         }
                     }
                     m_width += maxWidth;
                     m_legend->d_ptr->items()->setPos(geometry.topLeft());
                     m_minOffsetX = -left;
                     m_minOffsetY = -top;
                     m_maxOffsetX = m_width - geometry.width() - right;
                     m_maxOffsetY = m_height - geometry.height() - bottom;
                 }
                 break;
                 case Qt::AlignRight: {
                     QPointF point(geometry.width(), 0);
                     m_width = 0;
                     m_height = 0;
                     qreal maxWidth = 0;
                     for (int i = 0; i < markers.count(); i++) {
                         LegendMarkerItem *item = markers.at(i)->d_ptr->item();
                         if (item->isVisible()) {
                             item->setGeometry(geometry);
                             const QRectF &boundingRect = item->boundingRect();
                             qreal w = boundingRect.width();
                             qreal h = boundingRect.height();
                             m_height = qMax(m_height,h);
                             maxWidth = qMax(maxWidth,w);
                             item->setPos(point.x() - w,point.y());
                             point.setY(point.y() + h);
                             if (point.y() + h > geometry.bottom()-bottom) {
                                 // Next item would go off rect.
                                 point.setX(point.x() - maxWidth);
                                 point.setY(0);
                                 if (i+1 < markers.count()) {
                                     m_width += maxWidth;
                                     maxWidth = 0;
                                 }
                             }
                         }
                     }
                     m_width += maxWidth;
                     m_legend->d_ptr->items()->setPos(geometry.topLeft());
                     m_minOffsetX = - m_width + geometry.width() - left;
                     m_minOffsetY = -top;
                     m_maxOffsetX = - right;
                     m_maxOffsetY = m_height - geometry.height() - bottom;
                 }
                 break;
                 default:
                     break;
                 }
                 setOffset(oldOffsetX, oldOffsetY);
             }
             QSizeF LegendLayout::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 QSizeF size(0, 0);
                 qreal left, top, right, bottom;
                 getContentsMargins(&left, &top, &right, &bottom);
                 if(constraint.isValid()) {
                     foreach(QLegendMarker *marker, m_legend->d_ptr->markers()) {
                         LegendMarkerItem *item = marker->d_ptr->item();
                         size = size.expandedTo(item->effectiveSizeHint(which));
                     }
                     size = size.boundedTo(constraint);
                 }
                 else if (constraint.width() >= 0) {
                     qreal width = 0;
                     qreal height = 0;
                     foreach(QLegendMarker *marker, m_legend->d_ptr->markers()) {
                         LegendMarkerItem *item = marker->d_ptr->item();
                         width+=item->effectiveSizeHint(which).width();
                         height=qMax(height,item->effectiveSizeHint(which).height());
                     }
                     size = QSizeF(qMin(constraint.width(),width), height);
                 }
                 else if (constraint.height() >= 0) {
                     qreal width = 0;
                     qreal height = 0;
                     foreach(QLegendMarker *marker, m_legend->d_ptr->markers()) {
                         LegendMarkerItem *item = marker->d_ptr->item();
                         width=qMax(width,item->effectiveSizeHint(which).width());
                         height+=height,item->effectiveSizeHint(which).height();
                     }
                     size = QSizeF(width,qMin(constraint.height(),height));
                 }
                 else {
                     foreach(QLegendMarker *marker, m_legend->d_ptr->markers()) {
                         LegendMarkerItem *item = marker->d_ptr->item();
                         size = size.expandedTo(item->effectiveSizeHint(which));
                     }
                 }
                 size += QSize(left + right, top + bottom);
                 return size;
             }
             bool LegendLayout::widthLongerThan(const LegendWidthStruct *item1,
                                                const LegendWidthStruct *item2)
             {
                 return item1->width > item2->width;
             }
             QT_CHARTS_END_NAMESPACE

tests/manual/chartviewer/chartviewer.pro 0 -1

             !include( ../../tests.pri ) {
                 error( "Couldn't find the test.pri file!" )
             }
             include(charts/charts.pri)
             TARGET = chartviewer
-            QT += opengl
             INCLUDEPATH += .
             SOURCES += main.cpp window.cpp view.cpp grid.cpp
             HEADERS += window.h view.h charts.h model.h grid.h

tests/manual/chartviewer/window.cpp +3 -3

             /****************************************************************************
              **
              ** Copyright (C) 2015 The Qt Company Ltd
              ** All rights reserved.
              ** For any questions to The Qt Company, please use contact form at http://qt.io
              **
              ** This file is part of the Qt Charts module.
              **
              ** Licensees holding valid commercial license for Qt may use this file in
              ** accordance with the Qt License Agreement provided with the Software
              ** or, alternatively, in accordance with the terms contained in a written
              ** agreement between you and The Qt Company.
              **
              ** If you have questions regarding the use of this file, please use
              ** contact form at http://qt.io
              **
              ****************************************************************************/
             #include "window.h"
             #include "view.h"
             #include "grid.h"
             #include "charts.h"
             #include <QtCharts/QChartView>
             #include <QtCharts/QAreaSeries>
             #include <QtCharts/QLegend>
             #include <QtCharts/QValueAxis>
             #include <QtWidgets/QGridLayout>
             #include <QtWidgets/QFormLayout>
             #include <QtWidgets/QComboBox>
             #include <QtWidgets/QSpinBox>
             #include <QtWidgets/QCheckBox>
             #include <QtWidgets/QGroupBox>
             #include <QtWidgets/QLabel>
             #include <QtWidgets/QGraphicsScene>
             #include <QtWidgets/QGraphicsLinearLayout>
             #include <QtWidgets/QGraphicsProxyWidget>
-            #include <QtOpenGL/QGLWidget>
+            #include <QtWidgets/QOpenGLWidget>
             #include <QtWidgets/QApplication>
             #include <QtCore/QDebug>
             #include <QtWidgets/QMenu>
             #include <QtWidgets/QPushButton>
             Window::Window(const QVariantHash &parameters, QWidget *parent)
                 : QMainWindow(parent),
                   m_scene(new QGraphicsScene(this)),
                   m_view(0),
                   m_form(0),
                   m_themeComboBox(0),
                   m_antialiasCheckBox(0),
                   m_animatedComboBox(0),
                   m_legendComboBox(0),
                   m_templateComboBox(0),
                   m_viewComboBox(0),
                   m_xTickSpinBox(0),
                   m_yTickSpinBox(0),
                   m_minorXTickSpinBox(0),
                   m_minorYTickSpinBox(0),
                   m_openGLCheckBox(0),
                   m_zoomCheckBox(0),
                   m_scrollCheckBox(0),
                   m_baseLayout(new QGraphicsLinearLayout()),
                   m_menu(createMenu()),
                   m_template(0),
                   m_grid(new Grid(-1))
             {
                 createProxyWidgets();
                 // create layout
                 QGraphicsLinearLayout *settingsLayout = new QGraphicsLinearLayout();
                 settingsLayout->setOrientation(Qt::Vertical);
                 settingsLayout->setSizePolicy(QSizePolicy::Maximum, QSizePolicy::Maximum);
                 settingsLayout->addItem(m_widgetHash["openGLCheckBox"]);
                 settingsLayout->addItem(m_widgetHash["antialiasCheckBox"]);
                 settingsLayout->addItem(m_widgetHash["viewLabel"]);
                 settingsLayout->addItem(m_widgetHash["viewComboBox"]);
                 settingsLayout->addItem(m_widgetHash["themeLabel"]);
                 settingsLayout->addItem(m_widgetHash["themeComboBox"]);
                 settingsLayout->addItem(m_widgetHash["animationsLabel"]);
                 settingsLayout->addItem(m_widgetHash["animatedComboBox"]);
                 settingsLayout->addItem(m_widgetHash["legendLabel"]);
                 settingsLayout->addItem(m_widgetHash["legendComboBox"]);
                 settingsLayout->addItem(m_widgetHash["templateLabel"]);
                 settingsLayout->addItem(m_widgetHash["templateComboBox"]);
                 settingsLayout->addItem(m_widgetHash["scrollCheckBox"]);
                 settingsLayout->addItem(m_widgetHash["zoomCheckBox"]);
                 settingsLayout->addItem(m_widgetHash["xTickLabel"]);
                 settingsLayout->addItem(m_widgetHash["xTickSpinBox"]);
                 settingsLayout->addItem(m_widgetHash["yTickLabel"]);
                 settingsLayout->addItem(m_widgetHash["yTickSpinBox"]);
                 settingsLayout->addItem(m_widgetHash["minorXTickLabel"]);
                 settingsLayout->addItem(m_widgetHash["minorXTickSpinBox"]);
                 settingsLayout->addItem(m_widgetHash["minorYTickLabel"]);
                 settingsLayout->addItem(m_widgetHash["minorYTickSpinBox"]);
                 settingsLayout->addStretch();
                 m_baseLayout->setOrientation(Qt::Horizontal);
                 m_baseLayout->addItem(m_grid);
                 m_baseLayout->addItem(settingsLayout);
                 m_form = new QGraphicsWidget();
                 m_form->setLayout(m_baseLayout);
                 m_scene->addItem(m_form);
                 m_view = new View(m_scene, m_form);
                 m_view->setMinimumSize(m_form->minimumSize().toSize());
                 // Set defaults
                 m_antialiasCheckBox->setChecked(true);
                 initializeFromParamaters(parameters);
                 updateUI();
                 if(!m_category.isEmpty() && !m_subcategory.isEmpty() && !m_name.isEmpty())
                     m_grid->createCharts(m_category,m_subcategory,m_name);
                 handleGeometryChanged();
                 setCentralWidget(m_view);
                 connectSignals();
             }
             Window::~Window()
             {
             }
             void Window::connectSignals()
             {
                 QObject::connect(m_form, SIGNAL(geometryChanged()), this , SLOT(handleGeometryChanged()));
                 QObject::connect(m_viewComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(updateUI()));
                 QObject::connect(m_themeComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(updateUI()));
                 QObject::connect(m_xTickSpinBox, SIGNAL(valueChanged(int)), this, SLOT(updateUI()));
                 QObject::connect(m_yTickSpinBox, SIGNAL(valueChanged(int)), this, SLOT(updateUI()));
                 QObject::connect(m_minorXTickSpinBox, SIGNAL(valueChanged(int)), this, SLOT(updateUI()));
                 QObject::connect(m_minorYTickSpinBox, SIGNAL(valueChanged(int)), this, SLOT(updateUI()));
                 QObject::connect(m_antialiasCheckBox, SIGNAL(toggled(bool)), this, SLOT(updateUI()));
                 QObject::connect(m_openGLCheckBox, SIGNAL(toggled(bool)), this, SLOT(updateUI()));
                 QObject::connect(m_zoomCheckBox, SIGNAL(toggled(bool)), this, SLOT(updateUI()));
                 QObject::connect(m_scrollCheckBox, SIGNAL(toggled(bool)), this, SLOT(updateUI()));
                 QObject::connect(m_animatedComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(updateUI()));
                 QObject::connect(m_legendComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(updateUI()));
                 QObject::connect(m_templateComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(updateUI()));
                 QObject::connect(m_grid, SIGNAL(chartSelected(QChart*)), this, SLOT(handleChartSelected(QChart*)));
             }
             void Window::createProxyWidgets()
             {
                 m_themeComboBox = createThemeBox();
                 m_viewComboBox = createViewBox();
                 m_xTickSpinBox = new QSpinBox();
                 m_xTickSpinBox->setMinimum(2);
                 m_xTickSpinBox->setValue(5);
                 m_yTickSpinBox = new QSpinBox();
                 m_yTickSpinBox->setMinimum(2);
                 m_yTickSpinBox->setValue(5);
                 m_minorXTickSpinBox = new QSpinBox();
                 m_minorYTickSpinBox = new QSpinBox();
                 m_antialiasCheckBox = new QCheckBox(tr("Anti-aliasing"));
                 m_animatedComboBox = createAnimationBox();
                 m_legendComboBox = createLegendBox();
                 m_openGLCheckBox = new QCheckBox(tr("OpenGL"));
                 m_zoomCheckBox = new QCheckBox(tr("Zoom"));
                 m_scrollCheckBox = new QCheckBox(tr("Scroll"));
                 m_templateComboBox = createTempleteBox();
                 m_widgetHash["viewLabel"] = m_scene->addWidget(new QLabel("View"));
                 m_widgetHash["viewComboBox"] = m_scene->addWidget(m_viewComboBox);
                 m_widgetHash["themeComboBox"] = m_scene->addWidget(m_themeComboBox);
                 m_widgetHash["antialiasCheckBox"] = m_scene->addWidget(m_antialiasCheckBox);
                 m_widgetHash["animatedComboBox"] = m_scene->addWidget(m_animatedComboBox);
                 m_widgetHash["legendComboBox"] = m_scene->addWidget(m_legendComboBox);
                 m_widgetHash["xTickLabel"] = m_scene->addWidget(new QLabel("X Tick"));
                 m_widgetHash["xTickSpinBox"] = m_scene->addWidget(m_xTickSpinBox);
                 m_widgetHash["yTickLabel"] = m_scene->addWidget(new QLabel("Y Tick"));
                 m_widgetHash["yTickSpinBox"] = m_scene->addWidget(m_yTickSpinBox);
                 m_widgetHash["minorXTickLabel"] = m_scene->addWidget(new QLabel("Minor X Tick"));
                 m_widgetHash["minorXTickSpinBox"] = m_scene->addWidget(m_minorXTickSpinBox);
                 m_widgetHash["minorYTickLabel"] = m_scene->addWidget(new QLabel("Minor Y Tick"));
                 m_widgetHash["minorYTickSpinBox"] = m_scene->addWidget(m_minorYTickSpinBox);
                 m_widgetHash["openGLCheckBox"] = m_scene->addWidget(m_openGLCheckBox);
                 m_widgetHash["themeLabel"] = m_scene->addWidget(new QLabel("Theme"));
                 m_widgetHash["animationsLabel"] = m_scene->addWidget(new QLabel("Animations"));
                 m_widgetHash["legendLabel"] = m_scene->addWidget(new QLabel("Legend"));
                 m_widgetHash["templateLabel"] = m_scene->addWidget(new QLabel("Chart template"));
                 m_widgetHash["templateComboBox"] = m_scene->addWidget(m_templateComboBox);
                 m_widgetHash["zoomCheckBox"] = m_scene->addWidget(m_zoomCheckBox);
                 m_widgetHash["scrollCheckBox"] = m_scene->addWidget(m_scrollCheckBox);
             }
             QComboBox *Window::createThemeBox()
             {
                 QComboBox *themeComboBox = new ComboBox(this);
                 themeComboBox->addItem("Light", QChart::ChartThemeLight);
                 themeComboBox->addItem("Blue Cerulean", QChart::ChartThemeBlueCerulean);
                 themeComboBox->addItem("Dark", QChart::ChartThemeDark);
                 themeComboBox->addItem("Brown Sand", QChart::ChartThemeBrownSand);
                 themeComboBox->addItem("Blue NCS", QChart::ChartThemeBlueNcs);
                 themeComboBox->addItem("High Contrast", QChart::ChartThemeHighContrast);
                 themeComboBox->addItem("Blue Icy", QChart::ChartThemeBlueIcy);
                 themeComboBox->addItem("Qt", QChart::ChartThemeQt);
                 return themeComboBox;
             }
             QComboBox *Window::createViewBox()
             {
                 QComboBox *viewComboBox = new ComboBox(this);
                 viewComboBox->addItem("1 chart", 1);
                 viewComboBox->addItem("4 charts", 2);
                 viewComboBox->addItem("9 charts", 3);
                 viewComboBox->addItem("16 charts", 4);
                 return viewComboBox;
             }
             QComboBox *Window::createAnimationBox()
             {
                 QComboBox *animationComboBox = new ComboBox(this);
                 animationComboBox->addItem("No Animations", QChart::NoAnimation);
                 animationComboBox->addItem("GridAxis Animations", QChart::GridAxisAnimations);
                 animationComboBox->addItem("Series Animations", QChart::SeriesAnimations);
                 animationComboBox->addItem("All Animations", QChart::AllAnimations);
                 return animationComboBox;
             }
             QComboBox *Window::createLegendBox()
             {
                 QComboBox *legendComboBox = new ComboBox(this);
                 legendComboBox->addItem("No Legend ", 0);
                 legendComboBox->addItem("Legend Top", Qt::AlignTop);
                 legendComboBox->addItem("Legend Bottom", Qt::AlignBottom);
                 legendComboBox->addItem("Legend Left", Qt::AlignLeft);
                 legendComboBox->addItem("Legend Right", Qt::AlignRight);
                 return legendComboBox;
             }
             QComboBox *Window::createTempleteBox()
             {
                 QComboBox *templateComboBox = new ComboBox(this);
                 templateComboBox->addItem("No Template", 0);
                 Charts::ChartList list = Charts::chartList();
                 QMultiMap<QString, Chart *> categoryMap;
                 foreach (Chart *chart, list)
                     categoryMap.insertMulti(chart->category(), chart);
                 foreach (const QString &category, categoryMap.uniqueKeys())
                     templateComboBox->addItem(category, category);
                 return templateComboBox;
             }
             void Window::initializeFromParamaters(const QVariantHash &parameters)
             {
                 if (parameters.contains("view")) {
                        int t = parameters["view"].toInt();
                        for (int i = 0; i < m_viewComboBox->count(); ++i) {
                            if (m_viewComboBox->itemData(i).toInt() == t) {
                                m_viewComboBox->setCurrentIndex(i);
                                break;
                            }
                        }
                    }
                 if (parameters.contains("chart")) {
                     QString t = parameters["chart"].toString();
                     QRegExp rx("([a-zA-Z0-9_]*)::([a-zA-Z0-9_]*)::([a-zA-Z0-9_]*)");
                     int pos = rx.indexIn(t);
                     if (pos > -1) {
                         m_category = rx.cap(1);
                         m_subcategory = rx.cap(2);
                         m_name = rx.cap(3);
                         m_templateComboBox->setCurrentIndex(0);
                     }
                     else {
                         for (int i = 0; i < m_templateComboBox->count(); ++i) {
                             if (m_templateComboBox->itemText(i) == t) {
                                 m_templateComboBox->setCurrentIndex(i);
                                 break;
                             }
                         }
                     }
                 }
                 if (parameters.contains("opengl")) {
                     bool checked = parameters["opengl"].toBool();
                     m_openGLCheckBox->setChecked(checked);
                 }
                 if (parameters.contains("theme")) {
                     QString t = parameters["theme"].toString();
                     for (int i = 0; i < m_themeComboBox->count(); ++i) {
                         if (m_themeComboBox->itemText(i) == t) {
                             m_themeComboBox->setCurrentIndex(i);
                             break;
                         }
                     }
                 }
                 if (parameters.contains("animation")) {
                     QString t = parameters["animation"].toString();
                     for (int i = 0; i < m_animatedComboBox->count(); ++i) {
                         if (m_animatedComboBox->itemText(i) == t) {
                             m_animatedComboBox->setCurrentIndex(i);
                             break;
                         }
                     }
                 }
                 if (parameters.contains("legend")) {
                     QString t = parameters["legend"].toString();
                     for (int i = 0; i < m_legendComboBox->count(); ++i) {
                         if (m_legendComboBox->itemText(i) == t) {
                             m_legendComboBox->setCurrentIndex(i);
                             break;
                         }
                     }
                 }
             }
             void Window::updateUI()
             {
                 checkView();
                 checkTemplate();
                 checkOpenGL();
                 checkTheme();
                 checkAnimationOptions();
                 checkLegend();
                 checkState();
                 checkXTick();
                 checkYTick();
                 checkMinorXTick();
                 checkMinorYTick();
             }
             void Window::checkView()
             {
                 int count(m_viewComboBox->itemData(m_viewComboBox->currentIndex()).toInt());
                 if(m_grid->size()!=count){
                     m_grid->setSize(count);
                     m_template = 0;
                 }
             }
             void Window::checkXTick()
             {
                 foreach (QChart *chart, m_grid->charts()) {
                     if (qobject_cast<QValueAxis *>(chart->axisX())) {
                         QValueAxis *valueAxis = qobject_cast<QValueAxis *>(chart->axisX());
                         valueAxis->setGridLineVisible();
                         valueAxis->setTickCount(m_xTickSpinBox->value());
                     }
                 }
             }
             void Window::checkYTick()
             {
                 foreach (QChart *chart, m_grid->charts()) {
                     if (qobject_cast<QValueAxis *>(chart->axisY())) {
                         QValueAxis *valueAxis = qobject_cast<QValueAxis *>(chart->axisY());
                         valueAxis->setGridLineVisible();
                         valueAxis->setTickCount(m_yTickSpinBox->value());
                     }
                 }
             }
             void Window::checkMinorXTick()
             {
                 foreach (QChart *chart, m_grid->charts()) {
                     if (qobject_cast<QValueAxis *>(chart->axisX())) {
                         QValueAxis *valueAxis = qobject_cast<QValueAxis *>(chart->axisX());
                         valueAxis->setMinorGridLineVisible();
                         valueAxis->setMinorTickCount(m_minorXTickSpinBox->value());
                     }
                 }
             }
             void Window::checkMinorYTick()
             {
                 foreach (QChart *chart, m_grid->charts()) {
                     if (qobject_cast<QValueAxis *>(chart->axisY())) {
                         QValueAxis *valueAxis = qobject_cast<QValueAxis *>(chart->axisY());
                         valueAxis->setMinorGridLineVisible();
                         valueAxis->setMinorTickCount(m_minorYTickSpinBox->value());
                     }
                 }
             }
             void Window::checkLegend()
             {
                 Qt::Alignment alignment(m_legendComboBox->itemData(m_legendComboBox->currentIndex()).toInt());
                 if (!alignment) {
                     foreach (QChart *chart, m_grid->charts())
                         chart->legend()->hide();
                 } else {
                     foreach (QChart *chart, m_grid->charts()) {
                         chart->legend()->setAlignment(alignment);
                         chart->legend()->show();
                     }
                 }
             }
             void Window::checkOpenGL()
             {
                 bool opengl = m_openGLCheckBox->isChecked();
-                bool isOpengl = qobject_cast<QGLWidget *>(m_view->viewport());
+                bool isOpengl = qobject_cast<QOpenGLWidget *>(m_view->viewport());
                 if ((isOpengl && !opengl) || (!isOpengl && opengl)) {
                     m_view->deleteLater();
                     m_view = new View(m_scene, m_form);
-                    m_view->setViewport(!opengl ? new QWidget() : new QGLWidget());
+                    m_view->setViewport(!opengl ? new QWidget() : new QOpenGLWidget());
                     setCentralWidget(m_view);
                 }
                 bool antialias = m_antialiasCheckBox->isChecked();
                 if (opengl)
                     m_view->setRenderHint(QPainter::HighQualityAntialiasing, antialias);
                 else
                     m_view->setRenderHint(QPainter::Antialiasing, antialias);
             }
             void Window::checkAnimationOptions()
             {
                 QChart::AnimationOptions options(
                     m_animatedComboBox->itemData(m_animatedComboBox->currentIndex()).toInt());
                 QList<QChart *> charts = m_grid->charts();
                 if (!charts.isEmpty() && charts.at(0)->animationOptions() != options) {
                     foreach (QChart *chart, charts)
                         chart->setAnimationOptions(options);
                 }
             }
             void Window::checkState()
             {
                 bool scroll = m_scrollCheckBox->isChecked();
                 if (m_grid->state() != Grid::ScrollState && scroll) {
                     m_grid->setState(Grid::ScrollState);
                     m_zoomCheckBox->setChecked(false);
                 } else if (!scroll && m_grid->state() == Grid::ScrollState) {
                     m_grid->setState(Grid::NoState);
                 }
                 bool zoom = m_zoomCheckBox->isChecked();
                 if (m_grid->state() != Grid::ZoomState && zoom) {
                     m_grid->setState(Grid::ZoomState);
                     m_scrollCheckBox->setChecked(false);
                 } else if (!zoom && m_grid->state() == Grid::ZoomState) {
                     m_grid->setState(Grid::NoState);
                 }
             }
             void Window::checkTemplate()
             {
                 int index = m_templateComboBox->currentIndex();
                 if (m_template == index || index == 0)
                     return;
                 m_template = index;
                 QString category = m_templateComboBox->itemData(index).toString();
                 m_grid->createCharts(category);
             }
             void Window::checkTheme()
             {
                 QChart::ChartTheme theme = (QChart::ChartTheme) m_themeComboBox->itemData(
                                                m_themeComboBox->currentIndex()).toInt();
                 foreach (QChart *chart, m_grid->charts())
                     chart->setTheme(theme);
                 QPalette pal = window()->palette();
                 if (theme == QChart::ChartThemeLight) {
                     pal.setColor(QPalette::Window, QRgb(0xf0f0f0));
                     pal.setColor(QPalette::WindowText, QRgb(0x404044));
                 } else if (theme == QChart::ChartThemeDark) {
                     pal.setColor(QPalette::Window, QRgb(0x121218));
                     pal.setColor(QPalette::WindowText, QRgb(0xd6d6d6));
                 } else if (theme == QChart::ChartThemeBlueCerulean) {
                     pal.setColor(QPalette::Window, QRgb(0x40434a));
                     pal.setColor(QPalette::WindowText, QRgb(0xd6d6d6));
                 } else if (theme == QChart::ChartThemeBrownSand) {
                     pal.setColor(QPalette::Window, QRgb(0x9e8965));
                     pal.setColor(QPalette::WindowText, QRgb(0x404044));
                 } else if (theme == QChart::ChartThemeBlueNcs) {
                     pal.setColor(QPalette::Window, QRgb(0x018bba));
                     pal.setColor(QPalette::WindowText, QRgb(0x404044));
                 } else if (theme == QChart::ChartThemeHighContrast) {
                     pal.setColor(QPalette::Window, QRgb(0xffab03));
                     pal.setColor(QPalette::WindowText, QRgb(0x181818));
                 } else if (theme == QChart::ChartThemeBlueIcy) {
                     pal.setColor(QPalette::Window, QRgb(0xcee7f0));
                     pal.setColor(QPalette::WindowText, QRgb(0x404044));
                 } else if (theme == QChart::ChartThemeQt) {
                     pal.setColor(QPalette::Window, QRgb(0xf0f0f0));
                     pal.setColor(QPalette::WindowText, QRgb(0x404044));
                 } else {
                     pal.setColor(QPalette::Window, QRgb(0xf0f0f0));
                     pal.setColor(QPalette::WindowText, QRgb(0x404044));
                 }
                 foreach (QGraphicsProxyWidget *widget, m_widgetHash)
                     widget->setPalette(pal);
                 m_view->setBackgroundBrush(pal.color((QPalette::Window)));
                 m_grid->setRubberPen(pal.color((QPalette::WindowText)));
             }
             void Window::comboBoxFocused(QComboBox *combobox)
             {
                 foreach (QGraphicsProxyWidget *widget , m_widgetHash) {
                     if (widget->widget() == combobox)
                         widget->setZValue(2.0);
                     else
                         widget->setZValue(0.0);
                 }
             }
             void Window::handleChartSelected(QChart *qchart)
             {
                 if (m_templateComboBox->currentIndex() != 0)
                     return;
                 QAction *chosen = m_menu->exec(QCursor::pos());
                 if (chosen) {
                     Chart *chart = (Chart *) chosen->data().value<void *>();
                     m_grid->replaceChart(qchart, chart);
                     updateUI();
                 }
             }
             QMenu *Window::createMenu()
             {
                 Charts::ChartList list = Charts::chartList();
                 QMultiMap<QString, Chart *> categoryMap;
                 QMenu *result = new QMenu(this);
                 foreach (Chart *chart, list)
                     categoryMap.insertMulti(chart->category(), chart);
                 foreach (const QString &category, categoryMap.uniqueKeys()) {
                     QMenu *menu(0);
                     QMultiMap<QString, Chart *> subCategoryMap;
                     if (category.isEmpty()) {
                         menu = result;
                     } else {
                         menu = new QMenu(category, this);
                         result->addMenu(menu);
                     }
                     foreach (Chart *chart, categoryMap.values(category))
                         subCategoryMap.insert(chart->subCategory(), chart);
                     foreach (const QString &subCategory, subCategoryMap.uniqueKeys()) {
                         QMenu *subMenu(0);
                         if (subCategory.isEmpty()) {
                             subMenu = menu;
                         } else {
                             subMenu = new QMenu(subCategory, this);
                             menu->addMenu(subMenu);
                         }
                         foreach (Chart *chart, subCategoryMap.values(subCategory)) {
                             createMenuAction(subMenu, QIcon(), chart->name(),
                                              qVariantFromValue((void *) chart));
                         }
                     }
                 }
                 return result;
             }
             QAction *Window::createMenuAction(QMenu *menu, const QIcon &icon, const QString &text,
                                               const QVariant &data)
             {
                 QAction *action = menu->addAction(icon, text);
                 action->setCheckable(false);
                 action->setData(data);
                 return action;
             }
             void Window::handleGeometryChanged()
             {
                 QSizeF size = m_baseLayout->sizeHint(Qt::MinimumSize);
                 m_view->scene()->setSceneRect(0, 0, this->width(), this->height());
                 m_view->setMinimumSize(size.toSize());
             }

tests/manual/chartwidgettest/chartwidgettest.pro +1 -1

             !include( ../../tests.pri ) {
                 error( "Couldn't find the test.pri file!" )
             }
             TEMPLATE = app
-            QT += core gui opengl widgets
+            QT += core gui widgets
             SOURCES += main.cpp \
                 mainwidget.cpp \
                 dataseriedialog.cpp
             HEADERS += \
                 mainwidget.h \
                 dataseriedialog.h

tests/manual/chartwidgettest/mainwidget.cpp +5 -6

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include "mainwidget.h"
             #include "dataseriedialog.h"
             #include <QtCharts/QChartView>
             #include <QtCharts/QPieSeries>
             #include <QtCharts/QScatterSeries>
             #include <QtCharts/QLineSeries>
             #include <QtCharts/QAreaSeries>
             #include <QtCharts/QSplineSeries>
             #include <QtCharts/QBarSet>
             #include <QtCharts/QBarSeries>
             #include <QtCharts/QStackedBarSeries>
             #include <QtCharts/QPercentBarSeries>
             #include <QtWidgets/QPushButton>
             #include <QtWidgets/QComboBox>
             #include <QtWidgets/QSpinBox>
             #include <QtWidgets/QCheckBox>
             #include <QtWidgets/QGridLayout>
             #include <QtWidgets/QHBoxLayout>
             #include <QtWidgets/QLabel>
             #include <QtWidgets/QSpacerItem>
             #include <QtWidgets/QMessageBox>
             #include <cmath>
             #include <QtCore/QDebug>
             #include <QtGui/QStandardItemModel>
             #include <QtCharts/QBarCategoryAxis>
-            #include <QtOpenGL/QGLWidget>
+            #include <QtWidgets/QOpenGLWidget>
             QT_CHARTS_USE_NAMESPACE
             MainWidget::MainWidget(QWidget *parent) :
                 QWidget(parent),
                 m_addSerieDialog(0),
                 m_chart(0)
             {
                 m_chart = new QChart();
                 // Grid layout for the controls for configuring the chart widget
                 QGridLayout *grid = new QGridLayout();
                 QPushButton *addSeriesButton = new QPushButton("Add series");
                 connect(addSeriesButton, SIGNAL(clicked()), this, SLOT(addSeries()));
                 grid->addWidget(addSeriesButton, 0, 1);
                 initBackroundCombo(grid);
                 initScaleControls(grid);
                 initThemeCombo(grid);
                 initCheckboxes(grid);
                 // add row with empty label to make all the other rows static
                 grid->addWidget(new QLabel(""), grid->rowCount(), 0);
                 grid->setRowStretch(grid->rowCount() - 1, 1);
                 // Create chart view with the chart
                 m_chartView = new QChartView(m_chart, this);
                 m_chartView->setRubberBand(QChartView::HorizontalRubberBand);
                 // Another grid layout as a main layout
                 QGridLayout *mainLayout = new QGridLayout();
                 mainLayout->addLayout(grid, 0, 0);
                 mainLayout->addWidget(m_chartView, 0, 1, 3, 1);
                 setLayout(mainLayout);
             }
             // Combo box for selecting the chart's background
             void MainWidget::initBackroundCombo(QGridLayout *grid)
             {
                 QComboBox *backgroundCombo = new QComboBox(this);
                 backgroundCombo->addItem("Color");
                 backgroundCombo->addItem("Gradient");
                 backgroundCombo->addItem("Image");
                 connect(backgroundCombo, SIGNAL(currentIndexChanged(int)),
                         this, SLOT(backgroundChanged(int)));
                 grid->addWidget(new QLabel("Background:"), grid->rowCount(), 0);
                 grid->addWidget(backgroundCombo, grid->rowCount() - 1, 1);
             }
             // Scale related controls (auto-scale vs. manual min-max values)
             void MainWidget::initScaleControls(QGridLayout *grid)
             {
                 m_autoScaleCheck = new QCheckBox("Automatic scaling");
                 connect(m_autoScaleCheck, SIGNAL(stateChanged(int)), this, SLOT(autoScaleChanged(int)));
                 // Allow setting also non-sense values (like -2147483648 and 2147483647)
                 m_xMinSpin = new QSpinBox();
                 m_xMinSpin->setMinimum(INT_MIN);
                 m_xMinSpin->setMaximum(INT_MAX);
                 m_xMinSpin->setValue(0);
                 connect(m_xMinSpin, SIGNAL(valueChanged(int)), this, SLOT(xMinChanged(int)));
                 m_xMaxSpin = new QSpinBox();
                 m_xMaxSpin->setMinimum(INT_MIN);
                 m_xMaxSpin->setMaximum(INT_MAX);
                 m_xMaxSpin->setValue(10);
                 connect(m_xMaxSpin, SIGNAL(valueChanged(int)), this, SLOT(xMaxChanged(int)));
                 m_yMinSpin = new QSpinBox();
                 m_yMinSpin->setMinimum(INT_MIN);
                 m_yMinSpin->setMaximum(INT_MAX);
                 m_yMinSpin->setValue(0);
                 connect(m_yMinSpin, SIGNAL(valueChanged(int)), this, SLOT(yMinChanged(int)));
                 m_yMaxSpin = new QSpinBox();
                 m_yMaxSpin->setMinimum(INT_MIN);
                 m_yMaxSpin->setMaximum(INT_MAX);
                 m_yMaxSpin->setValue(10);
                 connect(m_yMaxSpin, SIGNAL(valueChanged(int)), this, SLOT(yMaxChanged(int)));
                 grid->addWidget(m_autoScaleCheck, grid->rowCount(), 0);
                 grid->addWidget(new QLabel("x min:"), grid->rowCount(), 0);
                 grid->addWidget(m_xMinSpin, grid->rowCount() - 1, 1);
                 grid->addWidget(new QLabel("x max:"), grid->rowCount(), 0);
                 grid->addWidget(m_xMaxSpin, grid->rowCount() - 1, 1);
                 grid->addWidget(new QLabel("y min:"), grid->rowCount(), 0);
                 grid->addWidget(m_yMinSpin, grid->rowCount() - 1, 1);
                 grid->addWidget(new QLabel("y max:"), grid->rowCount(), 0);
                 grid->addWidget(m_yMaxSpin, grid->rowCount() - 1, 1);
                 m_autoScaleCheck->setChecked(true);
             }
             // Combo box for selecting theme
             void MainWidget::initThemeCombo(QGridLayout *grid)
             {
                 QComboBox *chartTheme = new QComboBox();
                 chartTheme->addItem("Default");
                 chartTheme->addItem("Light");
                 chartTheme->addItem("Blue Cerulean");
                 chartTheme->addItem("Dark");
                 chartTheme->addItem("Brown Sand");
                 chartTheme->addItem("Blue NCS");
                 chartTheme->addItem("High Contrast");
                 chartTheme->addItem("Blue Icy");
                 chartTheme->addItem("Qt");
                 connect(chartTheme, SIGNAL(currentIndexChanged(int)),
                         this, SLOT(changeChartTheme(int)));
                 grid->addWidget(new QLabel("Chart theme:"), 8, 0);
                 grid->addWidget(chartTheme, 8, 1);
             }
             // Different check boxes for customizing chart
             void MainWidget::initCheckboxes(QGridLayout *grid)
             {
                 // TODO: setZoomEnabled slot has been removed from QChartView -> Re-implement zoom on/off
                 QCheckBox *zoomCheckBox = new QCheckBox("Drag'n drop Zoom");
             //    connect(zoomCheckBox, SIGNAL(toggled(bool)), m_chartView, SLOT(setZoomEnabled(bool)));
                 zoomCheckBox->setChecked(true);
                 grid->addWidget(zoomCheckBox, grid->rowCount(), 0);
                 QCheckBox *aliasCheckBox = new QCheckBox("Anti-alias");
                 connect(aliasCheckBox, SIGNAL(toggled(bool)), this, SLOT(antiAliasToggled(bool)));
                 aliasCheckBox->setChecked(false);
                 grid->addWidget(aliasCheckBox, grid->rowCount(), 0);
-                QCheckBox *openGLCheckBox = new QCheckBox("Use QGLWidget");
+                QCheckBox *openGLCheckBox = new QCheckBox("Use QOpenGLWidget");
                 connect(openGLCheckBox, SIGNAL(toggled(bool)), this, SLOT(openGLToggled(bool)));
                 openGLCheckBox->setChecked(false);
                 grid->addWidget(openGLCheckBox, grid->rowCount(), 0);
             }
             void MainWidget::antiAliasToggled(bool enabled)
             {
                 m_chartView->setRenderHint(QPainter::Antialiasing, enabled);
             }
             void MainWidget::openGLToggled(bool enabled)
             {
                 if (enabled) {
-                    QGLFormat f = QGLFormat::defaultFormat();
+                    QSurfaceFormat f = QSurfaceFormat::defaultFormat();
-                    f.setSampleBuffers(true);
                     f.setSamples(4);
-                    QGLFormat::setDefaultFormat(f);
+                    QSurfaceFormat::setDefaultFormat(f);
-                    QGLWidget *g = new QGLWidget();
+                    QOpenGLWidget *g = new QOpenGLWidget();
                     m_chartView->setViewport(g);
                 } else {
                     m_chartView->setViewport(0);
                 }
             }
             void MainWidget::addSeries()
             {
                 if (!m_addSerieDialog) {
                     m_addSerieDialog = new DataSerieDialog(this);
                     connect(m_addSerieDialog, SIGNAL(accepted(QString,int,int,QString,bool)),
                             this, SLOT(addSeries(QString,int,int,QString,bool)));
                 }
                 m_addSerieDialog->exec();
             }
             QList<RealList> MainWidget::generateTestData(int columnCount, int rowCount, QString dataCharacteristics)
             {
                 QList<RealList> testData;
                 for (int j(0); j < columnCount; j++) {
                     QList <qreal> newColumn;
                     for (int i(0); i < rowCount; i++) {
                         if (dataCharacteristics == "Sin") {
                             newColumn.append(abs(sin(3.14159265358979 / 50 * i) * 100));
                         } else if (dataCharacteristics == "Sin + random") {
                             newColumn.append(abs(sin(3.14159265358979 / 50 * i) * 100) + (rand() % 5));
                         } else if (dataCharacteristics == "Random") {
                             newColumn.append(rand() % 10 + (qreal) rand() / (qreal) RAND_MAX);
                         } else if (dataCharacteristics == "Linear") {
                             //newColumn.append(i * (j + 1.0));
                             // TODO: temporary hack to make pie work; prevent zero values:
                             newColumn.append(i * (j + 1.0) + 0.1);
                         } else { // "constant"
                             newColumn.append((j + 1.0));
                         }
                     }
                     testData.append(newColumn);
                 }
                 return testData;
             }
             QStringList MainWidget::generateLabels(int count)
             {
                 QStringList result;
                 for (int i(0); i < count; i++)
                     result.append("label" + QString::number(i));
                 return result;
             }
             void MainWidget::addSeries(QString seriesName, int columnCount, int rowCount, QString dataCharacteristics, bool labelsEnabled)
             {
                 qDebug() << "addSeries: " << seriesName
                          << " columnCount: " << columnCount
                          << " rowCount: " << rowCount
                          << " dataCharacteristics: " << dataCharacteristics
                          << " labels enabled: " << labelsEnabled;
                 m_defaultSeriesName = seriesName;
                 QList<RealList> data = generateTestData(columnCount, rowCount, dataCharacteristics);
                 // Line series and scatter series use similar data
                 if (seriesName == "Line") {
                     for (int j(0); j < data.count(); j ++) {
                         QList<qreal> column = data.at(j);
                         QLineSeries *series = new QLineSeries();
                         series->setName("line" + QString::number(j));
                         for (int i(0); i < column.count(); i++)
                             series->append(i, column.at(i));
                         m_chart->addSeries(series);
                     }
                 } else if (seriesName == "Area") {
                     // TODO: lower series for the area?
                     for (int j(0); j < data.count(); j ++) {
                         QList<qreal> column = data.at(j);
                         QLineSeries *lineSeries = new QLineSeries();
                         for (int i(0); i < column.count(); i++)
                             lineSeries->append(i, column.at(i));
                         QAreaSeries *areaSeries = new QAreaSeries(lineSeries);
                         areaSeries->setName("area" + QString::number(j));
                         m_chart->addSeries(areaSeries);
                     }
                 } else if (seriesName == "Scatter") {
                     for (int j(0); j < data.count(); j++) {
                         QList<qreal> column = data.at(j);
                         QScatterSeries *series = new QScatterSeries();
                         series->setName("scatter" + QString::number(j));
                         for (int i(0); i < column.count(); i++)
                             series->append(i, column.at(i));
                         m_chart->addSeries(series);
                     }
                 } else if (seriesName == "Pie") {
                     QStringList labels = generateLabels(rowCount);
                     for (int j(0); j < data.count(); j++) {
                         QPieSeries *series = new QPieSeries();
                         QList<qreal> column = data.at(j);
                         for (int i(0); i < column.count(); i++)
                             series->append(labels.at(i), column.at(i));
                         m_chart->addSeries(series);
                     }
                 } else if (seriesName == "Bar"
                            || seriesName == "Stacked bar"
                            || seriesName == "Percent bar") {
                     QStringList category;
                     QStringList labels = generateLabels(rowCount);
                     foreach (QString label, labels)
                         category << label;
                     QAbstractBarSeries* series = 0;
                     if (seriesName == "Bar") {
                         series = new QBarSeries(this);
                         QBarCategoryAxis* axis = new QBarCategoryAxis();
                         axis->append(category);
                         m_chart->setAxisX(axis,series);
                     } else if (seriesName == "Stacked bar") {
                         series = new QStackedBarSeries(this);
                         QBarCategoryAxis* axis = new QBarCategoryAxis();
                         axis->append(category);
                         m_chart->setAxisX(axis,series);
                     } else {
                         series = new QPercentBarSeries(this);
                         QBarCategoryAxis* axis = new QBarCategoryAxis();
                         axis->append(category);
                         m_chart->setAxisX(axis,series);
                     }
                     for (int j(0); j < data.count(); j++) {
                         QList<qreal> column = data.at(j);
                         QBarSet *set = new QBarSet("set" + QString::number(j));
                         for (int i(0); i < column.count(); i++)
                             *set << column.at(i);
                         series->append(set);
                     }
                     m_chart->addSeries(series);
                 } else if (seriesName == "Spline") {
                     for (int j(0); j < data.count(); j ++) {
                         QList<qreal> column = data.at(j);
                         QSplineSeries *series = new QSplineSeries();
                         series->setName("spline" + QString::number(j));
                         for (int i(0); i < column.count(); i++)
                             series->append(i, column.at(i));
                         m_chart->addSeries(series);
                     }
                 }
                 m_chart->createDefaultAxes();
             }
             void MainWidget::backgroundChanged(int itemIndex)
             {
                 qDebug() << "backgroundChanged: " << itemIndex;
             }
             void MainWidget::autoScaleChanged(int value)
             {
                 if (value) {
                     // TODO: enable auto scaling
                 } else {
                     // TODO: set scaling manually (and disable auto scaling)
                 }
                 m_xMinSpin->setEnabled(!value);
                 m_xMaxSpin->setEnabled(!value);
                 m_yMinSpin->setEnabled(!value);
                 m_yMaxSpin->setEnabled(!value);
             }
             void MainWidget::xMinChanged(int value)
             {
                 qDebug() << "xMinChanged: " << value;
             }
             void MainWidget::xMaxChanged(int value)
             {
                 qDebug() << "xMaxChanged: " << value;
             }
             void MainWidget::yMinChanged(int value)
             {
                 qDebug() << "yMinChanged: " << value;
             }
             void MainWidget::yMaxChanged(int value)
             {
                 qDebug() << "yMaxChanged: " << value;
             }
             void MainWidget::changeChartTheme(int themeIndex)
             {
                 qDebug() << "changeChartTheme: " << themeIndex;
                 if (themeIndex == 0)
                     m_chart->setTheme(QChart::ChartThemeLight);
                 else
                     m_chart->setTheme((QChart::ChartTheme) (themeIndex - 1));
             }

tests/manual/wavechart/main.cpp +2 -2

             /****************************************************************************
             **
             ** Copyright (C) 2015 The Qt Company Ltd
             ** All rights reserved.
             ** For any questions to The Qt Company, please use contact form at http://qt.io
             **
             ** This file is part of the Qt Charts module.
             **
             ** Licensees holding valid commercial license for Qt may use this file in
             ** accordance with the Qt License Agreement provided with the Software
             ** or, alternatively, in accordance with the terms contained in a written
             ** agreement between you and The Qt Company.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.io
             **
             ****************************************************************************/
             #include "wavechart.h"
             #include <QtWidgets/QApplication>
             #include <QtWidgets/QMainWindow>
-            #include <QtOpenGL/QGLWidget>
+            #include <QtWidgets/QOpenGLWidget>
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
                 QMainWindow window;
                 QChart *chart = new QChart();
                 WaveChart *waveChart = new WaveChart(chart,&window);
-                waveChart->setViewport( new QGLWidget() );
+                waveChart->setViewport( new QOpenGLWidget() );
                 waveChart->setRenderHint(QPainter::Antialiasing);
                 chart->setAnimationOptions(QChart::AllAnimations);
                 chart->setTitle("This is wave generator.");
                 window.setCentralWidget(waveChart);
                 window.resize(400, 300);
                 window.show();
                 return a.exec();
             }

tests/manual/wavechart/wavechart.pro 0 -1

             !include( ../../tests.pri ) {
                 error( "Couldn't find the test.pri file!" )
             }
-            QT+=opengl
             TARGET = wavechart
             SOURCES += main.cpp wavechart.cpp
             HEADERS += wavechart.h

General Comments 0

Write
Preview

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

No TODOs yet

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

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