Brush up the collidingmice example

- Port to snake case.
- Use per-class imports.
- Replace call to obsolete qrand() function.
- Fix the random movement (angle) by using setRotation() as does
  the C++ example.
- Use QGraphicsScene.advance() instead of per-mouse timers
  to advance the scene as does the C++ example.

Task-number: PYSIDE-1112
Change-Id: Ibb5b4bde51021d890acb4cc6c2f41a3e0d0207af
Reviewed-by: Cristian Maureira-Fredes <cristian.maureira-fredes@qt.io>

1 files changed, 77 insertions, 77 deletions

diff --git a/examples/widgets/graphicsview/collidingmice/collidingmice.py b/examples/widgets/graphicsview/collidingmice/collidingmice.py
index 2d5490b6d..b22517617 100644
--- a/examples/widgets/graphicsview/collidingmice/collidingmice.py
+++ b/examples/widgets/graphicsview/collidingmice/collidingmice.py
@@ -2,7 +2,7 @@
 #############################################################################
 ##
 ## Copyright (C) 2013 Riverbank Computing Limited.
-## Copyright (C) 2016 The Qt Company Ltd.
+## Copyright (C) 2021 The Qt Company Ltd.
 ## Contact: http://www.qt.io/licensing/
 ##
 ## This file is part of the Qt for Python examples of the Qt Toolkit.
@@ -41,23 +41,29 @@
 #############################################################################
 
 import math
+import sys
 
-from PySide6 import QtCore, QtGui, QtWidgets
+from PySide6.QtCore import (QLineF, QPointF, QRandomGenerator, QRectF, QTimer,
+                            Qt)
+from PySide6.QtGui import (QBrush, QColor, QPainter, QPainterPath, QPixmap,
+                           QPolygonF, QTransform)
+from PySide6.QtWidgets import (QApplication, QGraphicsItem, QGraphicsScene,
+                               QGraphicsView)
 
 import mice_rc
 
 
 def random(boundary):
-    return QtCore.QRandomGenerator.global_().bounded(boundary)
+    return QRandomGenerator.global_().bounded(boundary)
 
 
-class Mouse(QtWidgets.QGraphicsItem):
-    Pi = math.pi
-    TwoPi = 2.0 * Pi
+class Mouse(QGraphicsItem):
+    PI = math.pi
+    TWO_PI = 2.0 * PI
 
     # Create the bounding rectangle once.
     adjust = 0.5
-    BoundingRect = QtCore.QRectF(-20 - adjust, -22 - adjust, 40 + adjust,
+    BOUNDING_RECT = QRectF(-20 - adjust, -22 - adjust, 40 + adjust,
             83 + adjust)
 
     def __init__(self):
@@ -65,32 +71,24 @@ class Mouse(QtWidgets.QGraphicsItem):
 
         self.angle = 0.0
         self.speed = 0.0
-        self.mouseEyeDirection = 0.0
-        self.color = QtGui.QColor(random(256), random(256), random(256))
+        self._mouse_eye_direction = 0.0
+        self.color = QColor(random(256), random(256), random(256))
 
-        self.setTransform(QtGui.QTransform().rotate(random(360 * 16)))
-
-        # In the C++ version of this example, this class is also derived from
-        # QObject in order to receive timer events. PySide6 does not support
-        # deriving from more than one wrapped class so we just create an
-        # explicit timer instead.
-        self.timer = QtCore.QTimer()
-        self.timer.timeout.connect(self.timerEvent)
-        self.timer.start(1000 / 33)
+        self.setTransform(QTransform().rotate(random(360 * 16)))
 
     @staticmethod
-    def normalizeAngle(angle):
+    def normalize_angle(angle):
         while angle < 0:
-            angle += Mouse.TwoPi
-        while angle > Mouse.TwoPi:
-            angle -= Mouse.TwoPi
+            angle += Mouse.TWO_PI
+        while angle > Mouse.TWO_PI:
+            angle -= Mouse.TWO_PI
         return angle
 
     def boundingRect(self):
-        return Mouse.BoundingRect
+        return Mouse.BOUNDING_RECT
 
     def shape(self):
-        path = QtGui.QPainterPath()
+        path = QPainterPath()
         path.addRect(-10, -20, 20, 40)
         return path
 
@@ -100,80 +98,82 @@ class Mouse(QtWidgets.QGraphicsItem):
         painter.drawEllipse(-10, -20, 20, 40)
 
         # Eyes.
-        painter.setBrush(QtCore.Qt.white)
+        painter.setBrush(Qt.white)
         painter.drawEllipse(-10, -17, 8, 8)
         painter.drawEllipse(2, -17, 8, 8)
 
         # Nose.
-        painter.setBrush(QtCore.Qt.black)
-        painter.drawEllipse(QtCore.QRectF(-2, -22, 4, 4))
+        painter.setBrush(Qt.black)
+        painter.drawEllipse(QRectF(-2, -22, 4, 4))
 
         # Pupils.
-        painter.drawEllipse(QtCore.QRectF(-8.0 + self.mouseEyeDirection, -17, 4, 4))
-        painter.drawEllipse(QtCore.QRectF(4.0 + self.mouseEyeDirection, -17, 4, 4))
+        painter.drawEllipse(QRectF(-8.0 + self._mouse_eye_direction, -17, 4, 4))
+        painter.drawEllipse(QRectF(4.0 + self._mouse_eye_direction, -17, 4, 4))
 
         # Ears.
         if self.scene().collidingItems(self):
-            painter.setBrush(QtCore.Qt.red)
+            painter.setBrush(Qt.red)
         else:
-            painter.setBrush(QtCore.Qt.darkYellow)
+            painter.setBrush(Qt.darkYellow)
 
         painter.drawEllipse(-17, -12, 16, 16)
         painter.drawEllipse(1, -12, 16, 16)
 
         # Tail.
-        path = QtGui.QPainterPath(QtCore.QPointF(0, 20))
+        path = QPainterPath(QPointF(0, 20))
         path.cubicTo(-5, 22, -5, 22, 0, 25)
         path.cubicTo(5, 27, 5, 32, 0, 30)
         path.cubicTo(-5, 32, -5, 42, 0, 35)
-        painter.setBrush(QtCore.Qt.NoBrush)
+        painter.setBrush(Qt.NoBrush)
         painter.drawPath(path)
 
-    def timerEvent(self):
+    def advance(self, phase):
+        if not phase:
+            return
         # Don't move too far away.
-        lineToCenter = QtCore.QLineF(QtCore.QPointF(0, 0), self.mapFromScene(0, 0))
-        if lineToCenter.length() > 150:
-            angleToCenter = math.acos(lineToCenter.dx() / lineToCenter.length())
-            if lineToCenter.dy() < 0:
-                angleToCenter = Mouse.TwoPi - angleToCenter
-            angleToCenter = Mouse.normalizeAngle((Mouse.Pi - angleToCenter) + Mouse.Pi / 2)
-
-            if angleToCenter < Mouse.Pi and angleToCenter > Mouse.Pi / 4:
+        line_to_center = QLineF(QPointF(0, 0), self.mapFromScene(0, 0))
+        if line_to_center.length() > 150:
+            angle_to_center = math.acos(line_to_center.dx() / line_to_center.length())
+            if line_to_center.dy() < 0:
+                angle_to_center = Mouse.TWO_PI - angle_to_center
+            angle_to_center = Mouse.normalize_angle((Mouse.PI - angle_to_center) + Mouse.PI / 2)
+
+            if angle_to_center < Mouse.PI and angle_to_center > Mouse.PI / 4:
                 # Rotate left.
-                self.angle += [-0.25, 0.25][self.angle < -Mouse.Pi / 2]
-            elif angleToCenter >= Mouse.Pi and angleToCenter < (Mouse.Pi + Mouse.Pi / 2 + Mouse.Pi / 4):
+                self.angle += [-0.25, 0.25][self.angle < -Mouse.PI / 2]
+            elif angle_to_center >= Mouse.PI and angle_to_center < (Mouse.PI + Mouse.PI / 2 + Mouse.PI / 4):
                 # Rotate right.
-                self.angle += [-0.25, 0.25][self.angle < Mouse.Pi / 2]
+                self.angle += [-0.25, 0.25][self.angle < Mouse.PI / 2]
         elif math.sin(self.angle) < 0:
             self.angle += 0.25
         elif math.sin(self.angle) > 0:
             self.angle -= 0.25
 
         # Try not to crash with any other mice.
-        dangerMice = self.scene().items(QtGui.QPolygonF([self.mapToScene(0, 0),
-                                                         self.mapToScene(-30, -50),
-                                                         self.mapToScene(30, -50)]))
+        danger_mice = self.scene().items(QPolygonF([self.mapToScene(0, 0),
+                                                    self.mapToScene(-30, -50),
+                                                    self.mapToScene(30, -50)]))
 
-        for item in dangerMice:
+        for item in danger_mice:
             if item is self:
                 continue
 
-            lineToMouse = QtCore.QLineF(QtCore.QPointF(0, 0), self.mapFromItem(item, 0, 0))
-            angleToMouse = math.acos(lineToMouse.dx() / lineToMouse.length())
-            if lineToMouse.dy() < 0:
-                angleToMouse = Mouse.TwoPi - angleToMouse
-            angleToMouse = Mouse.normalizeAngle((Mouse.Pi - angleToMouse) + Mouse.Pi / 2)
+            line_to_mouse = QLineF(QPointF(0, 0), self.mapFromItem(item, 0, 0))
+            angle_to_mouse = math.acos(line_to_mouse.dx() / line_to_mouse.length())
+            if line_to_mouse.dy() < 0:
+                angle_to_mouse = Mouse.TWO_PI - angle_to_mouse
+            angle_to_mouse = Mouse.normalize_angle((Mouse.PI - angle_to_mouse) + Mouse.PI / 2)
 
-            if angleToMouse >= 0 and angleToMouse < Mouse.Pi / 2:
+            if angle_to_mouse >= 0 and angle_to_mouse < Mouse.PI / 2:
                 # Rotate right.
                 self.angle += 0.5
-            elif angleToMouse <= Mouse.TwoPi and angleToMouse > (Mouse.TwoPi - Mouse.Pi / 2):
+            elif angle_to_mouse <= Mouse.TWO_PI and angle_to_mouse > (Mouse.TWO_PI - Mouse.PI / 2):
                 # Rotate left.
                 self.angle -= 0.5
 
         # Add some random movement.
-        if len(dangerMice) > 1 and (QtCore.qrand() % 10) == 0:
-            if QtCore.qrand() % 1:
+        if len(danger_mice) > 1 and random(10) == 0:
+            if random(2) != 0:
                 self.angle += random(100) / 500.0
             else:
                 self.angle -= random(100) / 500.0
@@ -181,38 +181,38 @@ class Mouse(QtWidgets.QGraphicsItem):
         self.speed += (-50 + random(100)) / 100.0
 
         dx = math.sin(self.angle) * 10
-        self.mouseEyeDirection = [dx / 5, 0.0][QtCore.qAbs(dx / 5) < 1]
 
-        self.setTransform(QtGui.QTransform().rotate(dx))
+        self._mouse_eye_direction = [dx / 5, 0.0][abs(dx / 5) < 1]
+
+        self.setRotation(self.rotation() + dx)
         self.setPos(self.mapToParent(0, -(3 + math.sin(self.speed) * 3)))
 
 
 if __name__ == '__main__':
+    MOUSE_COUNT = 7
+    app = QApplication(sys.argv)
 
-    import sys
-
-    MouseCount = 7
-
-    app = QtWidgets.QApplication(sys.argv)
-
-    scene = QtWidgets.QGraphicsScene()
+    scene = QGraphicsScene()
     scene.setSceneRect(-300, -300, 600, 600)
-    scene.setItemIndexMethod(QtWidgets.QGraphicsScene.NoIndex)
+    scene.setItemIndexMethod(QGraphicsScene.NoIndex)
 
-    for i in range(MouseCount):
+    for i in range(MOUSE_COUNT):
         mouse = Mouse()
-        mouse.setPos(math.sin((i * 6.28) / MouseCount) * 200,
-                     math.cos((i * 6.28) / MouseCount) * 200)
+        mouse.setPos(math.sin((i * 6.28) / MOUSE_COUNT) * 200,
+                     math.cos((i * 6.28) / MOUSE_COUNT) * 200)
         scene.addItem(mouse)
 
-    view = QtWidgets.QGraphicsView(scene)
-    view.setRenderHint(QtGui.QPainter.Antialiasing)
-    view.setBackgroundBrush(QtGui.QBrush(QtGui.QPixmap(':/images/cheese.jpg')))
-    view.setCacheMode(QtWidgets.QGraphicsView.CacheBackground)
-    view.setViewportUpdateMode(QtWidgets.QGraphicsView.BoundingRectViewportUpdate)
-    view.setDragMode(QtWidgets.QGraphicsView.ScrollHandDrag)
+    view = QGraphicsView(scene)
+    view.setRenderHint(QPainter.Antialiasing)
+    view.setBackgroundBrush(QBrush(QPixmap(':/images/cheese.jpg')))
+    view.setCacheMode(QGraphicsView.CacheBackground)
+    view.setViewportUpdateMode(QGraphicsView.BoundingRectViewportUpdate)
+    view.setDragMode(QGraphicsView.ScrollHandDrag)
     view.setWindowTitle("Colliding Mice")
     view.resize(400, 300)
     view.show()
 
+    timer = QTimer()
+    timer.timeout.connect(scene.advance)
+    timer.start(1000 / 33)
     sys.exit(app.exec_())