Remaining QGraphicsView examples: Use per-class imports

As a drive by, fix breakages caused by removed APIs and oversights
of the snake case change and wrap some long lines.

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

3 files changed, 340 insertions, 308 deletions

diff --git a/examples/widgets/graphicsview/anchorlayout/anchorlayout.py b/examples/widgets/graphicsview/anchorlayout/anchorlayout.py
index f5579ec99..80a603e86 100644
--- a/examples/widgets/graphicsview/anchorlayout/anchorlayout.py
+++ b/examples/widgets/graphicsview/anchorlayout/anchorlayout.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,86 +40,89 @@
 ##
 #############################################################################
 
-from PySide6 import QtCore, QtWidgets
+import sys
+
+from PySide6.QtCore import QSizeF, Qt
+from PySide6.QtWidgets import (QApplication, QGraphicsAnchorLayout,
+                               QGraphicsProxyWidget, QGraphicsScene,
+                               QGraphicsView, QGraphicsWidget,
+                               QPushButton, QSizePolicy, QWidget)
 
 
 def create_item(minimum, preferred, maximum, name):
-    w = QtWidgets.QGraphicsProxyWidget()
+    w = QGraphicsProxyWidget()
 
-    w.setWidget(QtWidgets.QPushButton(name))
+    w.setWidget(QPushButton(name))
     w.setMinimumSize(minimum)
     w.setPreferredSize(preferred)
     w.setMaximumSize(maximum)
-    w.setSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Preferred)
+    w.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
 
     return w
 
 
 if __name__ == '__main__':
+    app = QApplication(sys.argv)
 
-    import sys
-
-    app = QtWidgets.QApplication(sys.argv)
-
-    scene = QtWidgets.QGraphicsScene()
+    scene = QGraphicsScene()
     scene.setSceneRect(0, 0, 800, 480)
 
-    min_size = QtCore.QSizeF(30, 100)
-    pref_size = QtCore.QSizeF(210, 100)
-    max_size = QtCore.QSizeF(300, 100)
+    min_size = QSizeF(30, 100)
+    pref_size = QSizeF(210, 100)
+    max_size = QSizeF(300, 100)
 
     a = create_item(min_size, pref_size, max_size, "A")
     b = create_item(min_size, pref_size, max_size, "B")
     c = create_item(min_size, pref_size, max_size, "C")
     d = create_item(min_size, pref_size, max_size, "D")
     e = create_item(min_size, pref_size, max_size, "E")
-    f = create_item(QtCore.QSizeF(30, 50), QtCore.QSizeF(150, 50), max_size, "F")
-    g = create_item(QtCore.QSizeF(30, 50), QtCore.QSizeF(30, 100), max_size, "G")
+    f = create_item(QSizeF(30, 50), QSizeF(150, 50), max_size, "F")
+    g = create_item(QSizeF(30, 50), QSizeF(30, 100), max_size, "G")
 
-    l = QtWidgets.QGraphicsAnchorLayout()
+    l = QGraphicsAnchorLayout()
     l.setSpacing(0)
 
-    w = QtWidgets.QGraphicsWidget(None, QtCore.Qt.Window)
+    w = QGraphicsWidget(None, Qt.Window)
     w.setPos(20, 20)
     w.setLayout(l)
 
     # Vertical.
-    l.addAnchor(a, QtCore.Qt.AnchorTop, l, QtCore.Qt.AnchorTop)
-    l.addAnchor(b, QtCore.Qt.AnchorTop, l, QtCore.Qt.AnchorTop)
+    l.addAnchor(a, Qt.AnchorTop, l, Qt.AnchorTop)
+    l.addAnchor(b, Qt.AnchorTop, l, Qt.AnchorTop)
 
-    l.addAnchor(c, QtCore.Qt.AnchorTop, a, QtCore.Qt.AnchorBottom)
-    l.addAnchor(c, QtCore.Qt.AnchorTop, b, QtCore.Qt.AnchorBottom)
-    l.addAnchor(c, QtCore.Qt.AnchorBottom, d, QtCore.Qt.AnchorTop)
-    l.addAnchor(c, QtCore.Qt.AnchorBottom, e, QtCore.Qt.AnchorTop)
+    l.addAnchor(c, Qt.AnchorTop, a, Qt.AnchorBottom)
+    l.addAnchor(c, Qt.AnchorTop, b, Qt.AnchorBottom)
+    l.addAnchor(c, Qt.AnchorBottom, d, Qt.AnchorTop)
+    l.addAnchor(c, Qt.AnchorBottom, e, Qt.AnchorTop)
 
-    l.addAnchor(d, QtCore.Qt.AnchorBottom, l, QtCore.Qt.AnchorBottom)
-    l.addAnchor(e, QtCore.Qt.AnchorBottom, l, QtCore.Qt.AnchorBottom)
+    l.addAnchor(d, Qt.AnchorBottom, l, Qt.AnchorBottom)
+    l.addAnchor(e, Qt.AnchorBottom, l, Qt.AnchorBottom)
 
-    l.addAnchor(c, QtCore.Qt.AnchorTop, f, QtCore.Qt.AnchorTop)
-    l.addAnchor(c, QtCore.Qt.AnchorVerticalCenter, f, QtCore.Qt.AnchorBottom)
-    l.addAnchor(f, QtCore.Qt.AnchorBottom, g, QtCore.Qt.AnchorTop)
-    l.addAnchor(c, QtCore.Qt.AnchorBottom, g, QtCore.Qt.AnchorBottom)
+    l.addAnchor(c, Qt.AnchorTop, f, Qt.AnchorTop)
+    l.addAnchor(c, Qt.AnchorVerticalCenter, f, Qt.AnchorBottom)
+    l.addAnchor(f, Qt.AnchorBottom, g, Qt.AnchorTop)
+    l.addAnchor(c, Qt.AnchorBottom, g, Qt.AnchorBottom)
 
     # Horizontal.
-    l.addAnchor(l, QtCore.Qt.AnchorLeft, a, QtCore.Qt.AnchorLeft)
-    l.addAnchor(l, QtCore.Qt.AnchorLeft, d, QtCore.Qt.AnchorLeft)
-    l.addAnchor(a, QtCore.Qt.AnchorRight, b, QtCore.Qt.AnchorLeft)
+    l.addAnchor(l, Qt.AnchorLeft, a, Qt.AnchorLeft)
+    l.addAnchor(l, Qt.AnchorLeft, d, Qt.AnchorLeft)
+    l.addAnchor(a, Qt.AnchorRight, b, Qt.AnchorLeft)
 
-    l.addAnchor(a, QtCore.Qt.AnchorRight, c, QtCore.Qt.AnchorLeft)
-    l.addAnchor(c, QtCore.Qt.AnchorRight, e, QtCore.Qt.AnchorLeft)
+    l.addAnchor(a, Qt.AnchorRight, c, Qt.AnchorLeft)
+    l.addAnchor(c, Qt.AnchorRight, e, Qt.AnchorLeft)
 
-    l.addAnchor(b, QtCore.Qt.AnchorRight, l, QtCore.Qt.AnchorRight)
-    l.addAnchor(e, QtCore.Qt.AnchorRight, l, QtCore.Qt.AnchorRight)
-    l.addAnchor(d, QtCore.Qt.AnchorRight, e, QtCore.Qt.AnchorLeft)
+    l.addAnchor(b, Qt.AnchorRight, l, Qt.AnchorRight)
+    l.addAnchor(e, Qt.AnchorRight, l, Qt.AnchorRight)
+    l.addAnchor(d, Qt.AnchorRight, e, Qt.AnchorLeft)
 
-    l.addAnchor(l, QtCore.Qt.AnchorLeft, f, QtCore.Qt.AnchorLeft)
-    l.addAnchor(l, QtCore.Qt.AnchorLeft, g, QtCore.Qt.AnchorLeft)
-    l.addAnchor(f, QtCore.Qt.AnchorRight, g, QtCore.Qt.AnchorRight)
+    l.addAnchor(l, Qt.AnchorLeft, f, Qt.AnchorLeft)
+    l.addAnchor(l, Qt.AnchorLeft, g, Qt.AnchorLeft)
+    l.addAnchor(f, Qt.AnchorRight, g, Qt.AnchorRight)
 
     scene.addItem(w)
-    scene.setBackgroundBrush(QtCore.Qt.darkGreen)
+    scene.setBackgroundBrush(Qt.darkGreen)
 
-    view = QtWidgets.QGraphicsView(scene)
+    view = QGraphicsView(scene)
     view.show()
 
     sys.exit(app.exec_())
diff --git a/examples/widgets/graphicsview/diagramscene/diagramscene.py b/examples/widgets/graphicsview/diagramscene/diagramscene.py
index d2c7f3383..c6f0b725b 100644
--- a/examples/widgets/graphicsview/diagramscene/diagramscene.py
+++ b/examples/widgets/graphicsview/diagramscene/diagramscene.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,24 +41,36 @@
 #############################################################################
 
 import math
-
-from PySide6 import QtCore, QtGui, QtWidgets
+import sys
+
+from PySide6.QtCore import (QLineF, QPointF, QRect, QRectF, QSize, QSizeF, Qt,
+                            Signal)
+from PySide6.QtGui import (QAction, QColor, QFont, QIcon, QIntValidator,
+                           QPainter, QPainterPath, QPen, QPixmap, QPolygonF)
+from PySide6.QtWidgets import (QApplication, QButtonGroup, QComboBox,
+                               QFontComboBox, QGraphicsAnchorLayout,
+                               QGraphicsItem, QGraphicsLineItem,
+                               QGraphicsPolygonItem, QGraphicsTextItem,
+                               QGraphicsScene, QGraphicsView, QGridLayout,
+                               QHBoxLayout, QLabel, QMainWindow, QMenu,
+                               QMessageBox, QSizePolicy, QToolBox, QToolButton,
+                               QWidget)
 
 import diagramscene_rc
 
 
-class Arrow(QtWidgets.QGraphicsLineItem):
+class Arrow(QGraphicsLineItem):
     def __init__(self, startItem, endItem, parent=None, scene=None):
         super(Arrow, self).__init__(parent, scene)
 
-        self._arrow_head = QtGui.QPolygonF()
+        self._arrow_head = QPolygonF()
 
         self._my_start_item = startItem
         self._my_end_item = endItem
-        self.setFlag(QtWidgets.QGraphicsItem.ItemIsSelectable, True)
-        self._my_color = QtCore.Qt.black
-        self.setPen(QtGui.QPen(self._my_color, 2, QtCore.Qt.SolidLine,
-                QtCore.Qt.RoundCap, QtCore.Qt.RoundJoin))
+        self.setFlag(QGraphicsItem.ItemIsSelectable, True)
+        self._my_color = Qt.black
+        self.setPen(QPen(self._my_color, 2, Qt.SolidLine,
+                Qt.RoundCap, Qt.RoundJoin))
 
     def set_color(self, color):
         self._my_color = color
@@ -73,7 +85,8 @@ class Arrow(QtWidgets.QGraphicsLineItem):
         extra = (self.pen().width() + 20) / 2.0
         p1 = self.line().p1()
         p2 = self.line().p2()
-        return QtCore.QRectF(p1, QtCore.QSizeF(p2.x() - p1.x(), p2.y() - p1.y())).normalized().adjusted(-extra, -extra, extra, extra)
+        rect = QRectF(p1, QSizeF(p2.x() - p1.x(), p2.y() - p1.y()))
+        return rect.normalized().adjusted(-extra, -extra, extra, extra)
 
     def shape(self):
         path = super(Arrow, self).shape()
@@ -81,8 +94,9 @@ class Arrow(QtWidgets.QGraphicsLineItem):
         return path
 
     def update_position(self):
-        line = QtCore.QLineF(self.mapFromItem(self._my_start_item, 0, 0), self.mapFromItem(self._my_end_item, 0, 0))
-        self.setLine(line)
+        start = self.mapFromItem(self._my_start_item, 0, 0)
+        end = self.mapFromItem(self._my_end_item, 0, 0)
+        self.setLine(QLineF(start, end))
 
     def paint(self, painter, option, widget=None):
         if (self._my_start_item.collidesWithItem(self._my_end_item)):
@@ -97,30 +111,33 @@ class Arrow(QtWidgets.QGraphicsLineItem):
         painter.setPen(my_pen)
         painter.setBrush(self._my_color)
 
-        center_line = QtCore.QLineF(my_start_item.pos(), my_end_item.pos())
+        center_line = QLineF(my_start_item.pos(), my_end_item.pos())
         end_polygon = my_end_item.polygon()
         p1 = end_polygon.at(0) + my_end_item.pos()
 
-        intersect_point = QtCore.QPointF()
+        intersect_point = QPointF()
         for i in end_polygon:
             p2 = i + my_end_item.pos()
-            poly_line = QtCore.QLineF(p1, p2)
-            intersectType, intersect_point = poly_line.intersect(center_line)
-            if intersectType == QtCore.QLineF.BoundedIntersection:
+            poly_line = QLineF(p1, p2)
+            intersectType, intersect_point = poly_line.intersects(center_line)
+            if intersectType == QLineF.BoundedIntersection:
                 break
             p1 = p2
 
-        self.setLine(QtCore.QLineF(intersect_point, my_start_item.pos()))
+        self.setLine(QLineF(intersect_point, my_start_item.pos()))
         line = self.line()
 
         angle = math.acos(line.dx() / line.length())
         if line.dy() >= 0:
             angle = (math.pi * 2.0) - angle
 
-        arrow_p1 = line.p1() + QtCore.QPointF(math.sin(angle + math.pi / 3.0) * arrow_size,
-                                        math.cos(angle + math.pi / 3) * arrow_size)
-        arrow_p2 = line.p1() + QtCore.QPointF(math.sin(angle + math.pi - math.pi / 3.0) * arrow_size,
-                                        math.cos(angle + math.pi - math.pi / 3.0) * arrow_size)
+
+        arrow_head1 = QPointF(math.sin(angle + math.pi / 3.0) * arrow_size,
+                              math.cos(angle + math.pi / 3) * arrow_size)
+        arrow_p1 = line.p1() + arrow_head1
+        arrow_head2 = QPointF(math.sin(angle + math.pi - math.pi / 3.0) * arrow_size,
+                              math.cos(angle + math.pi - math.pi / 3.0) * arrow_size)
+        arrow_p2 = line.p1() + arrow_head2
 
         self._arrow_head.clear()
         for point in [line.p1(), arrow_p1, arrow_p2]:
@@ -129,42 +146,42 @@ class Arrow(QtWidgets.QGraphicsLineItem):
         painter.drawLine(line)
         painter.drawPolygon(self._arrow_head)
         if self.isSelected():
-            painter.setPen(QtGui.QPen(my_color, 1, QtCore.Qt.DashLine))
-            my_line = QtCore.QLineF(line)
+            painter.setPen(QPen(my_color, 1, Qt.DashLine))
+            my_line = QLineF(line)
             my_line.translate(0, 4.0)
             painter.drawLine(my_line)
             my_line.translate(0,-8.0)
             painter.drawLine(my_line)
 
 
-class DiagramTextItem(QtWidgets.QGraphicsTextItem):
-    lost_focus = QtCore.Signal(QtWidgets.QGraphicsTextItem)
+class DiagramTextItem(QGraphicsTextItem):
+    lost_focus = Signal(QGraphicsTextItem)
 
-    selected_change = QtCore.Signal(QtWidgets.QGraphicsItem)
+    selected_change = Signal(QGraphicsItem)
 
     def __init__(self, parent=None, scene=None):
         super(DiagramTextItem, self).__init__(parent, scene)
 
-        self.setFlag(QtWidgets.QGraphicsItem.ItemIsMovable)
-        self.setFlag(QtWidgets.QGraphicsItem.ItemIsSelectable)
+        self.setFlag(QGraphicsItem.ItemIsMovable)
+        self.setFlag(QGraphicsItem.ItemIsSelectable)
 
     def itemChange(self, change, value):
-        if change == QtWidgets.QGraphicsItem.ItemSelectedChange:
+        if change == QGraphicsItem.ItemSelectedChange:
             self.selected_change.emit(self)
         return value
 
     def focusOutEvent(self, event):
-        self.setTextInteractionFlags(QtCore.Qt.NoTextInteraction)
+        self.setTextInteractionFlags(Qt.NoTextInteraction)
         self.lost_focus.emit(self)
         super(DiagramTextItem, self).focusOutEvent(event)
 
     def mouseDoubleClickEvent(self, event):
-        if self.textInteractionFlags() == QtCore.Qt.NoTextInteraction:
-            self.setTextInteractionFlags(QtCore.Qt.TextEditorInteraction)
+        if self.textInteractionFlags() == Qt.NoTextInteraction:
+            self.setTextInteractionFlags(Qt.TextEditorInteraction)
         super(DiagramTextItem, self).mouseDoubleClickEvent(event)
 
 
-class DiagramItem(QtWidgets.QGraphicsPolygonItem):
+class DiagramItem(QGraphicsPolygonItem):
     Step, Conditional, StartEnd, Io = range(4)
 
     def __init__(self, diagram_type, contextMenu, parent=None, scene=None):
@@ -175,7 +192,7 @@ class DiagramItem(QtWidgets.QGraphicsPolygonItem):
         self.diagram_type = diagram_type
         self._my_context_menu = contextMenu
 
-        path = QtGui.QPainterPath()
+        path = QPainterPath()
         if self.diagram_type == self.StartEnd:
             path.moveTo(200, 50)
             path.arcTo(150, 0, 50, 50, 0, 90)
@@ -185,24 +202,24 @@ class DiagramItem(QtWidgets.QGraphicsPolygonItem):
             path.lineTo(200, 25)
             self._my_polygon = path.toFillPolygon()
         elif self.diagram_type == self.Conditional:
-            self._my_polygon = QtGui.QPolygonF([
-                    QtCore.QPointF(-100, 0), QtCore.QPointF(0, 100),
-                    QtCore.QPointF(100, 0), QtCore.QPointF(0, -100),
-                    QtCore.QPointF(-100, 0)])
+            self._my_polygon = QPolygonF([
+                    QPointF(-100, 0), QPointF(0, 100),
+                    QPointF(100, 0), QPointF(0, -100),
+                    QPointF(-100, 0)])
         elif self.diagram_type == self.Step:
-            self._my_polygon = QtGui.QPolygonF([
-                    QtCore.QPointF(-100, -100), QtCore.QPointF(100, -100),
-                    QtCore.QPointF(100, 100), QtCore.QPointF(-100, 100),
-                    QtCore.QPointF(-100, -100)])
+            self._my_polygon = QPolygonF([
+                    QPointF(-100, -100), QPointF(100, -100),
+                    QPointF(100, 100), QPointF(-100, 100),
+                    QPointF(-100, -100)])
         else:
-            self._my_polygon = QtGui.QPolygonF([
-                    QtCore.QPointF(-120, -80), QtCore.QPointF(-70, 80),
-                    QtCore.QPointF(120, 80), QtCore.QPointF(70, -80),
-                    QtCore.QPointF(-120, -80)])
+            self._my_polygon = QPolygonF([
+                    QPointF(-120, -80), QPointF(-70, 80),
+                    QPointF(120, 80), QPointF(70, -80),
+                    QPointF(-120, -80)])
 
         self.setPolygon(self._my_polygon)
-        self.setFlag(QtWidgets.QGraphicsItem.ItemIsMovable, True)
-        self.setFlag(QtWidgets.QGraphicsItem.ItemIsSelectable, True)
+        self.setFlag(QGraphicsItem.ItemIsMovable, True)
+        self.setFlag(QGraphicsItem.ItemIsSelectable, True)
 
     def remove_arrow(self, arrow):
         try:
@@ -212,18 +229,18 @@ class DiagramItem(QtWidgets.QGraphicsPolygonItem):
 
     def remove_arrows(self):
         for arrow in self.arrows[:]:
-            arrow.startItem().removeArrow(arrow)
-            arrow.endItem().removeArrow(arrow)
+            arrow.start_item().remove_arrow(arrow)
+            arrow.end_item().remove_arrow(arrow)
             self.scene().removeItem(arrow)
 
     def add_arrow(self, arrow):
         self.arrows.append(arrow)
 
     def image(self):
-        pixmap = QtGui.QPixmap(250, 250)
-        pixmap.fill(QtCore.Qt.transparent)
-        painter = QtGui.QPainter(pixmap)
-        painter.setPen(QtGui.QPen(QtCore.Qt.black, 8))
+        pixmap = QPixmap(250, 250)
+        pixmap.fill(Qt.transparent)
+        painter = QPainter(pixmap)
+        painter.setPen(QPen(Qt.black, 8))
         painter.translate(125, 125)
         painter.drawPolyline(self._my_polygon)
         return pixmap
@@ -234,21 +251,21 @@ class DiagramItem(QtWidgets.QGraphicsPolygonItem):
         self._my_context_menu.exec_(event.screenPos())
 
     def itemChange(self, change, value):
-        if change == QtWidgets.QGraphicsItem.ItemPositionChange:
+        if change == QGraphicsItem.ItemPositionChange:
             for arrow in self.arrows:
                 arrow.updatePosition()
 
         return value
 
 
-class DiagramScene(QtWidgets.QGraphicsScene):
+class DiagramScene(QGraphicsScene):
     InsertItem, InsertLine, InsertText, MoveItem  = range(4)
 
-    item_inserted = QtCore.Signal(DiagramItem)
+    item_inserted = Signal(DiagramItem)
 
-    text_inserted = QtCore.Signal(QtWidgets.QGraphicsTextItem)
+    text_inserted = Signal(QGraphicsTextItem)
 
-    item_selected = QtCore.Signal(QtWidgets.QGraphicsItem)
+    item_selected = Signal(QGraphicsItem)
 
     def __init__(self, itemMenu, parent=None):
         super(DiagramScene, self).__init__(parent)
@@ -258,16 +275,16 @@ class DiagramScene(QtWidgets.QGraphicsScene):
         self._my_item_type = DiagramItem.Step
         self.line = None
         self._text_item = None
-        self._my_item_color = QtCore.Qt.white
-        self._my_text_color = QtCore.Qt.black
-        self._my_line_color = QtCore.Qt.black
-        self._my_font = QtGui.QFont()
+        self._my_item_color = Qt.white
+        self._my_text_color = Qt.black
+        self._my_line_color = Qt.black
+        self._my_font = QFont()
 
     def set_line_color(self, color):
         self._my_line_color = color
         if self.is_item_change(Arrow):
             item = self.selectedItems()[0]
-            item.setColor(self._my_line_color)
+            item.set_color(self._my_line_color)
             self.update()
 
     def set_text_color(self, color):
@@ -304,7 +321,7 @@ class DiagramScene(QtWidgets.QGraphicsScene):
             item.deleteLater()
 
     def mousePressEvent(self, mouseEvent):
-        if (mouseEvent.button() != QtCore.Qt.LeftButton):
+        if (mouseEvent.button() != Qt.LeftButton):
             return
 
         if self._my_mode == self.InsertItem:
@@ -314,14 +331,14 @@ class DiagramScene(QtWidgets.QGraphicsScene):
             item.setPos(mouseEvent.scenePos())
             self.item_inserted.emit(item)
         elif self._my_mode == self.InsertLine:
-            self.line = QtWidgets.QGraphicsLineItem(QtCore.QLineF(mouseEvent.scenePos(),
+            self.line = QGraphicsLineItem(QLineF(mouseEvent.scenePos(),
                                         mouseEvent.scenePos()))
-            self.line.setPen(QtGui.QPen(self._my_line_color, 2))
+            self.line.setPen(QPen(self._my_line_color, 2))
             self.addItem(self.line)
         elif self._my_mode == self.InsertText:
             text_item = DiagramTextItem()
             text_item.setFont(self._my_font)
-            text_item.setTextInteractionFlags(QtCore.Qt.TextEditorInteraction)
+            text_item.setTextInteractionFlags(Qt.TextEditorInteraction)
             text_item.setZValue(1000.0)
             text_item.lost_focus.connect(self.editor_lost_focus)
             text_item.selected_change.connect(self.item_selected)
@@ -334,7 +351,7 @@ class DiagramScene(QtWidgets.QGraphicsScene):
 
     def mouseMoveEvent(self, mouseEvent):
         if self._my_mode == self.InsertLine and self.line:
-            new_line = QtCore.QLineF(self.line.line().p1(), mouseEvent.scenePos())
+            new_line = QLineF(self.line.line().p1(), mouseEvent.scenePos())
             self.line.setLine(new_line)
         elif self._my_mode == self.MoveItem:
             super(DiagramScene, self).mouseMoveEvent(mouseEvent)
@@ -359,8 +376,8 @@ class DiagramScene(QtWidgets.QGraphicsScene):
                 end_item = end_items[0]
                 arrow = Arrow(start_item, end_item)
                 arrow.set_color(self._my_line_color)
-                start_item.addArrow(arrow)
-                end_item.addArrow(arrow)
+                start_item.add_arrow(arrow)
+                end_item.add_arrow(arrow)
                 arrow.setZValue(-1000.0)
                 self.addItem(arrow)
                 arrow.update_position()
@@ -375,7 +392,7 @@ class DiagramScene(QtWidgets.QGraphicsScene):
         return False
 
 
-class MainWindow(QtWidgets.QMainWindow):
+class MainWindow(QMainWindow):
     insert_text_button = 10
 
     def __init__(self):
@@ -386,19 +403,19 @@ class MainWindow(QtWidgets.QMainWindow):
         self.create_tool_box()
 
         self.scene = DiagramScene(self._item_menu)
-        self.scene.setSceneRect(QtCore.QRectF(0, 0, 5000, 5000))
+        self.scene.setSceneRect(QRectF(0, 0, 5000, 5000))
         self.scene.item_inserted.connect(self.item_inserted)
         self.scene.text_inserted.connect(self.text_inserted)
         self.scene.item_selected.connect(self.item_selected)
 
         self.create_toolbars()
 
-        layout = QtWidgets.QHBoxLayout()
+        layout = QHBoxLayout()
         layout.addWidget(self._tool_box)
-        self.view = QtWidgets.QGraphicsView(self.scene)
+        self.view = QGraphicsView(self.scene)
         layout.addWidget(self.view)
 
-        self.widget = QtWidgets.QWidget()
+        self.widget = QWidget()
         self.widget.setLayout(layout)
 
         self.setCentralWidget(self.widget)
@@ -412,13 +429,13 @@ class MainWindow(QtWidgets.QMainWindow):
 
         text = button.text()
         if text == "Blue Grid":
-            self.scene.setBackgroundBrush(QtGui.QBrush(QtGui.QPixmap(':/images/background1.png')))
+            self.scene.setBackgroundBrush(QBrush(QPixmap(':/images/background1.png')))
         elif text == "White Grid":
-            self.scene.setBackgroundBrush(QtGui.QBrush(QtGui.QPixmap(':/images/background2.png')))
+            self.scene.setBackgroundBrush(QBrush(QPixmap(':/images/background2.png')))
         elif text == "Gray Grid":
-            self.scene.setBackgroundBrush(QtGui.QBrush(QtGui.QPixmap(':/images/background3.png')))
+            self.scene.setBackgroundBrush(QBrush(QPixmap(':/images/background3.png')))
         else:
-            self.scene.setBackgroundBrush(QtGui.QBrush(QtGui.QPixmap(':/images/background4.png')))
+            self.scene.setBackgroundBrush(QBrush(QPixmap(':/images/background4.png')))
 
         self.scene.update()
         self.view.update()
@@ -438,7 +455,7 @@ class MainWindow(QtWidgets.QMainWindow):
     def delete_item(self):
         for item in self.scene.selectedItems():
             if isinstance(item, DiagramItem):
-                item.removeArrows()
+                item.remove_arrows()
             self.scene.removeItem(item)
 
     def pointer_group_clicked(self, i):
@@ -487,8 +504,8 @@ class MainWindow(QtWidgets.QMainWindow):
 
     def scene_scale_changed(self, scale):
         new_scale = int(scale[:-1]) / 100.0
-        old_matrix = self.view.matrix()
-        self.view.resetMatrix()
+        old_matrix = self.view.transform()
+        self.view.resetTransform()
         self.view.translate(old_matrix.dx(), old_matrix.dy())
         self.view.scale(new_scale, new_scale)
 
@@ -496,39 +513,39 @@ class MainWindow(QtWidgets.QMainWindow):
         self._text_action = self.sender()
         self._font_color_tool_button.setIcon(self.create_color_tool_button_icon(
                     ':/images/textpointer.png',
-                    QtGui.QColor(self._text_action.data())))
+                    QColor(self._text_action.data())))
         self.text_button_triggered()
 
     def item_color_changed(self):
         self._fill_action = self.sender()
         self._fill_color_tool_button.setIcon(self.create_color_tool_button_icon(
                     ':/images/floodfill.png',
-                    QtGui.QColor(self._fill_action.data())))
+                    QColor(self._fill_action.data())))
         self.fill_button_triggered()
 
     def line_color_changed(self):
         self._line_action = self.sender()
         self._line_color_tool_button.setIcon(self.create_color_tool_button_icon(
                     ':/images/linecolor.png',
-                    QtGui.QColor(self._line_action.data())))
+                    QColor(self._line_action.data())))
         self.line_button_triggered()
 
     def text_button_triggered(self):
-        self.scene.set_text_color(QtGui.QColor(self._text_action.data()))
+        self.scene.set_text_color(QColor(self._text_action.data()))
 
     def fill_button_triggered(self):
-        self.scene.set_item_color(QtGui.QColor(self._fill_action.data()))
+        self.scene.set_item_color(QColor(self._fill_action.data()))
 
     def line_button_triggered(self):
-        self.scene.set_line_color(QtGui.QColor(self._line_action.data()))
+        self.scene.set_line_color(QColor(self._line_action.data()))
 
     def handle_font_change(self):
         font = self._font_combo.currentFont()
         font.setPointSize(int(self._font_size_combo.currentText()))
         if self._bold_action.isChecked():
-            font.setWeight(QtGui.QFont.Bold)
+            font.setWeight(QFont.Bold)
         else:
-            font.setWeight(QtGui.QFont.Normal)
+            font.setWeight(QFont.Normal)
         font.setItalic(self._italic_action.isChecked())
         font.setUnderline(self._underline_action.isChecked())
 
@@ -539,20 +556,20 @@ class MainWindow(QtWidgets.QMainWindow):
         color = item.defaultTextColor()
         self._font_combo.setCurrentFont(font)
         self._font_size_combo.setEditText(str(font.pointSize()))
-        self._bold_action.setChecked(font.weight() == QtGui.QFont.Bold)
+        self._bold_action.setChecked(font.weight() == QFont.Bold)
         self._italic_action.setChecked(font.italic())
         self._underline_action.setChecked(font.underline())
 
     def about(self):
-        QtWidgets.QMessageBox.about(self, "About Diagram Scene",
+        QMessageBox.about(self, "About Diagram Scene",
                 "The <b>Diagram Scene</b> example shows use of the graphics framework.")
 
     def create_tool_box(self):
-        self._button_group = QtWidgets.QButtonGroup()
+        self._button_group = QButtonGroup()
         self._button_group.setExclusive(False)
         self._button_group.idClicked.connect(self.button_group_clicked)
 
-        layout = QtWidgets.QGridLayout()
+        layout = QGridLayout()
         layout.addWidget(self.create_cell_widget("Conditional", DiagramItem.Conditional),
                 0, 0)
         layout.addWidget(self.create_cell_widget("Process", DiagramItem.Step), 0,
@@ -560,31 +577,30 @@ class MainWindow(QtWidgets.QMainWindow):
         layout.addWidget(self.create_cell_widget("Input/Output", DiagramItem.Io),
                 1, 0)
 
-        text_button = QtWidgets.QToolButton()
+        text_button = QToolButton()
         text_button.setCheckable(True)
         self._button_group.addButton(text_button, self.insert_text_button)
-        text_button.setIcon(QtGui.QIcon(QtGui.QPixmap(':/images/textpointer.png')
+        text_button.setIcon(QIcon(QPixmap(':/images/textpointer.png')
                             .scaled(30, 30)))
-        text_button.setIconSize(QtCore.QSize(50, 50))
+        text_button.setIconSize(QSize(50, 50))
 
-        text_layout = QtWidgets.QGridLayout()
-        text_layout.addWidget(text_button, 0, 0, QtCore.Qt.AlignHCenter)
-        text_layout.addWidget(QtWidgets.QLabel("Text"), 1, 0,
-                QtCore.Qt.AlignCenter)
-        text_widget = QtWidgets.QWidget()
+        text_layout = QGridLayout()
+        text_layout.addWidget(text_button, 0, 0, Qt.AlignHCenter)
+        text_layout.addWidget(QLabel("Text"), 1, 0, Qt.AlignCenter)
+        text_widget = QWidget()
         text_widget.setLayout(text_layout)
         layout.addWidget(text_widget, 1, 1)
 
         layout.setRowStretch(3, 10)
         layout.setColumnStretch(2, 10)
 
-        item_widget = QtWidgets.QWidget()
+        item_widget = QWidget()
         item_widget.setLayout(layout)
 
-        self._background_button_group = QtWidgets.QButtonGroup()
+        self._background_button_group = QButtonGroup()
         self._background_button_group.buttonClicked.connect(self.background_button_group_clicked)
 
-        background_layout = QtWidgets.QGridLayout()
+        background_layout = QGridLayout()
         background_layout.addWidget(self.create_background_cell_widget("Blue Grid",
                 ':/images/background1.png'), 0, 0)
         background_layout.addWidget(self.create_background_cell_widget("White Grid",
@@ -597,48 +613,48 @@ class MainWindow(QtWidgets.QMainWindow):
         background_layout.setRowStretch(2, 10)
         background_layout.setColumnStretch(2, 10)
 
-        background_widget = QtWidgets.QWidget()
+        background_widget = QWidget()
         background_widget.setLayout(background_layout)
 
-        self._tool_box = QtWidgets.QToolBox()
-        self._tool_box.setSizePolicy(QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Maximum, QtWidgets.QSizePolicy.Ignored))
+        self._tool_box = QToolBox()
+        self._tool_box.setSizePolicy(QSizePolicy(QSizePolicy.Maximum, QSizePolicy.Ignored))
         self._tool_box.setMinimumWidth(item_widget.sizeHint().width())
         self._tool_box.addItem(item_widget, "Basic Flowchart Shapes")
         self._tool_box.addItem(background_widget, "Backgrounds")
 
     def create_actions(self):
-        self._to_front_action = QtGui.QAction(
-                QtGui.QIcon(':/images/bringtofront.png'), "Bring to &Front",
+        self._to_front_action = QAction(
+                QIcon(':/images/bringtofront.png'), "Bring to &Front",
                 self, shortcut="Ctrl+F", statusTip="Bring item to front",
                 triggered=self.bring_to_front)
 
-        self._send_back_action = QtGui.QAction(
-                QtGui.QIcon(':/images/sendtoback.png'), "Send to &Back", self,
+        self._send_back_action = QAction(
+                QIcon(':/images/sendtoback.png'), "Send to &Back", self,
                 shortcut="Ctrl+B", statusTip="Send item to back",
                 triggered=self.send_to_back)
 
-        self._delete_action = QtGui.QAction(QtGui.QIcon(':/images/delete.png'),
+        self._delete_action = QAction(QIcon(':/images/delete.png'),
                 "&Delete", self, shortcut="Delete",
                 statusTip="Delete item from diagram",
                 triggered=self.delete_item)
 
-        self._exit_action = QtGui.QAction("E&xit", self, shortcut="Ctrl+X",
+        self._exit_action = QAction("E&xit", self, shortcut="Ctrl+X",
                 statusTip="Quit Scenediagram example", triggered=self.close)
 
-        self._bold_action = QtGui.QAction(QtGui.QIcon(':/images/bold.png'),
+        self._bold_action = QAction(QIcon(':/images/bold.png'),
                 "Bold", self, checkable=True, shortcut="Ctrl+B",
                 triggered=self.handle_font_change)
 
-        self._italic_action = QtGui.QAction(QtGui.QIcon(':/images/italic.png'),
+        self._italic_action = QAction(QIcon(':/images/italic.png'),
                 "Italic", self, checkable=True, shortcut="Ctrl+I",
                 triggered=self.handle_font_change)
 
-        self._underline_action = QtGui.QAction(
-                QtGui.QIcon(':/images/underline.png'), "Underline", self,
+        self._underline_action = QAction(
+                QIcon(':/images/underline.png'), "Underline", self,
                 checkable=True, shortcut="Ctrl+U",
                 triggered=self.handle_font_change)
 
-        self._about_action = QtGui.QAction("A&bout", self, shortcut="Ctrl+B",
+        self._about_action = QAction("A&bout", self, shortcut="Ctrl+B",
                 triggered=self.about)
 
     def create_menus(self):
@@ -660,46 +676,46 @@ class MainWindow(QtWidgets.QMainWindow):
         self._edit_tool_bar.addAction(self._to_front_action)
         self._edit_tool_bar.addAction(self._send_back_action)
 
-        self._font_combo = QtWidgets.QFontComboBox()
+        self._font_combo = QFontComboBox()
         self._font_combo.currentFontChanged.connect(self.current_font_changed)
 
-        self._font_size_combo = QtWidgets.QComboBox()
+        self._font_size_combo = QComboBox()
         self._font_size_combo.setEditable(True)
         for i in range(8, 30, 2):
             self._font_size_combo.addItem(str(i))
-        validator = QtGui.QIntValidator(2, 64, self)
+        validator = QIntValidator(2, 64, self)
         self._font_size_combo.setValidator(validator)
         self._font_size_combo.currentIndexChanged.connect(self.font_size_changed)
 
-        self._font_color_tool_button = QtWidgets.QToolButton()
-        self._font_color_tool_button.setPopupMode(QtWidgets.QToolButton.MenuButtonPopup)
+        self._font_color_tool_button = QToolButton()
+        self._font_color_tool_button.setPopupMode(QToolButton.MenuButtonPopup)
         self._font_color_tool_button.setMenu(
-                self.create_color_menu(self.text_color_changed, QtCore.Qt.black))
+                self.create_color_menu(self.text_color_changed, Qt.black))
         self._text_action = self._font_color_tool_button.menu().defaultAction()
         self._font_color_tool_button.setIcon(
                 self.create_color_tool_button_icon(':/images/textpointer.png',
-                        QtCore.Qt.black))
+                        Qt.black))
         self._font_color_tool_button.setAutoFillBackground(True)
         self._font_color_tool_button.clicked.connect(self.text_button_triggered)
 
-        self._fill_color_tool_button = QtWidgets.QToolButton()
-        self._fill_color_tool_button.setPopupMode(QtWidgets.QToolButton.MenuButtonPopup)
+        self._fill_color_tool_button = QToolButton()
+        self._fill_color_tool_button.setPopupMode(QToolButton.MenuButtonPopup)
         self._fill_color_tool_button.setMenu(
-                self.create_color_menu(self.item_color_changed, QtCore.Qt.white))
+                self.create_color_menu(self.item_color_changed, Qt.white))
         self._fill_action = self._fill_color_tool_button.menu().defaultAction()
         self._fill_color_tool_button.setIcon(
                 self.create_color_tool_button_icon(':/images/floodfill.png',
-                        QtCore.Qt.white))
+                        Qt.white))
         self._fill_color_tool_button.clicked.connect(self.fill_button_triggered)
 
-        self._line_color_tool_button = QtWidgets.QToolButton()
-        self._line_color_tool_button.setPopupMode(QtWidgets.QToolButton.MenuButtonPopup)
+        self._line_color_tool_button = QToolButton()
+        self._line_color_tool_button.setPopupMode(QToolButton.MenuButtonPopup)
         self._line_color_tool_button.setMenu(
-                self.create_color_menu(self.line_color_changed, QtCore.Qt.black))
+                self.create_color_menu(self.line_color_changed, Qt.black))
         self._line_action = self._line_color_tool_button.menu().defaultAction()
         self._line_color_tool_button.setIcon(
                 self.create_color_tool_button_icon(':/images/linecolor.png',
-                        QtCore.Qt.black))
+                        Qt.black))
         self._line_color_tool_button.clicked.connect(self.line_button_triggered)
 
         self._text_tool_bar = self.addToolBar("Font")
@@ -714,21 +730,21 @@ class MainWindow(QtWidgets.QMainWindow):
         self._color_tool_bar.addWidget(self._fill_color_tool_button)
         self._color_tool_bar.addWidget(self._line_color_tool_button)
 
-        pointer_button = QtWidgets.QToolButton()
+        pointer_button = QToolButton()
         pointer_button.setCheckable(True)
         pointer_button.setChecked(True)
-        pointer_button.setIcon(QtGui.QIcon(':/images/pointer.png'))
-        line_pointer_button = QtWidgets.QToolButton()
+        pointer_button.setIcon(QIcon(':/images/pointer.png'))
+        line_pointer_button = QToolButton()
         line_pointer_button.setCheckable(True)
-        line_pointer_button.setIcon(QtGui.QIcon(':/images/linepointer.png'))
+        line_pointer_button.setIcon(QIcon(':/images/linepointer.png'))
 
-        self._pointer_type_group = QtWidgets.QButtonGroup()
+        self._pointer_type_group = QButtonGroup()
         self._pointer_type_group.addButton(pointer_button, DiagramScene.MoveItem)
         self._pointer_type_group.addButton(line_pointer_button,
                 DiagramScene.InsertLine)
         self._pointer_type_group.idClicked.connect(self.pointer_group_clicked)
 
-        self._scene_scale_combo = QtWidgets.QComboBox()
+        self._scene_scale_combo = QComboBox()
         self._scene_scale_combo.addItems(["50%", "75%", "100%", "125%", "150%"])
         self._scene_scale_combo.setCurrentIndex(2)
         self._scene_scale_combo.currentTextChanged.connect(self.scene_scale_changed)
@@ -739,83 +755,80 @@ class MainWindow(QtWidgets.QMainWindow):
         self._pointer_toolbar.addWidget(self._scene_scale_combo)
 
     def create_background_cell_widget(self, text, image):
-        button = QtWidgets.QToolButton()
+        button = QToolButton()
         button.setText(text)
-        button.setIcon(QtGui.QIcon(image))
-        button.setIconSize(QtCore.QSize(50, 50))
+        button.setIcon(QIcon(image))
+        button.setIconSize(QSize(50, 50))
         button.setCheckable(True)
         self._background_button_group.addButton(button)
 
-        layout = QtWidgets.QGridLayout()
-        layout.addWidget(button, 0, 0, QtCore.Qt.AlignHCenter)
-        layout.addWidget(QtWidgets.QLabel(text), 1, 0, QtCore.Qt.AlignCenter)
+        layout = QGridLayout()
+        layout.addWidget(button, 0, 0, Qt.AlignHCenter)
+        layout.addWidget(QLabel(text), 1, 0, Qt.AlignCenter)
 
-        widget = QtWidgets.QWidget()
+        widget = QWidget()
         widget.setLayout(layout)
 
         return widget
 
     def create_cell_widget(self, text, diagram_type):
         item = DiagramItem(diagram_type, self._item_menu)
-        icon = QtGui.QIcon(item.image())
+        icon = QIcon(item.image())
 
-        button = QtWidgets.QToolButton()
+        button = QToolButton()
         button.setIcon(icon)
-        button.setIconSize(QtCore.QSize(50, 50))
+        button.setIconSize(QSize(50, 50))
         button.setCheckable(True)
         self._button_group.addButton(button, diagram_type)
 
-        layout = QtWidgets.QGridLayout()
-        layout.addWidget(button, 0, 0, QtCore.Qt.AlignHCenter)
-        layout.addWidget(QtWidgets.QLabel(text), 1, 0, QtCore.Qt.AlignCenter)
+        layout = QGridLayout()
+        layout.addWidget(button, 0, 0, Qt.AlignHCenter)
+        layout.addWidget(QLabel(text), 1, 0, Qt.AlignCenter)
 
-        widget = QtWidgets.QWidget()
+        widget = QWidget()
         widget.setLayout(layout)
 
         return widget
 
     def create_color_menu(self, slot, defaultColor):
-        colors = [QtCore.Qt.black, QtCore.Qt.white, QtCore.Qt.red, QtCore.Qt.blue, QtCore.Qt.yellow]
+        colors = [Qt.black, Qt.white, Qt.red, Qt.blue, Qt.yellow]
         names = ["black", "white", "red", "blue", "yellow"]
 
-        color_menu = QtWidgets.QMenu(self)
+        color_menu = QMenu(self)
         for color, name in zip(colors, names):
-            action = QtGui.QAction(self.create_color_icon(color), name, self,
+            action = QAction(self.create_color_icon(color), name, self,
                     triggered=slot)
-            action.setData(QtGui.QColor(color))
+            action.setData(QColor(color))
             color_menu.addAction(action)
             if color == defaultColor:
                 color_menu.setDefaultAction(action)
         return color_menu
 
     def create_color_tool_button_icon(self, imageFile, color):
-        pixmap = QtGui.QPixmap(50, 80)
-        pixmap.fill(QtCore.Qt.transparent)
-        painter = QtGui.QPainter(pixmap)
-        image = QtGui.QPixmap(imageFile)
-        target = QtCore.QRect(0, 0, 50, 60)
-        source = QtCore.QRect(0, 0, 42, 42)
-        painter.fillRect(QtCore.QRect(0, 60, 50, 80), color)
+        pixmap = QPixmap(50, 80)
+        pixmap.fill(Qt.transparent)
+        painter = QPainter(pixmap)
+        image = QPixmap(imageFile)
+        target = QRect(0, 0, 50, 60)
+        source = QRect(0, 0, 42, 42)
+        painter.fillRect(QRect(0, 60, 50, 80), color)
         painter.drawPixmap(target, image, source)
         painter.end()
 
-        return QtGui.QIcon(pixmap)
+        return QIcon(pixmap)
 
     def create_color_icon(self, color):
-        pixmap = QtGui.QPixmap(20, 20)
-        painter = QtGui.QPainter(pixmap)
-        painter.setPen(QtCore.Qt.NoPen)
-        painter.fillRect(QtCore.QRect(0, 0, 20, 20), color)
+        pixmap = QPixmap(20, 20)
+        painter = QPainter(pixmap)
+        painter.setPen(Qt.NoPen)
+        painter.fillRect(QRect(0, 0, 20, 20), color)
         painter.end()
 
-        return QtGui.QIcon(pixmap)
+        return QIcon(pixmap)
 
 
 if __name__ == '__main__':
-
-    import sys
-
-    app = QtWidgets.QApplication(sys.argv)
+    app = QApplication(sys.argv)
 
     main_window = MainWindow()
     main_window.setGeometry(100, 100, 800, 500)
diff --git a/examples/widgets/graphicsview/elasticnodes/elasticnodes.py b/examples/widgets/graphicsview/elasticnodes/elasticnodes.py
index 297cbe545..f374f0180 100644
--- a/examples/widgets/graphicsview/elasticnodes/elasticnodes.py
+++ b/examples/widgets/graphicsview/elasticnodes/elasticnodes.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.
@@ -43,26 +43,30 @@
 import sys
 import weakref
 import math
-from PySide6 import QtCore, QtGui, QtWidgets
+
+from PySide6.QtCore import (QLineF, QPointF, QRandomGenerator, QRectF, QSizeF,
+                            Qt, qAbs)
+from PySide6.QtGui import (QColor, QBrush, QPainter, QPainterPath, QPen,
+                           QPolygonF, QRadialGradient)
+from PySide6.QtWidgets import (QApplication, QGraphicsItem, QGraphicsScene,
+                               QGraphicsView, QStyle, QWidget)
 
 
 def random(boundary):
-    return QtCore.QRandomGenerator.global_().bounded(boundary)
+    return QRandomGenerator.global_().bounded(boundary)
 
 
-class Edge(QtWidgets.QGraphicsItem):
-    Pi = math.pi
-    two_pi = 2.0 * Pi
+class Edge(QGraphicsItem):
 
-    type = QtWidgets.QGraphicsItem.UserType + 2
+    type = QGraphicsItem.UserType + 2
 
     def __init__(self, sourceNode, destNode):
-        QtWidgets.QGraphicsItem.__init__(self)
+        QGraphicsItem.__init__(self)
 
         self._arrow_size = 10.0
-        self._source_point = QtCore.QPointF()
-        self._dest_point = QtCore.QPointF()
-        self.setAcceptedMouseButtons(QtCore.Qt.NoButton)
+        self._source_point = QPointF()
+        self._dest_point = QPointF()
+        self.setAcceptedMouseButtons(Qt.NoButton)
         self.source = weakref.ref(sourceNode)
         self.dest = weakref.ref(destNode)
         self.source().add_edge(self)
@@ -90,13 +94,14 @@ class Edge(QtWidgets.QGraphicsItem):
         if not self.source() or not self.dest():
             return
 
-        line = QtCore.QLineF(self.mapFromItem(self.source(), 0, 0), self.mapFromItem(self.dest(), 0, 0))
+        line = QLineF(self.mapFromItem(self.source(), 0, 0),
+                      self.mapFromItem(self.dest(), 0, 0))
         length = line.length()
 
         if length == 0.0:
             return
 
-        edge_offset = QtCore.QPointF((line.dx() * 10) / length, (line.dy() * 10) / length)
+        edge_offset = QPointF((line.dx() * 10) / length, (line.dy() * 10) / length)
 
         self.prepareGeometryChange()
         self._source_point = line.p1() + edge_offset
@@ -104,58 +109,64 @@ class Edge(QtWidgets.QGraphicsItem):
 
     def boundingRect(self):
         if not self.source() or not self.dest():
-            return QtCore.QRectF()
+            return QRectF()
 
         pen_width = 1
         extra = (pen_width + self._arrow_size) / 2.0
 
-        return QtCore.QRectF(self._source_point,
-                             QtCore.QSizeF(self._dest_point.x() - self._source_point.x(),
-                                           self._dest_point.y() - self._source_point.y())).normalized().adjusted(-extra, -extra, extra, extra)
+        width = self._dest_point.x() - self._source_point.x()
+        height = self._dest_point.y() - self._source_point.y()
+        rect = QRectF(self._source_point, QSizeF(width, height))
+        return rect.normalized().adjusted(-extra, -extra, extra, extra)
 
     def paint(self, painter, option, widget):
         if not self.source() or not self.dest():
             return
 
         # Draw the line itself.
-        line = QtCore.QLineF(self._source_point, self._dest_point)
+        line = QLineF(self._source_point, self._dest_point)
 
         if line.length() == 0.0:
             return
 
-        painter.setPen(QtGui.QPen(QtCore.Qt.black, 1, QtCore.Qt.SolidLine, QtCore.Qt.RoundCap, QtCore.Qt.RoundJoin))
+        painter.setPen(QPen(Qt.black, 1, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin))
         painter.drawLine(line)
 
         # Draw the arrows if there's enough room.
         angle = math.acos(line.dx() / line.length())
         if line.dy() >= 0:
-            angle = Edge.two_pi - angle
+            angle = 2 * math.pi - angle
+
+        arrow_head1 = QPointF(math.sin(angle + math.pi / 3) * self._arrow_size,
+                              math.cos(angle + math.pi / 3) * self._arrow_size)
+        source_arrow_p1 = self._source_point + arrow_head1
+        arrow_head2 = QPointF(math.sin(angle + math.pi - math.pi / 3) * self._arrow_size,
+                              math.cos(angle + math.pi - math.pi / 3) * self._arrow_size)
+        source_arrow_p2 = self._source_point + arrow_head2
 
-        source_arrow_p1 = self._source_point + QtCore.QPointF(math.sin(angle + Edge.Pi / 3) * self._arrow_size,
-                                                          math.cos(angle + Edge.Pi / 3) * self._arrow_size)
-        source_arrow_p2 = self._source_point + QtCore.QPointF(math.sin(angle + Edge.Pi - Edge.Pi / 3) * self._arrow_size,
-                                                          math.cos(angle + Edge.Pi - Edge.Pi / 3) * self._arrow_size)
-        dest_arrow_p1 = self._dest_point + QtCore.QPointF(math.sin(angle - Edge.Pi / 3) * self._arrow_size,
-                                                      math.cos(angle - Edge.Pi / 3) * self._arrow_size)
-        dest_arrow_p2 = self._dest_point + QtCore.QPointF(math.sin(angle - Edge.Pi + Edge.Pi / 3) * self._arrow_size,
-                                                      math.cos(angle - Edge.Pi + Edge.Pi / 3) * self._arrow_size)
+        arrow_head1 = QPointF(math.sin(angle - math.pi / 3) * self._arrow_size,
+                              math.cos(angle - math.pi / 3) * self._arrow_size)
+        dest_arrow_p1 = self._dest_point + arrow_head1
+        arrow_head2 = QPointF(math.sin(angle - math.pi + math.pi / 3) * self._arrow_size,
+                              math.cos(angle - math.pi + math.pi / 3) * self._arrow_size)
+        dest_arrow_p2 = self._dest_point + arrow_head2
 
-        painter.setBrush(QtCore.Qt.black)
-        painter.drawPolygon(QtGui.QPolygonF([line.p1(), source_arrow_p1, source_arrow_p2]))
-        painter.drawPolygon(QtGui.QPolygonF([line.p2(), dest_arrow_p1, dest_arrow_p2]))
+        painter.setBrush(Qt.black)
+        painter.drawPolygon(QPolygonF([line.p1(), source_arrow_p1, source_arrow_p2]))
+        painter.drawPolygon(QPolygonF([line.p2(), dest_arrow_p1, dest_arrow_p2]))
 
 
-class Node(QtWidgets.QGraphicsItem):
-    type = QtWidgets.QGraphicsItem.UserType + 1
+class Node(QGraphicsItem):
+    type = QGraphicsItem.UserType + 1
 
     def __init__(self, graphWidget):
-        QtWidgets.QGraphicsItem.__init__(self)
+        QGraphicsItem.__init__(self)
 
         self.graph = weakref.ref(graphWidget)
         self._edge_list = []
-        self._new_pos = QtCore.QPointF()
-        self.setFlag(QtWidgets.QGraphicsItem.ItemIsMovable)
-        self.setFlag(QtWidgets.QGraphicsItem.ItemSendsGeometryChanges)
+        self._new_pos = QPointF()
+        self.setFlag(QGraphicsItem.ItemIsMovable)
+        self.setFlag(QGraphicsItem.ItemSendsGeometryChanges)
         self.setCacheMode(self.DeviceCoordinateCache)
         self.setZValue(-1)
 
@@ -181,7 +192,7 @@ class Node(QtWidgets.QGraphicsItem):
             if not isinstance(item, Node):
                 continue
 
-            line = QtCore.QLineF(self.mapFromItem(item, 0, 0), QtCore.QPointF(0, 0))
+            line = QLineF(self.mapFromItem(item, 0, 0), QPointF(0, 0))
             dx = line.dx()
             dy = line.dy()
             l = 2.0 * (dx * dx + dy * dy)
@@ -199,13 +210,15 @@ class Node(QtWidgets.QGraphicsItem):
             xvel += pos.x() / weight
             yvel += pos.y() / weight
 
-        if QtCore.qAbs(xvel) < 0.1 and QtCore.qAbs(yvel) < 0.1:
+        if qAbs(xvel) < 0.1 and qAbs(yvel) < 0.1:
             xvel = yvel = 0.0
 
         scene_rect = self.scene().sceneRect()
-        self._new_pos = self.pos() + QtCore.QPointF(xvel, yvel)
-        self._new_pos.setX(min(max(self._new_pos.x(), scene_rect.left() + 10), scene_rect.right() - 10))
-        self._new_pos.setY(min(max(self._new_pos.y(), scene_rect.top() + 10), scene_rect.bottom() - 10))
+        self._new_pos = self.pos() + QPointF(xvel, yvel)
+        self._new_pos.setX(min(max(self._new_pos.x(), scene_rect.left() + 10),
+                               scene_rect.right() - 10))
+        self._new_pos.setY(min(max(self._new_pos.y(), scene_rect.top() + 10),
+                               scene_rect.bottom() - 10))
 
     def advance(self):
         if self._new_pos == self.pos():
@@ -216,64 +229,64 @@ class Node(QtWidgets.QGraphicsItem):
 
     def boundingRect(self):
         adjust = 2.0
-        return QtCore.QRectF(-10 - adjust, -10 - adjust,
+        return QRectF(-10 - adjust, -10 - adjust,
                              23 + adjust, 23 + adjust)
 
     def shape(self):
-        path = QtGui.QPainterPath()
+        path = QPainterPath()
         path.addEllipse(-10, -10, 20, 20)
         return path
 
     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(-7, -7, 20, 20)
 
-        gradient = QtGui.QRadialGradient(-3, -3, 10)
-        if option.state & QtWidgets.QStyle.State_Sunken:
+        gradient = QRadialGradient(-3, -3, 10)
+        if option.state & QStyle.State_Sunken:
             gradient.setCenter(3, 3)
             gradient.setFocalPoint(3, 3)
-            gradient.setColorAt(1, QtGui.QColor(QtCore.Qt.yellow).lighter(120))
-            gradient.setColorAt(0, QtGui.QColor(QtCore.Qt.darkYellow).lighter(120))
+            gradient.setColorAt(1, QColor(Qt.yellow).lighter(120))
+            gradient.setColorAt(0, QColor(Qt.darkYellow).lighter(120))
         else:
-            gradient.setColorAt(0, QtCore.Qt.yellow)
-            gradient.setColorAt(1, QtCore.Qt.darkYellow)
+            gradient.setColorAt(0, Qt.yellow)
+            gradient.setColorAt(1, Qt.darkYellow)
 
-        painter.setBrush(QtGui.QBrush(gradient))
-        painter.setPen(QtGui.QPen(QtCore.Qt.black, 0))
+        painter.setBrush(QBrush(gradient))
+        painter.setPen(QPen(Qt.black, 0))
         painter.drawEllipse(-10, -10, 20, 20)
 
     def itemChange(self, change, value):
-        if change == QtWidgets.QGraphicsItem.ItemPositionChange:
+        if change == QGraphicsItem.ItemPositionChange:
             for edge in self._edge_list:
                 edge().adjust()
             self.graph().item_moved()
 
-        return QtWidgets.QGraphicsItem.itemChange(self, change, value)
+        return QGraphicsItem.itemChange(self, change, value)
 
     def mousePressEvent(self, event):
         self.update()
-        QtWidgets.QGraphicsItem.mousePressEvent(self, event)
+        QGraphicsItem.mousePressEvent(self, event)
 
     def mouseReleaseEvent(self, event):
         self.update()
-        QtWidgets.QGraphicsItem.mouseReleaseEvent(self, event)
+        QGraphicsItem.mouseReleaseEvent(self, event)
 
 
-class GraphWidget(QtWidgets.QGraphicsView):
+class GraphWidget(QGraphicsView):
     def __init__(self):
-        QtWidgets.QGraphicsView.__init__(self)
+        QGraphicsView.__init__(self)
 
         self._timer_id = 0
 
-        scene = QtWidgets.QGraphicsScene(self)
-        scene.setItemIndexMethod(QtWidgets.QGraphicsScene.NoIndex)
+        scene = QGraphicsScene(self)
+        scene.setItemIndexMethod(QGraphicsScene.NoIndex)
         scene.setSceneRect(-200, -200, 400, 400)
         self.setScene(scene)
-        self.setCacheMode(QtWidgets.QGraphicsView.CacheBackground)
-        self.setRenderHint(QtGui.QPainter.Antialiasing)
-        self.setTransformationAnchor(QtWidgets.QGraphicsView.AnchorUnderMouse)
-        self.setResizeAnchor(QtWidgets.QGraphicsView.AnchorViewCenter)
+        self.setCacheMode(QGraphicsView.CacheBackground)
+        self.setRenderHint(QPainter.Antialiasing)
+        self.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)
+        self.setResizeAnchor(QGraphicsView.AnchorViewCenter)
 
         node1 = Node(self)
         node2 = Node(self)
@@ -327,24 +340,24 @@ class GraphWidget(QtWidgets.QGraphicsView):
     def keyPressEvent(self, event):
         key = event.key()
 
-        if key == QtCore.Qt.Key_Up:
+        if key == Qt.Key_Up:
             self._center_node.moveBy(0, -20)
-        elif key == QtCore.Qt.Key_Down:
+        elif key == Qt.Key_Down:
             self._center_node.moveBy(0, 20)
-        elif key == QtCore.Qt.Key_Left:
+        elif key == Qt.Key_Left:
             self._center_node.moveBy(-20, 0)
-        elif key == QtCore.Qt.Key_Right:
+        elif key == Qt.Key_Right:
             self._center_node.moveBy(20, 0)
-        elif key == QtCore.Qt.Key_Plus:
+        elif key == Qt.Key_Plus:
             self.scale_view(1.2)
-        elif key == QtCore.Qt.Key_Minus:
+        elif key == Qt.Key_Minus:
             self.scale_view(1 / 1.2)
-        elif key == QtCore.Qt.Key_Space or key == QtCore.Qt.Key_Enter:
+        elif key == Qt.Key_Space or key == Qt.Key_Enter:
             for item in self.scene().items():
                 if isinstance(item, Node):
                     item.setPos(-150 + random(300), -150 + random(300))
         else:
-            QtWidgets.QGraphicsView.keyPressEvent(self, event)
+            QGraphicsView.keyPressEvent(self, event)
 
 
     def timerEvent(self, event):
@@ -363,28 +376,31 @@ class GraphWidget(QtWidgets.QGraphicsView):
             self._timer_id = 0
 
     def wheelEvent(self, event):
-        self.scale_view(math.pow(2.0, -event.delta() / 240.0))
+        delta = event.angleDelta().y()
+        self.scale_view(math.pow(2.0, -delta / 240.0))
 
     def draw_background(self, painter, rect):
         # Shadow.
         scene_rect = self.sceneRect()
-        right_shadow = QtCore.QRectF(scene_rect.right(), scene_rect.top() + 5, 5, scene_rect.height())
-        bottom_shadow = QtCore.QRectF(scene_rect.left() + 5, scene_rect.bottom(), scene_rect.width(), 5)
+        right_shadow = QRectF(scene_rect.right(), scene_rect.top() + 5,
+                              5, scene_rect.height())
+        bottom_shadow = QRectF(scene_rect.left() + 5, scene_rect.bottom(),
+                               scene_rect.width(), 5)
         if right_shadow.intersects(rect) or right_shadow.contains(rect):
-                painter.fillRect(right_shadow, QtCore.Qt.darkGray)
+                painter.fillRect(right_shadow, Qt.darkGray)
         if bottom_shadow.intersects(rect) or bottom_shadow.contains(rect):
-                painter.fillRect(bottom_shadow, QtCore.Qt.darkGray)
+                painter.fillRect(bottom_shadow, Qt.darkGray)
 
         # Fill.
-        gradient = QtGui.QLinearGradient(scene_rect.topLeft(), scene_rect.bottomRight())
-        gradient.setColorAt(0, QtCore.Qt.white)
-        gradient.setColorAt(1, QtCore.Qt.lightGray)
-        painter.fillRect(rect.intersected(scene_rect), QtGui.QBrush(gradient))
-        painter.setBrush(QtCore.Qt.NoBrush)
+        gradient = QLinearGradient(scene_rect.topLeft(), scene_rect.bottomRight())
+        gradient.setColorAt(0, Qt.white)
+        gradient.setColorAt(1, Qt.lightGray)
+        painter.fillRect(rect.intersected(scene_rect), QBrush(gradient))
+        painter.setBrush(Qt.NoBrush)
         painter.drawRect(scene_rect)
 
         # Text.
-        text_rect = QtCore.QRectF(scene_rect.left() + 4, scene_rect.top() + 4,
+        text_rect = QRectF(scene_rect.left() + 4, scene_rect.top() + 4,
                                  scene_rect.width() - 4, scene_rect.height() - 4)
         message = self.tr("Click and drag the nodes around, and zoom with the "
                           "mouse wheel or the '+' and '-' keys")
@@ -393,13 +409,13 @@ class GraphWidget(QtWidgets.QGraphicsView):
         font.setBold(True)
         font.setPointSize(14)
         painter.setFont(font)
-        painter.setPen(QtCore.Qt.lightGray)
+        painter.setPen(Qt.lightGray)
         painter.drawText(text_rect.translated(2, 2), message)
-        painter.setPen(QtCore.Qt.black)
+        painter.setPen(Qt.black)
         painter.drawText(text_rect, message)
 
     def scale_view(self, scaleFactor):
-        factor = self.matrix().scale(scaleFactor, scaleFactor).mapRect(QtCore.QRectF(0, 0, 1, 1)).width()
+        factor = self.transform().scale(scaleFactor, scaleFactor).mapRect(QRectF(0, 0, 1, 1)).width()
 
         if factor < 0.07 or factor > 100:
             return
@@ -408,7 +424,7 @@ class GraphWidget(QtWidgets.QGraphicsView):
 
 
 if __name__ == "__main__":
-    app = QtWidgets.QApplication(sys.argv)
+    app = QApplication(sys.argv)
 
     widget = GraphWidget()
     widget.show()