Cannon tutorial: Brush up code

- Use per class imports
- Remove string-based connections, fixing some errors introduced
  by the snake case renaming
- Add some spacing and indent main
- Use math.pi

Task-number: PYSIDE-1112
Change-Id: I2171fc9eb27f9926f32648a289df404d390ace43
Reviewed-by: Christian Tismer <[email protected]>

1 files changed, 107 insertions, 107 deletions

diff --git a/examples/widgets/tutorials/cannon/t13.py b/examples/widgets/tutorials/cannon/t13.py
index b0d56c166..9214611bd 100644
--- a/examples/widgets/tutorials/cannon/t13.py
+++ b/examples/widgets/tutorials/cannon/t13.py
@@ -1,7 +1,7 @@
 
 #############################################################################
 ##
-## 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.
@@ -45,17 +45,25 @@
 import sys
 import math
 import random
-from PySide6 import QtCore, QtGui, QtWidgets
 
+from PySide6.QtCore import (QPoint, QRect, QTime, QTimer, Qt, SIGNAL, SLOT,
+                            Signal, Slot)
+from PySide6.QtGui import QColor, QFont, QPainter, QPalette, QRegion
+from PySide6.QtWidgets import (QApplication, QGridLayout, QHBoxLayout, QLabel,
+                               QLCDNumber, QPushButton, QSizePolicy, QSlider,
+                               QVBoxLayout, QWidget)
+
+
+class LCDRange(QWidget):
+
+    value_changed = Signal(int)
 
-class LCDRange(QtWidgets.QWidget):
-    value_changed = QtCore.Signal(int)
     def __init__(self, text=None, parent=None):
-        if isinstance(text, QtWidgets.QWidget):
+        if isinstance(text, QWidget):
             parent = text
             text = None
 
-        QtWidgets.QWidget.__init__(self, parent)
+        super().__init__(parent)
 
         self.init()
 
@@ -63,31 +71,28 @@ class LCDRange(QtWidgets.QWidget):
             self.set_text(text)
 
     def init(self):
-        lcd = QtWidgets.QLCDNumber(2)
-        self.slider = QtWidgets.QSlider(QtCore.Qt.Horizontal)
+        lcd = QLCDNumber(2)
+        self.slider = QSlider(Qt.Horizontal)
         self.slider.setRange(0, 99)
         self.slider.setValue(0)
-        self.label = QtWidgets.QLabel()
-        self.label.setAlignment(QtCore.Qt.AlignHCenter | QtCore.Qt.AlignTop)
-        self.label.setSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Fixed)
+        self.label = QLabel()
+        self.label.setAlignment(Qt.AlignHCenter | Qt.AlignTop)
+        self.label.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
 
-        self.connect(self.slider, QtCore.SIGNAL("valueChanged(int)"),
-                     lcd, QtCore.SLOT("display(int)"))
-        self.connect(self.slider, QtCore.SIGNAL("valueChanged(int)"),
-                     self, QtCore.SIGNAL("valueChanged(int)"))
+        self.slider.valueChanged.connect(lcd.display)
+        self.slider.valueChanged.connect(self.value_changed)
 
-        layout = QtWidgets.QVBoxLayout()
+        layout = QVBoxLayout(self)
         layout.addWidget(lcd)
         layout.addWidget(self.slider)
         layout.addWidget(self.label)
-        self.setLayout(layout)
 
         self.setFocusProxy(self.slider)
 
     def value(self):
         return self.slider.value()
 
-    @QtCore.Slot(int)
+    @Slot(int)
     def set_value(self, value):
         self.slider.setValue(value)
 
@@ -96,7 +101,7 @@ class LCDRange(QtWidgets.QWidget):
 
     def set_range(self, minValue, maxValue):
         if minValue < 0 or maxValue > 99 or minValue > maxValue:
-            QtCore.qWarning(f"LCDRange::setRange({minValue}, {maxValue})\n"
+            qWarning(f"LCDRange::setRange({minValue}, {maxValue})\n"
                     "\tRange must be 0..99\n"
                     "\tand minValue must not be greater than maxValue")
             return
@@ -107,33 +112,34 @@ class LCDRange(QtWidgets.QWidget):
         self.label.setText(text)
 
 
-class CannonField(QtWidgets.QWidget):
-    angle_changed = QtCore.Signal(int)
-    force_changed = QtCore.Signal(int)
-    hit = QtCore.Signal()
-    missed = QtCore.Signal()
-    can_shoot = QtCore.Signal(bool)
+class CannonField(QWidget):
+
+    angle_changed = Signal(int)
+    force_changed = Signal(int)
+    hit = Signal()
+    missed = Signal()
+    can_shoot = Signal(bool)
+
     def __init__(self, parent=None):
-        QtWidgets.QWidget.__init__(self, parent)
+        super().__init__(parent)
 
         self._current_angle = 45
         self._current_force = 0
         self._timer_count = 0
-        self._auto_shoot_timer = QtCore.QTimer(self)
-        self.connect(self._auto_shoot_timer, QtCore.SIGNAL("timeout()"),
-                     self.move_shot)
+        self._auto_shoot_timer = QTimer(self)
+        self._auto_shoot_timer.timeout.connect(self.move_shot)
         self._shoot_angle = 0
         self._shoot_force = 0
-        self.target = QtCore.QPoint(0, 0)
+        self.target = QPoint(0, 0)
         self._game_ended = False
-        self.setPalette(QtGui.QPalette(QtGui.QColor(250, 250, 200)))
+        self.setPalette(QPalette(QColor(250, 250, 200)))
         self.setAutoFillBackground(True)
         self.new_target()
 
     def angle(self):
         return self._current_angle
 
-    @QtCore.Slot(int)
+    @Slot(int)
     def set_angle(self, angle):
         if angle < 5:
             angle = 5
@@ -143,21 +149,21 @@ class CannonField(QtWidgets.QWidget):
             return
         self._current_angle = angle
         self.update()
-        self.emit(QtCore.SIGNAL("angleChanged(int)"), self._current_angle)
+        self.angle_changed.emit(self._current_angle)
 
     def force(self):
         return self._current_force
 
-    @QtCore.Slot(int)
+    @Slot(int)
     def set_force(self, force):
         if force < 0:
             force = 0
         if self._current_force == force:
             return
         self._current_force = force
-        self.emit(QtCore.SIGNAL("forceChanged(int)"), self._current_force)
+        self.force_changed.emit(self._current_force)
 
-    @QtCore.Slot()
+    @Slot()
     def shoot(self):
         if self.is_shooting():
             return
@@ -165,17 +171,17 @@ class CannonField(QtWidgets.QWidget):
         self._shoot_angle = self._current_angle
         self._shoot_force = self._current_force
         self._auto_shoot_timer.start(5)
-        self.emit(QtCore.SIGNAL("canShoot(bool)"), False)
+        self.can_shoot.emit(False)
 
     first_time = True
 
     def new_target(self):
         if CannonField.first_time:
             CannonField.first_time = False
-            midnight = QtCore.QTime(0, 0, 0)
-            random.seed(midnight.secsTo(QtCore.QTime.currentTime()))
+            midnight = QTime(0, 0, 0)
+            random.seed(midnight.secsTo(QTime.currentTime()))
 
-        self.target = QtCore.QPoint(200 + random.randint(0, 190 - 1), 10 + random.randint(0, 255 - 1))
+        self.target = QPoint(200 + random.randint(0, 190 - 1), 10 + random.randint(0, 255 - 1))
         self.update()
 
     def set_game_over(self):
@@ -191,35 +197,35 @@ class CannonField(QtWidgets.QWidget):
             self._auto_shoot_timer.stop()
         self._game_ended = False
         self.update()
-        self.emit(QtCore.SIGNAL("canShoot(bool)"), True)
+        self.can_shoot.emit(True)
 
-    @QtCore.Slot()
+    @Slot()
     def move_shot(self):
-        region = QtGui.QRegion(self.shot_rect())
+        region = QRegion(self.shot_rect())
         self._timer_count += 1
 
         shot_r = self.shot_rect()
 
         if shot_r.intersects(self.target_rect()):
             self._auto_shoot_timer.stop()
-            self.emit(QtCore.SIGNAL("hit()"))
-            self.emit(QtCore.SIGNAL("canShoot(bool)"), True)
+            self.hit.emit()
+            self.can_shoot.emit(True)
         elif shot_r.x() > self.width() or shot_r.y() > self.height():
             self._auto_shoot_timer.stop()
-            self.emit(QtCore.SIGNAL("missed()"))
-            self.emit(QtCore.SIGNAL("canShoot(bool)"), True)
+            self.missed.emit()
+            self.can_shoot.emit(True)
         else:
-            region = region.united(QtGui.QRegion(shot_r))
+            region = region.united(QRegion(shot_r))
 
         self.update(region)
 
     def paintEvent(self, event):
-        painter = QtGui.QPainter(self)
+        painter = QPainter(self)
 
         if self._game_ended:
-            painter.setPen(QtCore.Qt.black)
-            painter.setFont(QtGui.QFont("Courier", 48, QtGui.QFont.Bold))
-            painter.drawText(self.rect(), QtCore.Qt.AlignCenter, "Game Over")
+            painter.setPen(Qt.black)
+            painter.setFont(QFont("Courier", 48, QFont.Bold))
+            painter.drawText(self.rect(), Qt.AlignCenter, "Game Over")
 
         self.paint_cannon(painter)
         if self.is_shooting():
@@ -228,30 +234,30 @@ class CannonField(QtWidgets.QWidget):
             self.paint_target(painter)
 
     def paint_shot(self, painter):
-        painter.setPen(QtCore.Qt.NoPen)
-        painter.setBrush(QtCore.Qt.black)
+        painter.setPen(Qt.NoPen)
+        painter.setBrush(Qt.black)
         painter.drawRect(self.shot_rect())
 
     def paint_target(self, painter):
-        painter.setPen(QtCore.Qt.black)
-        painter.setBrush(QtCore.Qt.red)
+        painter.setPen(Qt.black)
+        painter.setBrush(Qt.red)
         painter.drawRect(self.target_rect())
 
-    barrel_rect = QtCore.QRect(33, -4, 15, 8)
+    barrel_rect = QRect(33, -4, 15, 8)
 
     def paint_cannon(self, painter):
-        painter.setPen(QtCore.Qt.NoPen)
-        painter.setBrush(QtCore.Qt.blue)
+        painter.setPen(Qt.NoPen)
+        painter.setBrush(Qt.blue)
 
         painter.save()
         painter.translate(0, self.height())
-        painter.drawPie(QtCore.QRect(-35, -35, 70, 70), 0, 90 * 16)
+        painter.drawPie(QRect(-35, -35, 70, 70), 0, 90 * 16)
         painter.rotate(-self._current_angle)
         painter.drawRect(CannonField.barrel_rect)
         painter.restore()
 
     def cannon_rect(self):
-        result = QtCore.QRect(0, 0, 50, 50)
+        result = QRect(0, 0, 50, 50)
         result.moveBottomLeft(self.rect().bottomLect())
         return result
 
@@ -260,7 +266,7 @@ class CannonField(QtWidgets.QWidget):
 
         time = self._timer_count / 40.0
         velocity = self._shoot_force
-        radians = self._shoot_angle * 3.14159265 / 180
+        radians = self._shoot_angle * math.pi / 180
 
         velx = velocity * math.cos(radians)
         vely = velocity * math.sin(radians)
@@ -269,13 +275,13 @@ class CannonField(QtWidgets.QWidget):
         x = x0 + velx * time
         y = y0 + vely * time - 0.5 * gravity * time * time
 
-        result = QtCore.QRect(0, 0, 6, 6)
-        result.moveCenter(QtCore.QPoint(round(x), self.height() - 1 - round(y)))
+        result = QRect(0, 0, 6, 6)
+        result.moveCenter(QPoint(round(x), self.height() - 1 - round(y)))
         return result
 
     def target_rect(self):
-        result = QtCore.QRect(0, 0, 20, 10)
-        result.moveCenter(QtCore.QPoint(self.target.x(), self.height() - 1 - self.target.y()))
+        result = QRect(0, 0, 20, 10)
+        result.moveCenter(QPoint(self.target.x(), self.height() - 1 - self.target.y()))
         return result
 
     def game_over(self):
@@ -285,15 +291,14 @@ class CannonField(QtWidgets.QWidget):
         return self._auto_shoot_timer.isActive()
 
 
-class GameBoard(QtWidgets.QWidget):
+class GameBoard(QWidget):
     def __init__(self, parent=None):
-        QtWidgets.QWidget.__init__(self, parent)
+        super().__init__(parent)
 
-        quit = QtWidgets.QPushButton("&Quit")
-        quit.setFont(QtGui.QFont("Times", 18, QtGui.QFont.Bold))
+        quit = QPushButton("&Quit")
+        quit.setFont(QFont("Times", 18, QFont.Bold))
 
-        self.connect(quit, QtCore.SIGNAL("clicked()"),
-                     qApp, QtCore.SLOT("quit()"))
+        quit.clicked.connect(qApp.quit)
 
         angle = LCDRange("ANGLE")
         angle.set_range(5, 70)
@@ -303,37 +308,32 @@ class GameBoard(QtWidgets.QWidget):
 
         self._cannon_field = CannonField()
 
-        self.connect(angle, QtCore.SIGNAL("valueChanged(int)"),
-                     self._cannon_field.set_angle)
-        self.connect(self._cannon_field, QtCore.SIGNAL("angleChanged(int)"),
-                     angle.set_value)
+        angle.value_changed.connect(self._cannon_field.set_angle)
+        self._cannon_field.angle_changed.connect(angle.set_value)
 
-        self.connect(force, QtCore.SIGNAL("valueChanged(int)"),
-                     self._cannon_field.set_force)
-        self.connect(self._cannon_field, QtCore.SIGNAL("forceChanged(int)"),
-                     force.set_value)
+        force.value_changed.connect(self._cannon_field.set_force)
+        self._cannon_field.force_changed.connect(force.set_value)
 
-        self.connect(self._cannon_field, QtCore.SIGNAL("hit()"), self.hit)
-        self.connect(self._cannon_field, QtCore.SIGNAL("missed()"), self.missed)
+        self._cannon_field.hit.connect(self.hit)
+        self._cannon_field.missed.connect(self.missed)
 
-        shoot = QtWidgets.QPushButton("&Shoot")
-        shoot.setFont(QtGui.QFont("Times", 18, QtGui.QFont.Bold))
+        shoot = QPushButton("&Shoot")
+        shoot.setFont(QFont("Times", 18, QFont.Bold))
 
-        self.connect(shoot, QtCore.SIGNAL("clicked()"), self.fire)
-        self.connect(self._cannon_field, QtCore.SIGNAL("canShoot(bool)"),
-                     shoot, QtCore.SLOT("setEnabled(bool)"))
+        shoot.clicked.connect(self.fire)
+        self._cannon_field.can_shoot.connect(shoot.setEnabled)
 
-        restart = QtWidgets.QPushButton("&New Game")
-        restart.setFont(QtGui.QFont("Times", 18, QtGui.QFont.Bold))
+        restart = QPushButton("&New Game")
+        restart.setFont(QFont("Times", 18, QFont.Bold))
 
-        self.connect(restart, QtCore.SIGNAL("clicked()"), self.new_game)
+        restart.clicked.connect(self.new_game)
 
-        self.hits = QtWidgets.QLCDNumber(2)
-        self._shots_left = QtWidgets.QLCDNumber(2)
-        hits_label = QtWidgets.QLabel("HITS")
-        shots_left_label = QtWidgets.QLabel("SHOTS LEFT")
+        self.hits = QLCDNumber(2)
+        self._shots_left = QLCDNumber(2)
+        hits_label = QLabel("HITS")
+        shots_left_label = QLabel("SHOTS LEFT")
 
-        top_layout = QtWidgets.QHBoxLayout()
+        top_layout = QHBoxLayout()
         top_layout.addWidget(shoot)
         top_layout.addWidget(self.hits)
         top_layout.addWidget(hits_label)
@@ -342,17 +342,16 @@ class GameBoard(QtWidgets.QWidget):
         top_layout.addStretch(1)
         top_layout.addWidget(restart)
 
-        left_layout = QtWidgets.QVBoxLayout()
+        left_layout = QVBoxLayout()
         left_layout.addWidget(angle)
         left_layout.addWidget(force)
 
-        grid_layout = QtWidgets.QGridLayout()
+        grid_layout = QGridLayout(self)
         grid_layout.addWidget(quit, 0, 0)
         grid_layout.addLayout(top_layout, 0, 1)
         grid_layout.addLayout(left_layout, 1, 0)
         grid_layout.addWidget(self._cannon_field, 1, 1, 2, 1)
         grid_layout.setColumnStretch(1, 10)
-        self.setLayout(grid_layout)
 
         angle.set_value(60)
         force.set_value(25)
@@ -360,14 +359,14 @@ class GameBoard(QtWidgets.QWidget):
 
         self.new_game()
 
-    @QtCore.Slot()
+    @Slot()
     def fire(self):
         if self._cannon_field.game_over() or self._cannon_field.is_shooting():
             return
         self._shots_left.display(self._shots_left.intValue() - 1)
         self._cannon_field.shoot()
 
-    @QtCore.Slot()
+    @Slot()
     def hit(self):
         self.hits.display(self.hits.intValue() + 1)
         if self._shots_left.intValue() == 0:
@@ -375,12 +374,12 @@ class GameBoard(QtWidgets.QWidget):
         else:
             self._cannon_field.new_target()
 
-    @QtCore.Slot()
+    @Slot()
     def missed(self):
         if self._shots_left.intValue() == 0:
             self._cannon_field.set_game_over()
 
-    @QtCore.Slot()
+    @Slot()
     def new_game(self):
         self._shots_left.display(15)
         self.hits.display(0)
@@ -388,8 +387,9 @@ class GameBoard(QtWidgets.QWidget):
         self._cannon_field.new_target()
 
 
-app = QtWidgets.QApplication(sys.argv)
-board = GameBoard()
-board.setGeometry(100, 100, 500, 355)
-board.show()
-sys.exit(app.exec_())
+if __name__ == '__main__':
+    app = QApplication(sys.argv)
+    board = GameBoard()
+    board.setGeometry(100, 100, 500, 355)
+    board.show()
+    sys.exit(app.exec_())