Port QWidget examples to snake case

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

4 files changed, 121 insertions, 121 deletions

diff --git a/examples/widgets/state-machine/eventtrans/eventtrans.py b/examples/widgets/state-machine/eventtrans/eventtrans.py
index 312b4e258..a014d9356 100644
--- a/examples/widgets/state-machine/eventtrans/eventtrans.py
+++ b/examples/widgets/state-machine/eventtrans/eventtrans.py
@@ -57,24 +57,24 @@ class MainWindow(QMainWindow):
         s2 = QState()
         s2.assignProperty(button, 'text', 'Inside')
 
-        enterTransition = QEventTransition(button, QEvent.Enter)
-        enterTransition.setTargetState(s2)
-        s1.addTransition(enterTransition)
+        enter_transition = QEventTransition(button, QEvent.Enter)
+        enter_transition.setTargetState(s2)
+        s1.addTransition(enter_transition)
 
-        leaveTransition = QEventTransition(button, QEvent.Leave)
-        leaveTransition.setTargetState(s1)
-        s2.addTransition(leaveTransition)
+        leave_transition = QEventTransition(button, QEvent.Leave)
+        leave_transition.setTargetState(s1)
+        s2.addTransition(leave_transition)
 
         s3 = QState()
         s3.assignProperty(button, 'text', 'Pressing...')
 
-        pressTransition = QEventTransition(button, QEvent.MouseButtonPress)
-        pressTransition.setTargetState(s3)
-        s2.addTransition(pressTransition)
+        press_transition = QEventTransition(button, QEvent.MouseButtonPress)
+        press_transition.setTargetState(s3)
+        s2.addTransition(press_transition)
 
-        releaseTransition = QEventTransition(button, QEvent.MouseButtonRelease)
-        releaseTransition.setTargetState(s2)
-        s3.addTransition(releaseTransition)
+        release_transition = QEventTransition(button, QEvent.MouseButtonRelease)
+        release_transition.setTargetState(s2)
+        s3.addTransition(release_transition)
 
         machine.addState(s1)
         machine.addState(s2)
@@ -90,5 +90,5 @@ if __name__ == '__main__':
     import sys
 
     app = QApplication(sys.argv)
-    mainWin = MainWindow()
+    main_win = MainWindow()
     sys.exit(app.exec_())
diff --git a/examples/widgets/state-machine/factstates/factstates.py b/examples/widgets/state-machine/factstates/factstates.py
index 3608f2a49..dfde45781 100644
--- a/examples/widgets/state-machine/factstates/factstates.py
+++ b/examples/widgets/state-machine/factstates/factstates.py
@@ -47,28 +47,28 @@ from PySide6.QtStateMachine import (QFinalState, QSignalTransition, QState,
 
 
 class Factorial(QObject):
-    xChanged = Signal(int)
+    x_changed = Signal(int)
     def __init__(self):
         super(Factorial, self).__init__()
         self.xval = -1
         self.facval = 1
-    def getX(self):
+    def get_x(self):
         return self.xval
-    def setX(self, x):
+    def set_x(self, x):
         if self.xval == x:
             return
         self.xval = x
-        self.xChanged.emit(x)
-    x = Property(int, getX, setX)
-    def getFact(self):
+        self.x_changed.emit(x)
+    x = Property(int, get_x, set_x)
+    def get_fact(self):
         return self.facval
-    def setFact(self, fac):
+    def set_fact(self, fac):
         self.facval = fac
-    fac = Property(int, getFact, setFact)
+    fac = Property(int, get_fact, set_fact)
 
 class FactorialLoopTransition(QSignalTransition):
     def __init__(self, fact):
-        super(FactorialLoopTransition, self).__init__(fact, SIGNAL('xChanged(int)'))
+        super(FactorialLoopTransition, self).__init__(fact, SIGNAL('x_changed(int)'))
         self.fact = fact
     def eventTest(self, e):
         if not super(FactorialLoopTransition, self).eventTest(e):
@@ -82,7 +82,7 @@ class FactorialLoopTransition(QSignalTransition):
 
 class FactorialDoneTransition(QSignalTransition):
     def __init__(self, fact):
-        super(FactorialDoneTransition, self).__init__(fact, SIGNAL('xChanged(int)'))
+        super(FactorialDoneTransition, self).__init__(fact, SIGNAL('x_changed(int)'))
         self.fact = fact
     def eventTest(self, e):
         if not super(FactorialDoneTransition, self).eventTest(e):
@@ -103,9 +103,9 @@ if __name__ == '__main__':
     compute.addTransition(FactorialLoopTransition(factorial))
 
     done = QFinalState(machine)
-    doneTransition = FactorialDoneTransition(factorial)
-    doneTransition.setTargetState(done)
-    compute.addTransition(doneTransition)
+    done_transition = FactorialDoneTransition(factorial)
+    done_transition.setTargetState(done)
+    compute.addTransition(done_transition)
 
     machine.setInitialState(compute)
     machine.finished.connect(app.quit)
diff --git a/examples/widgets/state-machine/rogue/rogue.py b/examples/widgets/state-machine/rogue/rogue.py
index b830d6023..c214b897b 100644
--- a/examples/widgets/state-machine/rogue/rogue.py
+++ b/examples/widgets/state-machine/rogue/rogue.py
@@ -61,13 +61,13 @@ class MovementTransition(QEventTransition):
     def onTransition(self, event):
         key = event.event().key()
         if key == Qt.Key_4:
-            self.window.movePlayer(self.window.Left)
+            self.window.move_player(self.window.left)
         if key == Qt.Key_8:
-            self.window.movePlayer(self.window.Up)
+            self.window.move_player(self.window.Up)
         if key == Qt.Key_6:
-            self.window.movePlayer(self.window.Right)
+            self.window.move_player(self.window.right)
         if key == Qt.Key_2:
-            self.window.movePlayer(self.window.Down)
+            self.window.move_player(self.window.down)
 
 class Custom(QState):
     def __init__(self, parent, mw):
@@ -84,7 +84,7 @@ class MainWindow(QMainWindow):
         self.pY = 5
         self.width = 35
         self.height = 20
-        self.statusStr = ''
+        self._status_str = ''
 
         font = QFont()
         if 'Monospace' in QFontDatabase.families():
@@ -95,10 +95,10 @@ class MainWindow(QMainWindow):
                     font = QFont(family, 12)
         self.setFont(font)
 
-        self.setupMap()
-        self.buildMachine()
+        self.setup_map()
+        self.build_machine()
         self.show()
-    def setupMap(self):
+    def setup_map(self):
         self.map = []
         generator = QRandomGenerator().global_()
         for x in range(self.width):
@@ -111,38 +111,38 @@ class MainWindow(QMainWindow):
                     column.append('.')
             self.map.append(column)
 
-    def buildMachine(self):
+    def build_machine(self):
         machine = QStateMachine(self)
 
-        inputState = Custom(machine, self)
+        input_state = Custom(machine, self)
         # this line sets the status
         self.status = 'hello!'
         # however this line does not
-        inputState.assignProperty(self, 'status', 'Move the rogue with 2, 4, 6, and 8')
+        input_state.assignProperty(self, 'status', 'Move the rogue with 2, 4, 6, and 8')
 
-        machine.setInitialState(inputState)
+        machine.setInitialState(input_state)
         machine.start()
 
         transition = MovementTransition(self)
-        inputState.addTransition(transition)
+        input_state.addTransition(transition)
 
-        quitState = QState(machine)
-        quitState.assignProperty(self, 'status', 'Really quit(y/n)?')
+        quit_state = QState(machine)
+        quit_state.assignProperty(self, 'status', 'Really quit(y/n)?')
 
-        yesTransition = QKeyEventTransition(self, QEvent.KeyPress, Qt.Key_Y)
-        self.finalState = QFinalState(machine)
-        yesTransition.setTargetState(self.finalState)
-        quitState.addTransition(yesTransition)
+        yes_transition = QKeyEventTransition(self, QEvent.KeyPress, Qt.Key_Y)
+        self._final_state = QFinalState(machine)
+        yes_transition.setTargetState(self._final_state)
+        quit_state.addTransition(yes_transition)
 
-        noTransition = QKeyEventTransition(self, QEvent.KeyPress, Qt.Key_N)
-        noTransition.setTargetState(inputState)
-        quitState.addTransition(noTransition)
+        no_transition = QKeyEventTransition(self, QEvent.KeyPress, Qt.Key_N)
+        no_transition.setTargetState(input_state)
+        quit_state.addTransition(no_transition)
 
-        quitTransition = QKeyEventTransition(self, QEvent.KeyPress, Qt.Key_Q)
-        quitTransition.setTargetState(quitState)
-        inputState.addTransition(quitTransition)
+        quit_transition = QKeyEventTransition(self, QEvent.KeyPress, Qt.Key_Q)
+        quit_transition.setTargetState(quit_state)
+        input_state.addTransition(quit_transition)
 
-        machine.setInitialState(inputState)
+        machine.setInitialState(input_state)
         machine.finished.connect(qApp.quit)
         machine.start()
 
@@ -153,53 +153,53 @@ class MainWindow(QMainWindow):
     def paintEvent(self, event):
         metrics = QFontMetrics(self.font())
         painter = QPainter(self)
-        fontHeight = metrics.height()
-        fontWidth = metrics.horizontalAdvance('X')
+        font_height = metrics.height()
+        font_width = metrics.horizontalAdvance('X')
 
         painter.fillRect(self.rect(), Qt.black)
         painter.setPen(Qt.white)
 
-        yPos = fontHeight
-        painter.drawText(QPoint(0, yPos), self.status)
+        y_pos = font_height
+        painter.drawText(QPoint(0, y_pos), self.status)
         for y in range(self.height):
-            yPos += fontHeight
-            xPos = 0
+            y_pos += font_height
+            x_pos = 0
             for x in range(self.width):
                 if y == self.pY and x == self.pX:
-                    xPos += fontWidth
+                    x_pos += font_width
                     continue
-                painter.drawText(QPoint(xPos, yPos), self.map[x][y])
-                xPos += fontWidth
-        painter.drawText(QPoint(self.pX * fontWidth, (self.pY + 2) * fontHeight), '@')
-    def movePlayer(self, direction):
-        if direction == self.Left:
+                painter.drawText(QPoint(x_pos, y_pos), self.map[x][y])
+                x_pos += font_width
+        painter.drawText(QPoint(self.pX * font_width, (self.pY + 2) * font_height), '@')
+    def move_player(self, direction):
+        if direction == self.left:
             if self.map[self.pX - 1][self.pY] != '#':
                 self.pX -= 1
-        elif direction == self.Right:
+        elif direction == self.right:
             if self.map[self.pX + 1][self.pY] != '#':
                 self.pX += 1
         elif direction == self.Up:
             if self.map[self.pX][self.pY - 1] != '#':
                 self.pY -= 1
-        elif direction == self.Down:
+        elif direction == self.down:
             if self.map[self.pX][self.pY + 1] != '#':
                 self.pY += 1
         self.repaint()
-    def getStatus(self):
-        return self.statusStr
-    def setStatus(self, status):
-        self.statusStr = status
+    def get_status(self):
+        return self._status_str
+    def set_status(self, status):
+        self._status_str = status
         self.repaint()
-    status = Property(str, getStatus, setStatus)
+    status = Property(str, get_status, set_status)
     Up = 0
-    Down = 1
-    Left = 2
-    Right = 3
-    Width = 35
-    Height = 20
+    down = 1
+    left = 2
+    right = 3
+    width = 35
+    height = 20
 
 if __name__ == '__main__':
     import sys
     app = QApplication(sys.argv)
-    mainWin = MainWindow()
+    main_win = MainWindow()
     sys.exit(app.exec_())
diff --git a/examples/widgets/state-machine/trafficlight/trafficlight.py b/examples/widgets/state-machine/trafficlight/trafficlight.py
index 3631fdbbb..d642261e9 100644
--- a/examples/widgets/state-machine/trafficlight/trafficlight.py
+++ b/examples/widgets/state-machine/trafficlight/trafficlight.py
@@ -50,58 +50,58 @@ class LightWidget(QWidget):
     def __init__(self, color):
         super(LightWidget, self).__init__()
         self.color = color
-        self.onVal = False
-    def isOn(self):
-        return self.onVal
-    def setOn(self, on):
-        if self.onVal == on:
+        self._on_val = False
+    def is_on(self):
+        return self._on_val
+    def set_on(self, on):
+        if self._on_val == on:
             return
-        self.onVal = on
+        self._on_val = on
         self.update()
     @Slot()
-    def turnOff(self):
-        self.setOn(False)
+    def turn_off(self):
+        self.set_on(False)
     @Slot()
-    def turnOn(self):
-        self.setOn(True)
+    def turn_on(self):
+        self.set_on(True)
     def paintEvent(self, e):
-        if not self.onVal:
+        if not self._on_val:
             return
         painter = QPainter(self)
         painter.setRenderHint(QPainter.Antialiasing)
         painter.setBrush(self.color)
         painter.drawEllipse(0, 0, self.width(), self.height())
 
-    on = Property(bool, isOn, setOn)
+    on = Property(bool, is_on, set_on)
 
 class TrafficLightWidget(QWidget):
     def __init__(self):
         super(TrafficLightWidget, self).__init__()
         vbox = QVBoxLayout(self)
-        self.redLight = LightWidget(Qt.red)
-        vbox.addWidget(self.redLight)
-        self.yellowLight = LightWidget(Qt.yellow)
-        vbox.addWidget(self.yellowLight)
-        self.greenLight = LightWidget(Qt.green)
-        vbox.addWidget(self.greenLight)
+        self._red_light = LightWidget(Qt.red)
+        vbox.addWidget(self._red_light)
+        self._yellow_light = LightWidget(Qt.yellow)
+        vbox.addWidget(self._yellow_light)
+        self._green_light = LightWidget(Qt.green)
+        vbox.addWidget(self._green_light)
         pal = QPalette()
         pal.setColor(QPalette.Window, Qt.black)
         self.setPalette(pal)
         self.setAutoFillBackground(True)
 
-def createLightState(light, duration, parent=None):
-    lightState = QState(parent)
-    timer = QTimer(lightState)
+def create_light_state(light, duration, parent=None):
+    light_state = QState(parent)
+    timer = QTimer(light_state)
     timer.setInterval(duration)
     timer.setSingleShot(True)
-    timing = QState(lightState)
-    timing.entered.connect(light.turnOn)
+    timing = QState(light_state)
+    timing.entered.connect(light.turn_on)
     timing.entered.connect(timer.start)
-    timing.exited.connect(light.turnOff)
-    done = QFinalState(lightState)
+    timing.exited.connect(light.turn_off)
+    done = QFinalState(light_state)
     timing.addTransition(timer, SIGNAL('timeout()'), done)
-    lightState.setInitialState(timing)
-    return lightState
+    light_state.setInitialState(timing)
+    return light_state
 
 class TrafficLight(QWidget):
     def __init__(self):
@@ -112,24 +112,24 @@ class TrafficLight(QWidget):
         vbox.setContentsMargins(0, 0, 0, 0)
 
         machine = QStateMachine(self)
-        redGoingYellow = createLightState(widget.redLight, 1000)
-        redGoingYellow.setObjectName('redGoingYellow')
-        yellowGoingGreen = createLightState(widget.redLight, 1000)
-        yellowGoingGreen.setObjectName('redGoingYellow')
-        redGoingYellow.addTransition(redGoingYellow, SIGNAL('finished()'), yellowGoingGreen)
-        greenGoingYellow = createLightState(widget.yellowLight, 3000)
-        greenGoingYellow.setObjectName('redGoingYellow')
-        yellowGoingGreen.addTransition(yellowGoingGreen, SIGNAL('finished()'), greenGoingYellow)
-        yellowGoingRed = createLightState(widget.greenLight, 1000)
-        yellowGoingRed.setObjectName('redGoingYellow')
-        greenGoingYellow.addTransition(greenGoingYellow, SIGNAL('finished()'), yellowGoingRed)
-        yellowGoingRed.addTransition(yellowGoingRed, SIGNAL('finished()'), redGoingYellow)
+        red_going_yellow = create_light_state(widget._red_light, 1000)
+        red_going_yellow.setObjectName('redGoingYellow')
+        yellow_going_green = create_light_state(widget._red_light, 1000)
+        yellow_going_green.setObjectName('redGoingYellow')
+        red_going_yellow.addTransition(red_going_yellow, SIGNAL('finished()'), yellow_going_green)
+        green_going_yellow = create_light_state(widget._yellow_light, 3000)
+        green_going_yellow.setObjectName('redGoingYellow')
+        yellow_going_green.addTransition(yellow_going_green, SIGNAL('finished()'), green_going_yellow)
+        yellow_going_red = create_light_state(widget._green_light, 1000)
+        yellow_going_red.setObjectName('redGoingYellow')
+        green_going_yellow.addTransition(green_going_yellow, SIGNAL('finished()'), yellow_going_red)
+        yellow_going_red.addTransition(yellow_going_red, SIGNAL('finished()'), red_going_yellow)
 
-        machine.addState(redGoingYellow)
-        machine.addState(yellowGoingGreen)
-        machine.addState(greenGoingYellow)
-        machine.addState(yellowGoingRed)
-        machine.setInitialState(redGoingYellow)
+        machine.addState(red_going_yellow)
+        machine.addState(yellow_going_green)
+        machine.addState(green_going_yellow)
+        machine.addState(yellow_going_red)
+        machine.setInitialState(red_going_yellow)
         machine.start()
 
 if __name__ == '__main__':