4 files changed, 202 insertions, 242 deletions

diff --git a/examples/widgets/painting/shared/arthurwidgets.cpp b/examples/widgets/painting/shared/arthurwidgets.cpp
index 667246b79a..61e73c4a60 100644
--- a/examples/widgets/painting/shared/arthurwidgets.cpp
+++ b/examples/widgets/painting/shared/arthurwidgets.cpp
@@ -70,28 +70,15 @@
 extern QPixmap cached(const QString &img);
 
 ArthurFrame::ArthurFrame(QWidget *parent)
-    : QWidget(parent)
-    , m_prefer_image(false)
+    : QWidget(parent),
+      m_tile(QPixmap(128, 128))
 {
-#if QT_CONFIG(opengl)
-    m_glWindow = nullptr;
-    m_glWidget = nullptr;
-    m_use_opengl = false;
-#endif
-    m_document = nullptr;
-    m_show_doc = false;
-
-    m_tile = QPixmap(128, 128);
     m_tile.fill(Qt::white);
     QPainter pt(&m_tile);
     QColor color(230, 230, 230);
     pt.fillRect(0, 0, 64, 64, color);
     pt.fillRect(64, 64, 64, 64, color);
     pt.end();
-
-//     QPalette pal = palette();
-//     pal.setBrush(backgroundRole(), m_tile);
-//     setPalette(pal);
 }
 
 
@@ -209,7 +196,7 @@ void ArthurFrame::paintEvent(QPaintEvent *e)
     painter.restore();
 
     painter.save();
-    if (m_show_doc)
+    if (m_showDoc)
         paintDescription(&painter);
     painter.restore();
 
@@ -244,9 +231,9 @@ void ArthurFrame::resizeEvent(QResizeEvent *e)
 
 void ArthurFrame::setDescriptionEnabled(bool enabled)
 {
-    if (m_show_doc != enabled) {
-        m_show_doc = enabled;
-        emit descriptionEnabledChanged(m_show_doc);
+    if (m_showDoc != enabled) {
+        m_showDoc = enabled;
+        emit descriptionEnabledChanged(m_showDoc);
         update();
     }
 }
@@ -276,9 +263,8 @@ void ArthurFrame::paintDescription(QPainter *painter)
 
     int pageWidth = qMax(width() - 100, 100);
     int pageHeight = qMax(height() - 100, 100);
-    if (pageWidth != m_document->pageSize().width()) {
+    if (pageWidth != m_document->pageSize().width())
         m_document->setPageSize(QSize(pageWidth, pageHeight));
-    }
 
     QRect textRect(width() / 2 - pageWidth / 2,
                    height() / 2 - pageHeight / 2,
@@ -340,7 +326,7 @@ void ArthurFrame::showSource()
         if (!f.open(QFile::ReadOnly))
             contents = tr("Could not open file: '%1'").arg(m_sourceFileName);
         else
-            contents = f.readAll();
+            contents = QString::fromUtf8(f.readAll());
     }
 
     contents.replace(QLatin1Char('&'), QStringLiteral("&"));
diff --git a/examples/widgets/painting/shared/arthurwidgets.h b/examples/widgets/painting/shared/arthurwidgets.h
index 73e1310c0e..69fee57a27 100644
--- a/examples/widgets/painting/shared/arthurwidgets.h
+++ b/examples/widgets/painting/shared/arthurwidgets.h
@@ -69,7 +69,6 @@ public:
     ArthurFrame(QWidget *parent);
     virtual void paint(QPainter *) {}
 
-
     void paintDescription(QPainter *p);
 
     void loadDescription(const QString &filename);
@@ -77,13 +76,13 @@ public:
 
     void loadSourceFile(const QString &fileName);
 
-    bool preferImage() const { return m_prefer_image; }
+    bool preferImage() const { return m_preferImage; }
 #if QT_CONFIG(opengl)
     QOpenGLWindow *glWindow() const { return m_glWindow; }
 #endif
 
 public slots:
-    void setPreferImage(bool pi) { m_prefer_image = pi; }
+    void setPreferImage(bool pi) { m_preferImage = pi; }
     void setDescriptionEnabled(bool enabled);
     void showSource();
 
@@ -101,18 +100,17 @@ protected:
 
 #if QT_CONFIG(opengl)
     virtual void createGlWindow();
-    QOpenGLWindow *m_glWindow;
-    QWidget *m_glWidget;
-    bool m_use_opengl;
+    QOpenGLWindow *m_glWindow = nullptr;
+    QWidget *m_glWidget = nullptr;
+    bool m_use_opengl = false;
 #endif
     QPixmap m_tile;
 
-    bool m_show_doc;
-    bool m_prefer_image;
-    QTextDocument *m_document;
+    bool m_showDoc = false;
+    bool m_preferImage = false;
+    QTextDocument *m_document = nullptr;;
 
     QString m_sourceFileName;
-
 };
 
 #endif
diff --git a/examples/widgets/painting/shared/hoverpoints.cpp b/examples/widgets/painting/shared/hoverpoints.cpp
index 417d593d04..ea59694f92 100644
--- a/examples/widgets/painting/shared/hoverpoints.cpp
+++ b/examples/widgets/painting/shared/hoverpoints.cpp
@@ -57,31 +57,18 @@
 #include <QtOpenGL/QOpenGLWindow>
 #endif
 
-#define printf
-
 HoverPoints::HoverPoints(QWidget *widget, PointShape shape)
-    : QObject(widget)
+    : QObject(widget),
+      m_widget(widget),
+      m_shape(shape)
 {
-    m_widget = widget;
     widget->installEventFilter(this);
     widget->setAttribute(Qt::WA_AcceptTouchEvents);
 
-    m_connectionType = CurveConnection;
-    m_sortType = NoSort;
-    m_shape = shape;
-    m_pointPen = QPen(QColor(255, 255, 255, 191), 1);
-    m_connectionPen = QPen(QColor(255, 255, 255, 127), 2);
-    m_pointBrush = QBrush(QColor(191, 191, 191, 127));
-    m_pointSize = QSize(11, 11);
-    m_currentIndex = -1;
-    m_editable = true;
-    m_enabled = true;
-
     connect(this, &HoverPoints::pointsChanged,
             m_widget, QOverload<>::of(&QWidget::update));
 }
 
-
 void HoverPoints::setEnabled(bool enabled)
 {
     if (m_enabled != enabled) {
@@ -90,191 +77,197 @@ void HoverPoints::setEnabled(bool enabled)
     }
 }
 
-
 bool HoverPoints::eventFilter(QObject *object, QEvent *event)
 {
-    if (object == m_widget && m_enabled) {
-        switch (event->type()) {
+    if (object != m_widget || !m_enabled)
+        return false;
 
-        case QEvent::MouseButtonPress:
-        {
-            if (!m_fingerPointMapping.isEmpty())
-                return true;
-            QMouseEvent *me = (QMouseEvent *) event;
-
-            QPointF clickPos = me->position().toPoint();
-            int index = -1;
-            for (int i=0; i<m_points.size(); ++i) {
-                QPainterPath path;
-                if (m_shape == CircleShape)
-                    path.addEllipse(pointBoundingRect(i));
-                else
-                    path.addRect(pointBoundingRect(i));
-
-                if (path.contains(clickPos)) {
-                    index = i;
-                    break;
-                }
+    switch (event->type()) {
+    case QEvent::MouseButtonPress:
+    {
+        if (!m_fingerPointMapping.isEmpty())
+            return true;
+        auto *me = static_cast<const QMouseEvent *>(event);
+        QPointF clickPos = me->position().toPoint();
+        qsizetype index = -1;
+        for (qsizetype i = 0; i < m_points.size(); ++i) {
+            QPainterPath path;
+            const QRectF rect = pointBoundingRect(m_points.at(i));
+            if (m_shape == CircleShape)
+                path.addEllipse(rect);
+            else
+                path.addRect(rect);
+
+            if (path.contains(clickPos)) {
+                index = i;
+                break;
             }
+        }
 
-            if (me->button() == Qt::LeftButton) {
-                if (index == -1) {
-                    if (!m_editable)
-                        return false;
-                    int pos = 0;
-                    // Insert sort for x or y
-                    if (m_sortType == XSort) {
-                        for (int i=0; i<m_points.size(); ++i)
-                            if (m_points.at(i).x() > clickPos.x()) {
-                                pos = i;
-                                break;
-                            }
-                    } else if (m_sortType == YSort) {
-                        for (int i=0; i<m_points.size(); ++i)
-                            if (m_points.at(i).y() > clickPos.y()) {
-                                pos = i;
-                                break;
-                            }
+        if (me->button() == Qt::LeftButton) {
+            if (index == -1) {
+                if (!m_editable)
+                    return false;
+                qsizetype pos = 0;
+                // Insert sort for x or y
+                switch (m_sortType) {
+                case XSort:
+                    for (qsizetype i = 0; i < m_points.size(); ++i) {
+                        if (m_points.at(i).x() > clickPos.x()) {
+                            pos = i;
+                            break;
+                        }
                     }
-
-                    m_points.insert(pos, clickPos);
-                    m_locks.insert(pos, 0);
-                    m_currentIndex = pos;
-                    firePointChange();
-                } else {
-                    m_currentIndex = index;
-                }
-                return true;
-
-            } else if (me->button() == Qt::RightButton) {
-                if (index >= 0 && m_editable) {
-                    if (m_locks[index] == 0) {
-                        m_locks.remove(index);
-                        m_points.remove(index);
+                    break;
+                case YSort:
+                    for (qsizetype i = 0; i < m_points.size(); ++i) {
+                        if (m_points.at(i).y() > clickPos.y()) {
+                            pos = i;
+                            break;
+                        }
                     }
-                    firePointChange();
-                    return true;
+                    break;
+                default:
+                    break;
                 }
+
+                m_points.insert(pos, clickPos);
+                m_locks.insert(pos, 0);
+                m_currentIndex = pos;
+                firePointChange();
+            } else {
+                m_currentIndex = index;
             }
+            return true;
 
+        } else if (me->button() == Qt::RightButton) {
+            if (index >= 0 && m_editable) {
+                if (m_locks[index] == 0) {
+                    m_locks.remove(index);
+                    m_points.remove(index);
+                }
+                firePointChange();
+                return true;
+            }
         }
+    }
+    break;
+
+    case QEvent::MouseButtonRelease:
+        if (!m_fingerPointMapping.isEmpty())
+            return true;
+        m_currentIndex = -1;
         break;
 
-        case QEvent::MouseButtonRelease:
-            if (!m_fingerPointMapping.isEmpty())
-                return true;
-            m_currentIndex = -1;
-            break;
+    case QEvent::MouseMove:
+        if (!m_fingerPointMapping.isEmpty())
+            return true;
+        if (m_currentIndex >= 0) {
+            auto *me = static_cast<const QMouseEvent *>(event);
+            movePoint(m_currentIndex, me->position().toPoint());
+        }
+        break;
 
-        case QEvent::MouseMove:
-            if (!m_fingerPointMapping.isEmpty())
-                return true;
-            if (m_currentIndex >= 0)
-                movePoint(m_currentIndex, ((QMouseEvent *)event)->position().toPoint());
-            break;
-        case QEvent::TouchBegin:
-        case QEvent::TouchUpdate:
+    case QEvent::TouchBegin:
+    case QEvent::TouchUpdate:
+    {
+        auto *touchEvent = static_cast<const QTouchEvent*>(event);
+        const auto points = touchEvent->points();
+        const qreal pointSize = qMax(m_pointSize.width(), m_pointSize.height());
+        for (const auto &point : points) {
+            const int id = point.id();
+            switch (point.state()) {
+            case QEventPoint::Pressed:
             {
-                const QTouchEvent *const touchEvent = static_cast<const QTouchEvent*>(event);
-                const auto points = touchEvent->points();
-                const qreal pointSize = qMax(m_pointSize.width(), m_pointSize.height());
-                for (const auto &point : points) {
-                    const int id = point.id();
-                    switch (point.state()) {
-                    case QEventPoint::Pressed:
-                        {
-                            // find the point, move it
-                            const auto mappedPoints = m_fingerPointMapping.values();
-                            QSet<int> activePoints = QSet<int>(mappedPoints.begin(), mappedPoints.end());
-                            int activePoint = -1;
-                            qreal distance = -1;
-                            const int pointsCount = m_points.size();
-                            const int activePointCount = activePoints.size();
-                            if (pointsCount == 2 && activePointCount == 1) { // only two points
-                                activePoint = activePoints.contains(0) ? 1 : 0;
-                            } else {
-                                for (int i=0; i<pointsCount; ++i) {
-                                    if (activePoints.contains(i))
-                                        continue;
-
-                                    qreal d = QLineF(point.position(), m_points.at(i)).length();
-                                    if ((distance < 0 && d < 12 * pointSize) || d < distance) {
-                                        distance = d;
-                                        activePoint = i;
-                                    }
-
-                                }
-                            }
-                            if (activePoint != -1) {
-                                m_fingerPointMapping.insert(point.id(), activePoint);
-                                movePoint(activePoint, point.position());
-                            }
-                        }
-                        break;
-                    case QEventPoint::Released:
-                        {
-                            // move the point and release
-                            QHash<int,int>::iterator it = m_fingerPointMapping.find(id);
-                            movePoint(it.value(), point.position());
-                            m_fingerPointMapping.erase(it);
-                        }
-                        break;
-                    case QEventPoint::Updated:
-                        {
-                            // move the point
-                            const int pointIdx = m_fingerPointMapping.value(id, -1);
-                            if (pointIdx >= 0) // do we track this point?
-                                movePoint(pointIdx, point.position());
+                // find the point, move it
+                const auto mappedPoints = m_fingerPointMapping.values();
+                QSet<qsizetype> activePoints(mappedPoints.begin(), mappedPoints.end());
+                qsizetype activePoint = -1;
+                qreal distance = -1;
+                const qsizetype pointsCount = m_points.size();
+                const qsizetype activePointCount = activePoints.size();
+                if (pointsCount == 2 && activePointCount == 1) { // only two points
+                    activePoint = activePoints.contains(0) ? 1 : 0;
+                } else {
+                    for (qsizetype i = 0; i < pointsCount; ++i) {
+                        if (activePoints.contains(i))
+                            continue;
+
+                        qreal d = QLineF(point.position(), m_points.at(i)).length();
+                        if ((distance < 0 && d < 12 * pointSize) || d < distance) {
+                            distance = d;
+                            activePoint = i;
                         }
-                        break;
-                    default:
-                        break;
+
                     }
                 }
-                if (m_fingerPointMapping.isEmpty()) {
-                    event->ignore();
-                    return false;
-                } else {
-                    return true;
+                if (activePoint != -1) {
+                    m_fingerPointMapping.insert(point.id(), activePoint);
+                    movePoint(activePoint, point.position());
                 }
             }
             break;
-        case QEvent::TouchEnd:
-            if (m_fingerPointMapping.isEmpty()) {
-                event->ignore();
-                return false;
+            case QEventPoint::Released:
+            {
+                // move the point and release
+                const auto it = m_fingerPointMapping.find(id);
+                movePoint(it.value(), point.position());
+                m_fingerPointMapping.erase(it);
             }
-            return true;
             break;
-
-        case QEvent::Resize:
-        {
-            QResizeEvent *e = (QResizeEvent *) event;
-            if (e->oldSize().width() == 0 || e->oldSize().height() == 0)
-                break;
-            qreal stretch_x = e->size().width() / qreal(e->oldSize().width());
-            qreal stretch_y = e->size().height() / qreal(e->oldSize().height());
-            for (int i=0; i<m_points.size(); ++i) {
-                QPointF p = m_points[i];
-                movePoint(i, QPointF(p.x() * stretch_x, p.y() * stretch_y), false);
+            case QEventPoint::Updated:
+            {
+                // move the point
+                const qsizetype pointIdx = m_fingerPointMapping.value(id, -1);
+                if (pointIdx >= 0) // do we track this point?
+                    movePoint(pointIdx, point.position());
             }
-
-            firePointChange();
             break;
+            default:
+                break;
+            }
         }
-
-        case QEvent::Paint:
-        {
-            QWidget *that_widget = m_widget;
-            m_widget = nullptr;
-            QCoreApplication::sendEvent(object, event);
-            m_widget = that_widget;
-            paintPoints();
-            return true;
+        if (m_fingerPointMapping.isEmpty()) {
+            event->ignore();
+            return false;
+        }
+        return true;
+    }
+    case QEvent::TouchEnd:
+        if (m_fingerPointMapping.isEmpty()) {
+            event->ignore();
+            return false;
         }
-        default:
+        return true;
+
+    case QEvent::Resize:
+    {
+        auto *e = static_cast<const QResizeEvent *>(event);
+        if (e->oldSize().width() <= 0 || e->oldSize().height() <= 0)
             break;
+        qreal stretch_x = e->size().width() / qreal(e->oldSize().width());
+        qreal stretch_y = e->size().height() / qreal(e->oldSize().height());
+        for (qsizetype i = 0; i < m_points.size(); ++i) {
+            QPointF p = m_points.at(i);
+            movePoint(i, QPointF(p.x() * stretch_x, p.y() * stretch_y), false);
         }
+
+        firePointChange();
+        break;
+    }
+
+    case QEvent::Paint:
+    {
+        QWidget *that_widget = m_widget;
+        m_widget = nullptr;
+        QCoreApplication::sendEvent(object, event);
+        m_widget = that_widget;
+        paintPoints();
+        return true;
+    }
+
+    default:
+        break;
     }
 
     return false;
@@ -304,8 +297,8 @@ void HoverPoints::paintPoints()
         if (m_connectionType == CurveConnection) {
             QPainterPath path;
             path.moveTo(m_points.at(0));
-            for (int i=1; i<m_points.size(); ++i) {
-                QPointF p1 = m_points.at(i-1);
+            for (qsizetype i = 1; i < m_points.size(); ++i) {
+                QPointF p1 = m_points.at(i - 1);
                 QPointF p2 = m_points.at(i);
                 qreal distance = p2.x() - p1.x();
 
@@ -322,8 +315,8 @@ void HoverPoints::paintPoints()
     p.setPen(m_pointPen);
     p.setBrush(m_pointBrush);
 
-    for (int i=0; i<m_points.size(); ++i) {
-        QRectF bounds = pointBoundingRect(i);
+    for (const auto &point : qAsConst(m_points)) {
+        QRectF bounds = pointBoundingRect(point);
         if (m_shape == CircleShape)
             p.drawEllipse(bounds);
         else
@@ -354,32 +347,28 @@ void HoverPoints::setPoints(const QPolygonF &points)
     if (points.size() != m_points.size())
         m_fingerPointMapping.clear();
     m_points.clear();
-    for (int i=0; i<points.size(); ++i)
+    for (qsizetype i = 0; i < points.size(); ++i)
         m_points << bound_point(points.at(i), boundingRect(), 0);
 
     m_locks.clear();
     if (m_points.size() > 0) {
         m_locks.resize(m_points.size());
-
         m_locks.fill(0);
     }
 }
 
-
-void HoverPoints::movePoint(int index, const QPointF &point, bool emitUpdate)
+void HoverPoints::movePoint(qsizetype index, const QPointF &point, bool emitUpdate)
 {
     m_points[index] = bound_point(point, boundingRect(), m_locks.at(index));
     if (emitUpdate)
         firePointChange();
 }
 
-
 inline static bool x_less_than(const QPointF &p1, const QPointF &p2)
 {
     return p1.x() < p2.x();
 }
 
-
 inline static bool y_less_than(const QPointF &p1, const QPointF &p2)
 {
     return p1.y() < p2.y();
@@ -387,14 +376,11 @@ inline static bool y_less_than(const QPointF &p1, const QPointF &p2)
 
 void HoverPoints::firePointChange()
 {
-//    printf("HoverPoints::firePointChange(), current=%d\n", m_currentIndex);
-
     if (m_sortType != NoSort) {
 
         QPointF oldCurrent;
-        if (m_currentIndex != -1) {
+        if (m_currentIndex != -1)
             oldCurrent = m_points[m_currentIndex];
-        }
 
         if (m_sortType == XSort)
             std::sort(m_points.begin(), m_points.end(), x_less_than);
@@ -403,22 +389,14 @@ void HoverPoints::firePointChange()
 
         // Compensate for changed order...
         if (m_currentIndex != -1) {
-            for (int i=0; i<m_points.size(); ++i) {
+            for (qsizetype i = 0; i < m_points.size(); ++i) {
                 if (m_points[i] == oldCurrent) {
                     m_currentIndex = i;
                     break;
                 }
             }
         }
-
-//         printf(" - firePointChange(), current=%d\n", m_currentIndex);
-
     }
 
-//     for (int i=0; i<m_points.size(); ++i) {
-//         printf(" - point(%2d)=[%.2f, %.2f], lock=%d\n",
-//                i, m_points.at(i).x(), m_points.at(i).y(), m_locks.at(i));
-//     }
-
     emit pointsChanged(m_points);
 }
diff --git a/examples/widgets/painting/shared/hoverpoints.h b/examples/widgets/painting/shared/hoverpoints.h
index 3c6f356e1b..8b341197d2 100644
--- a/examples/widgets/painting/shared/hoverpoints.h
+++ b/examples/widgets/painting/shared/hoverpoints.h
@@ -124,35 +124,33 @@ public:
     void firePointChange();
 
 private:
-    inline QRectF pointBoundingRect(int i) const;
-    void movePoint(int i, const QPointF &newPos, bool emitChange = true);
+    inline QRectF pointBoundingRect(const QPointF &p) const;
+    void movePoint(qsizetype i, const QPointF &newPos, bool emitChange = true);
 
     QWidget *m_widget;
 
     QPolygonF m_points;
     QRectF m_bounds;
     PointShape m_shape;
-    SortType m_sortType;
-    ConnectionType m_connectionType;
+    SortType m_sortType = NoSort;
+    ConnectionType m_connectionType = CurveConnection;
 
     QList<uint> m_locks;
 
-    QSizeF m_pointSize;
-    int m_currentIndex;
-    bool m_editable;
-    bool m_enabled;
+    QSizeF m_pointSize{11, 11};
+    qsizetype m_currentIndex= -1;
+    bool m_editable = true;
+    bool m_enabled = true;
 
-    QHash<int, int> m_fingerPointMapping;
+    QHash<int, qsizetype> m_fingerPointMapping;
 
-    QPen m_pointPen;
-    QBrush m_pointBrush;
-    QPen m_connectionPen;
+    QPen m_pointPen{QColor(255, 255, 255, 191), 1};
+    QBrush m_pointBrush{QColor(191, 191, 191, 127)};
+    QPen m_connectionPen{QColor(255, 255, 255, 127), 2};
 };
 
-
-inline QRectF HoverPoints::pointBoundingRect(int i) const
+inline QRectF HoverPoints::pointBoundingRect(const QPointF &p) const
 {
-    QPointF p = m_points.at(i);
     qreal w = m_pointSize.width();
     qreal h = m_pointSize.height();
     qreal x = p.x() - w / 2;