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

                     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());
                                               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());
                                 && (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());
                                     && (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) ||

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

                     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());
                                               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],
                                               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]);
                                 && (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());
                                     && (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)

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

             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);
             }

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

                         // 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;
                             }
                         }
-                        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;
                         }

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

             }
             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

             #include <QtWidgets/QGraphicsScene>
             #include <QtWidgets/QGraphicsLinearLayout>
             #include <QtWidgets/QGraphicsProxyWidget>
-            #include <QtOpenGL/QGLWidget>
+            #include <QtWidgets/QOpenGLWidget>
             #include <QtWidgets/QApplication>
             #include <QtCore/QDebug>
             #include <QtWidgets/QMenu>
             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);
                 }

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

             TEMPLATE = app
-            QT += core gui opengl widgets
+            QT += core gui widgets
             SOURCES += main.cpp \
                 mainwidget.cpp \

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

             #include <QtCore/QDebug>
             #include <QtGui/QStandardItemModel>
             #include <QtCharts/QBarCategoryAxis>
-            #include <QtOpenGL/QGLWidget>
+            #include <QtWidgets/QOpenGLWidget>
             QT_CHARTS_USE_NAMESPACE
                 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::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);

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

             #include "wavechart.h"
             #include <QtWidgets/QApplication>
             #include <QtWidgets/QMainWindow>
-            #include <QtOpenGL/QGLWidget>
+            #include <QtWidgets/QOpenGLWidget>
             int main(int argc, char *argv[])
             {
                 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.");

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

                 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