Brush up the dragdroprobot example

- Use per class imports
- Streamline code

Task-number: PYSIDE-1112
Change-Id: I77f00a893b397d1cf73d85bb41038c7c4a73405c
Reviewed-by: Christian Tismer <tismer@stackless.com>

1 files changed, 70 insertions, 64 deletions

diff --git a/examples/widgets/graphicsview/dragdroprobot/dragdroprobot.py b/examples/widgets/graphicsview/dragdroprobot/dragdroprobot.py
index b5114bad1..8fbd6c79c 100644
--- a/examples/widgets/graphicsview/dragdroprobot/dragdroprobot.py
+++ b/examples/widgets/graphicsview/dragdroprobot/dragdroprobot.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.
@@ -40,90 +40,102 @@
 ##
 #############################################################################
 
-from PySide6 import QtCore, QtGui, QtWidgets
+import sys
+import math
+
+from PySide6.QtCore import (QEasingCurve, QLineF, QMimeData, QPoint, QPointF,
+                            QRandomGenerator, QRectF, QTimeLine, Qt)
+from PySide6.QtGui import (QBrush, QColor, QDrag, QImage, QPainter, QPixmap,
+                           QPen, QTransform)
+from PySide6.QtWidgets import (QApplication, QGraphicsItem,
+                               QGraphicsItemAnimation, QGraphicsScene,
+                               QGraphicsView, QWidget)
 
 import dragdroprobot_rc
 
 
 def random(boundary):
-    return QtCore.QRandomGenerator.global_().bounded(boundary)
+    return QRandomGenerator.global_().bounded(boundary)
 
 
-class ColorItem(QtWidgets.QGraphicsItem):
+class ColorItem(QGraphicsItem):
     n = 0
 
     def __init__(self):
-        super(ColorItem, self).__init__()
+        super().__init__()
 
-        self.color = QtGui.QColor(random(256), random(256), random(256))
+        self.color = QColor(random(256), random(256), random(256))
 
         (r, g, b) = (self.color.red(), self.color.green(), self.color.blue())
         self.setToolTip(
             f"QColor({r}, {g}, {b})\nClick and drag this color onto the robot!")
-        self.setCursor(QtCore.Qt.OpenHandCursor)
+        self.setCursor(Qt.OpenHandCursor)
+        self._start_drag_distance = QApplication.startDragDistance()
 
     def boundingRect(self):
-        return QtCore.QRectF(-15.5, -15.5, 34, 34)
+        return QRectF(-15.5, -15.5, 34, 34)
 
     def paint(self, painter, option, widget):
-        painter.setPen(QtCore.Qt.NoPen)
-        painter.setBrush(QtCore.Qt.darkGray)
+        painter.setPen(Qt.NoPen)
+        painter.setBrush(Qt.darkGray)
         painter.drawEllipse(-12, -12, 30, 30)
-        painter.setPen(QtGui.QPen(QtCore.Qt.black, 1))
-        painter.setBrush(QtGui.QBrush(self.color))
+        painter.setPen(QPen(Qt.black, 1))
+        painter.setBrush(QBrush(self.color))
         painter.drawEllipse(-15, -15, 30, 30)
 
     def mousePressEvent(self, event):
-        if event.button() != QtCore.Qt.LeftButton:
+        if event.button() != Qt.LeftButton:
             event.ignore()
             return
 
-        self.setCursor(QtCore.Qt.ClosedHandCursor)
+        self.setCursor(Qt.ClosedHandCursor)
 
     def mouseMoveEvent(self, event):
-        if QtCore.QLineF(QtCore.QPointF(event.screenPos()), QtCore.QPointF(event.buttonDownScreenPos(QtCore.Qt.LeftButton))).length() < QtWidgets.QApplication.startDragDistance():
+        start = QPointF(event.buttonDownScreenPos(Qt.LeftButton))
+        if QLineF(event.screenPos(), start).length() < self._start_drag_distance:
             return
 
-        drag = QtGui.QDrag(event.widget())
-        mime = QtCore.QMimeData()
+        drag = QDrag(event.widget())
+        mime = QMimeData()
         drag.setMimeData(mime)
 
         ColorItem.n += 1
         if ColorItem.n > 2 and random(3) == 0:
-            image = QtGui.QImage(':/images/head.png')
+            image = QImage(':/images/head.png')
             mime.setImageData(image)
-            drag.setPixmap(QtGui.QPixmap.fromImage(image).scaled(30,40))
-            drag.setHotSpot(QtCore.QPoint(15, 30))
+            drag.setPixmap(QPixmap.fromImage(image).scaled(30,40))
+            drag.setHotSpot(QPoint(15, 30))
         else:
             mime.setColorData(self.color)
-            mime.setText("#%02x%02x%02x" % (self.color.red(), self.color.green(), self.color.blue()))
+            (r, g, b) = (self.color.red(), self.color.green(), self.color.blue())
+            mime.setText(f"#{r:02x}{g:02x}{b:02x}")
 
-            pixmap = QtGui.QPixmap(34, 34)
-            pixmap.fill(QtCore.Qt.white)
+            pixmap = QPixmap(34, 34)
+            pixmap.fill(Qt.white)
 
-            painter = QtGui.QPainter(pixmap)
+            painter = QPainter(pixmap)
             painter.translate(15, 15)
-            painter.setRenderHint(QtGui.QPainter.Antialiasing)
+            painter.setRenderHint(QPainter.Antialiasing)
             self.paint(painter, None, None)
             painter.end()
 
             pixmap.setMask(pixmap.createHeuristicMask())
 
             drag.setPixmap(pixmap)
-            drag.setHotSpot(QtCore.QPoint(15, 20))
+            drag.setHotSpot(QPoint(15, 20))
 
         drag.exec_()
-        self.setCursor(QtCore.Qt.OpenHandCursor)
+        self.setCursor(Qt.OpenHandCursor)
 
     def mouseReleaseEvent(self, event):
-        self.setCursor(QtCore.Qt.OpenHandCursor)
+        self.setCursor(Qt.OpenHandCursor)
 
 
-class RobotPart(QtWidgets.QGraphicsItem):
+class RobotPart(QGraphicsItem):
     def __init__(self, parent=None):
-        super(RobotPart, self).__init__(parent)
+        super().__init__(parent)
 
-        self.color = QtGui.QColor(QtCore.Qt.lightGray)
+        self.color = QColor(Qt.lightGray)
         self.pixmap = None
         self._drag_over = False
 
@@ -145,46 +157,44 @@ class RobotPart(QtWidgets.QGraphicsItem):
     def dropEvent(self, event):
         self._drag_over = False
         if event.mimeData().hasColor():
-            self.color = QtGui.QColor(event.mimeData().colorData())
+            self.color = QColor(event.mimeData().colorData())
         elif event.mimeData().hasImage():
-            self.pixmap = QtGui.QPixmap(event.mimeData().imageData())
+            self.pixmap = QPixmap(event.mimeData().imageData())
 
         self.update()
 
 
 class RobotHead(RobotPart):
     def boundingRect(self):
-        return QtCore.QRectF(-15, -50, 30, 50)
+        return QRectF(-15, -50, 30, 50)
 
     def paint(self, painter, option, widget=None):
         if not self.pixmap:
             painter.setBrush(self._drag_over and self.color.lighter(130)
                                             or self.color)
-            painter.drawRoundedRect(-10, -30, 20, 30, 25, 25,
-                    QtCore.Qt.RelativeSize)
-            painter.setBrush(QtCore.Qt.white)
+            painter.drawRoundedRect(-10, -30, 20, 30, 25, 25, Qt.RelativeSize)
+            painter.setBrush(Qt.white)
             painter.drawEllipse(-7, -3 - 20, 7, 7)
             painter.drawEllipse(0, -3 - 20, 7, 7)
-            painter.setBrush(QtCore.Qt.black)
+            painter.setBrush(Qt.black)
             painter.drawEllipse(-5, -1 - 20, 2, 2)
             painter.drawEllipse(2, -1 - 20, 2, 2)
-            painter.setPen(QtGui.QPen(QtCore.Qt.black, 2))
-            painter.setBrush(QtCore.Qt.NoBrush)
+            painter.setPen(QPen(Qt.black, 2))
+            painter.setBrush(Qt.NoBrush)
             painter.drawArc(-6, -2 - 20, 12, 15, 190 * 16, 160 * 16)
         else:
             painter.scale(.2272, .2824)
-            painter.drawPixmap(QtCore.QPointF(-15*4.4, -50*3.54), self.pixmap)
+            painter.drawPixmap(QPointF(-15*4.4, -50*3.54), self.pixmap)
 
 
 class RobotTorso(RobotPart):
     def boundingRect(self):
-        return QtCore.QRectF(-30, -20, 60, 60)
+        return QRectF(-30, -20, 60, 60)
 
     def paint(self, painter, option, widget=None):
         painter.setBrush(self._drag_over and self.color.lighter(130)
                                         or self.color)
-        painter.drawRoundedRect(-20, -20, 40, 60, 25, 25,
-                QtCore.Qt.RelativeSize)
+        painter.drawRoundedRect(-20, -20, 40, 60, 25, 25, Qt.RelativeSize)
         painter.drawEllipse(-25, -20, 20, 20)
         painter.drawEllipse(5, -20, 20, 20)
         painter.drawEllipse(-20, 22, 20, 20)
@@ -193,18 +203,18 @@ class RobotTorso(RobotPart):
 
 class RobotLimb(RobotPart):
     def boundingRect(self):
-        return QtCore.QRectF(-5, -5, 40, 10)
+        return QRectF(-5, -5, 40, 10)
 
     def paint(self, painter, option, widget=None):
         painter.setBrush(self._drag_over and self.color.lighter(130) or self.color)
         painter.drawRoundedRect(self.boundingRect(), 50, 50,
-                QtCore.Qt.RelativeSize)
+                Qt.RelativeSize)
         painter.drawEllipse(-5, -5, 10, 10)
 
 
 class Robot(RobotPart):
     def __init__(self):
-        super(Robot, self).__init__()
+        super().__init__()
 
         self.torsoItem         = RobotTorso(self)
         self.headItem          = RobotHead(self.torsoItem)
@@ -217,7 +227,7 @@ class Robot(RobotPart):
         self.upperLeftLegItem  = RobotLimb(self.torsoItem)
         self.lowerLeftLegItem  = RobotLimb(self.upperLeftLegItem)
 
-        self.timeline = QtCore.QTimeLine()
+        self.timeline = QTimeLine()
         settings = [
         #             item               position    rotation at
         #                                 x    y    time 0  /  1
@@ -235,7 +245,7 @@ class Robot(RobotPart):
         self.animations = []
         for item, pos_x, pos_y, rotation1, rotation2 in settings:
             item.setPos(pos_x,pos_y)
-            animation = QtWidgets.QGraphicsItemAnimation()
+            animation = QGraphicsItemAnimation()
             animation.setItem(item)
             animation.setTimeLine(self.timeline)
             animation.setRotationAt(0, rotation1)
@@ -244,43 +254,39 @@ class Robot(RobotPart):
         self.animations[0].setScaleAt(1, 1.1, 1.1)
 
         self.timeline.setUpdateInterval(1000 / 25)
-        curve = QtCore.QEasingCurve(QtCore.QEasingCurve.SineCurve)
+        curve = QEasingCurve(QEasingCurve.SineCurve)
         self.timeline.setEasingCurve(curve)
         self.timeline.setLoopCount(0)
         self.timeline.setDuration(2000)
         self.timeline.start()
 
     def boundingRect(self):
-        return QtCore.QRectF()
+        return QRectF()
 
     def paint(self, painter, option, widget=None):
         pass
 
 
 if __name__== '__main__':
+    app = QApplication(sys.argv)
 
-    import sys
-    import math
-
-    app = QtWidgets.QApplication(sys.argv)
-
-    scene = QtWidgets.QGraphicsScene(-200, -200, 400, 400)
+    scene = QGraphicsScene(-200, -200, 400, 400)
 
     for i in range(10):
         item = ColorItem()
-        angle = i*6.28 / 10.0
-        item.setPos(math.sin(angle)*150, math.cos(angle)*150)
+        angle = i * 2.0 * math.pi / 10.0
+        item.setPos(math.sin(angle) * 150, math.cos(angle) * 150)
         scene.addItem(item)
 
     robot = Robot()
-    robot.setTransform(QtGui.QTransform().scale(1.2, 1.2))
+    robot.setTransform(QTransform().scale(1.2, 1.2))
     robot.setPos(0, -20)
     scene.addItem(robot)
 
-    view = QtWidgets.QGraphicsView(scene)
-    view.setRenderHint(QtGui.QPainter.Antialiasing)
-    view.setViewportUpdateMode(QtWidgets.QGraphicsView.BoundingRectViewportUpdate)
-    view.setBackgroundBrush(QtGui.QColor(230, 200, 167))
+    view = QGraphicsView(scene)
+    view.setRenderHint(QPainter.Antialiasing)
+    view.setViewportUpdateMode(QGraphicsView.BoundingRectViewportUpdate)
+    view.setBackgroundBrush(QColor(230, 200, 167))
     view.setWindowTitle("Drag and Drop Robot")
     view.show()