Polish the painting/affine example

- Use member initialization
- Remove C-style casts
- Add space around operators
- Use qsizetype for list indexes
- Remove commented out debugging code

Task-number: QTBUG-97095
Pick-to: 6.2
Change-Id: I11a17fa6e7f17968367a57291d83ee6fba731a34
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>

7 files changed, 256 insertions, 299 deletions

diff --git a/examples/widgets/painting/affine/xform.cpp b/examples/widgets/painting/affine/xform.cpp
index d7ed2125d2..a18d6fb71b 100644
--- a/examples/widgets/painting/affine/xform.cpp
+++ b/examples/widgets/painting/affine/xform.cpp
@@ -58,27 +58,22 @@
 const int alpha = 155;
 
 XFormView::XFormView(QWidget *parent)
-    : ArthurFrame(parent)
+    : ArthurFrame(parent),
+      m_pixmap(QPixmap(":res/affine/bg1.jpg"))
 {
     setAttribute(Qt::WA_MouseTracking);
-    m_type = VectorType;
-    m_rotation = 0.0;
-    m_scale = 1.0;
-    m_shear = 0.0;
-
-    m_pixmap = QPixmap(":res/affine/bg1.jpg");
-    pts = new HoverPoints(this, HoverPoints::CircleShape);
-    pts->setConnectionType(HoverPoints::LineConnection);
-    pts->setEditable(false);
-    pts->setPointSize(QSize(15, 15));
-    pts->setShapeBrush(QBrush(QColor(151, 0, 0, alpha)));
-    pts->setShapePen(QPen(QColor(255, 100, 50, alpha)));
-    pts->setConnectionPen(QPen(QColor(151, 0, 0, 50)));
-    pts->setBoundingRect(QRectF(0, 0, 500, 500));
-    ctrlPoints << QPointF(250, 250) << QPointF(350, 250);
-    pts->setPoints(ctrlPoints);
-    connect(pts, &HoverPoints::pointsChanged,
-            this,&XFormView::updateCtrlPoints);
+
+    m_hoverPoints = new HoverPoints(this, HoverPoints::CircleShape);
+    m_hoverPoints->setConnectionType(HoverPoints::LineConnection);
+    m_hoverPoints->setEditable(false);
+    m_hoverPoints->setPointSize(QSize(15, 15));
+    m_hoverPoints->setShapeBrush(QBrush(QColor(151, 0, 0, alpha)));
+    m_hoverPoints->setShapePen(QPen(QColor(255, 100, 50, alpha)));
+    m_hoverPoints->setConnectionPen(QPen(QColor(151, 0, 0, 50)));
+    m_hoverPoints->setBoundingRect(QRectF(0, 0, 500, 500));
+    m_hoverPoints->setPoints(m_controlPoints);
+    connect(m_hoverPoints, &HoverPoints::pointsChanged,
+            this, &XFormView::updateControlPoints);
     setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
 }
 
@@ -122,7 +117,7 @@ void XFormView::mousePressEvent(QMouseEvent *)
 
 void XFormView::resizeEvent(QResizeEvent *e)
 {
-    pts->setBoundingRect(rect());
+    m_hoverPoints->setBoundingRect(rect());
     ArthurFrame::resizeEvent(e);
 }
 
@@ -145,24 +140,24 @@ void XFormView::paint(QPainter *p)
     p->restore();
 }
 
-void XFormView::updateCtrlPoints(const QPolygonF &points)
+void XFormView::updateControlPoints(const QPolygonF &points)
 {
-    QPointF trans = points.at(0) - ctrlPoints.at(0);
+    QPointF trans = points.at(0) - m_controlPoints.at(0);
 
     if (qAbs(points.at(0).x() - points.at(1).x()) < 10
         && qAbs(points.at(0).y() - points.at(1).y()) < 10)
-        pts->setPoints(ctrlPoints);
+        m_hoverPoints->setPoints(m_controlPoints);
     if (!trans.isNull()) {
-        ctrlPoints[0] = points.at(0);
-        ctrlPoints[1] += trans;
-        pts->setPoints(ctrlPoints);
+        m_controlPoints[0] = points.at(0);
+        m_controlPoints[1] += trans;
+        m_hoverPoints->setPoints(m_controlPoints);
     }
-    ctrlPoints = points;
+    m_controlPoints = points;
 
-    QLineF line(ctrlPoints.at(0), ctrlPoints.at(1));
+    QLineF line(m_controlPoints.at(0), m_controlPoints.at(1));
     m_rotation = 360 - QLineF(0, 0, 1, 0).angleTo(line);
     if (trans.isNull())
-        emit rotationChanged(int(m_rotation*10));
+        emit rotationChanged(int(m_rotation * 10));
 }
 
 void XFormView::setVectorType()
@@ -222,12 +217,12 @@ void XFormView::setRotation(qreal r)
     qreal old_rot = m_rotation;
     m_rotation = r;
 
-    QPointF center(pts->points().at(0));
+    QPointF center(m_hoverPoints->points().at(0));
     QTransform m;
     m.translate(center.x(), center.y());
     m.rotate(m_rotation - old_rot);
     m.translate(-center.x(), -center.y());
-    pts->setPoints(pts->points() * m);
+    m_hoverPoints->setPoints(m_hoverPoints->points() * m);
 
     update();
 }
@@ -235,12 +230,12 @@ void XFormView::setRotation(qreal r)
 void XFormView::timerEvent(QTimerEvent *e)
 {
     if (e->timerId() == timer.timerId()) {
-        QPointF center(pts->points().at(0));
+        QPointF center(m_hoverPoints->points().at(0));
         QTransform m;
         m.translate(center.x(), center.y());
         m.rotate(0.2);
         m.translate(-center.x(), -center.y());
-        pts->setPoints(pts->points() * m);
+        m_hoverPoints->setPoints(m_hoverPoints->points() * m);
 
         setUpdatesEnabled(false);
         static qreal scale_inc = 0.003;
@@ -253,7 +248,7 @@ void XFormView::timerEvent(QTimerEvent *e)
             shear_inc = -shear_inc;
         setUpdatesEnabled(true);
 
-        pts->firePointChange();
+        m_hoverPoints->firePointChange();
     }
 }
 
@@ -271,16 +266,15 @@ void XFormView::reset()
     emit rotationChanged(0);
     emit scaleChanged(1000);
     emit shearChanged(0);
-    ctrlPoints = QPolygonF();
-    ctrlPoints << QPointF(250, 250) << QPointF(350, 250);
-    pts->setPoints(ctrlPoints);
-    pts->firePointChange();
+    m_controlPoints = {{250, 250}, {350, 250}};
+    m_hoverPoints->setPoints(m_controlPoints);
+    m_hoverPoints->firePointChange();
 }
 
 void XFormView::drawPixmapType(QPainter *painter)
 {
     QPointF center(m_pixmap.width() / qreal(2), m_pixmap.height() / qreal(2));
-    painter->translate(ctrlPoints.at(0) - center);
+    painter->translate(m_controlPoints.at(0) - center);
 
     painter->translate(center);
     painter->rotate(m_rotation);
@@ -289,9 +283,11 @@ void XFormView::drawPixmapType(QPainter *painter)
     painter->translate(-center);
 
     painter->drawPixmap(QPointF(0, 0), m_pixmap);
-    painter->setPen(QPen(QColor(255, 0, 0, alpha), 0.25, Qt::SolidLine, Qt::FlatCap, Qt::BevelJoin));
+    painter->setPen(QPen(QColor(255, 0, 0, alpha), 0.25,
+                         Qt::SolidLine, Qt::FlatCap, Qt::BevelJoin));
     painter->setBrush(Qt::NoBrush);
-    painter->drawRect(QRectF(0, 0, m_pixmap.width(), m_pixmap.height()).adjusted(-2, -2, 2, 2));
+    painter->drawRect(QRectF(0, 0, m_pixmap.width(),
+                             m_pixmap.height()).adjusted(-2, -2, 2, 2));
 }
 
 void XFormView::drawTextType(QPainter *painter)
@@ -306,7 +302,7 @@ void XFormView::drawTextType(QPainter *painter)
     QFontMetrics fm(f);
     QRectF br(fm.boundingRect(m_text));
     QPointF center(br.center());
-    painter->translate(ctrlPoints.at(0) - center);
+    painter->translate(m_controlPoints.at(0) - center);
 
     painter->translate(center);
     painter->rotate(m_rotation);
@@ -316,7 +312,8 @@ void XFormView::drawTextType(QPainter *painter)
 
     painter->fillPath(path, Qt::black);
 
-    painter->setPen(QPen(QColor(255, 0, 0, alpha), 0.25, Qt::SolidLine, Qt::FlatCap, Qt::BevelJoin));
+    painter->setPen(QPen(QColor(255, 0, 0, alpha), 0.25,
+                         Qt::SolidLine, Qt::FlatCap, Qt::BevelJoin));
     painter->setBrush(Qt::NoBrush);
     painter->drawRect(br.adjusted(-1, -1, 1, 1));
 }
@@ -324,7 +321,7 @@ void XFormView::drawTextType(QPainter *painter)
 void XFormView::drawVectorType(QPainter *painter)
 {
     QPainterPath path;
-    painter->translate(ctrlPoints.at(0) - QPointF(250,250));
+    painter->translate(m_controlPoints.at(0) - QPointF(250,250));
 
     painter->scale(0.77, 0.77);
     painter->translate(98.9154 + 30 , -217.691 - 20);
@@ -339,10 +336,10 @@ void XFormView::drawVectorType(QPainter *painter)
 
     painter->setPen(Qt::NoPen);
     path.moveTo(120, 470);
-    path.lineTo(60+245, 470);
-    path.lineTo(60+245, 470+350);
-    path.lineTo(60, 470+350);
-    path.lineTo(60, 470+80);
+    path.lineTo(60 + 245, 470);
+    path.lineTo(60 + 245, 470 + 350);
+    path.lineTo(60, 470 + 350);
+    path.lineTo(60, 470 + 80);
 
     painter->setBrush(Qt::white);
     painter->drawPath(path);
diff --git a/examples/widgets/painting/affine/xform.h b/examples/widgets/painting/affine/xform.h
index 1dce3b26da..0c28435057 100644
--- a/examples/widgets/painting/affine/xform.h
+++ b/examples/widgets/painting/affine/xform.h
@@ -88,7 +88,7 @@ public:
 
     void mousePressEvent(QMouseEvent *e) override;
     void resizeEvent(QResizeEvent *e) override;
-    HoverPoints *hoverPoints() { return pts; }
+    HoverPoints *hoverPoints() { return m_hoverPoints; }
 
     bool animation() const { return timer.isActive(); }
     qreal shear() const { return m_shear; }
@@ -104,7 +104,7 @@ public:
 
 public slots:
     void setAnimation(bool animate);
-    void updateCtrlPoints(const QPolygonF &);
+    void updateControlPoints(const QPolygonF &);
     void changeRotation(int rotation);
     void changeScale(int scale);
     void changeShear(int shear);
@@ -130,12 +130,12 @@ protected:
 #endif
 
 private:
-    QPolygonF ctrlPoints;
-    HoverPoints *pts;
-    qreal m_rotation;
-    qreal m_scale;
-    qreal m_shear;
-    XFormType m_type;
+    QPolygonF m_controlPoints{{250, 250}, {350, 250}};
+    HoverPoints *m_hoverPoints;
+    qreal m_rotation = 0;
+    qreal m_scale = 1;
+    qreal m_shear = 0;
+    XFormType m_type = VectorType;
     QPixmap m_pixmap;
     QString m_text;
     QBasicTimer timer;
diff --git a/examples/widgets/painting/deform/pathdeform.cpp b/examples/widgets/painting/deform/pathdeform.cpp
index acf0191260..998b6a53a1 100644
--- a/examples/widgets/painting/deform/pathdeform.cpp
+++ b/examples/widgets/painting/deform/pathdeform.cpp
@@ -481,7 +481,7 @@ void PathDeformRenderer::timerEvent(QTimerEvent *e)
 
 void PathDeformRenderer::mousePressEvent(QMouseEvent *e)
 {
-    if (m_show_doc) {
+    if (m_showDoc) {
         setDescriptionEnabled(false);
         return;
     }
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("&amp;"));
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;