PySide6-Examples 6.7.0__cp39-abi3-win_amd64.whl

PySide6/examples/widgets/graphicsview/diagramscene/diagramscene.py

@@ -0,0 +1,802 @@
+# Copyright (C) 2013 Riverbank Computing Limited.
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+import math
+import sys
+
+from PySide6.QtCore import (QLineF, QPointF, QRect, QRectF, QSize, QSizeF, Qt,
+                            Signal, Slot)
+from PySide6.QtGui import (QAction, QBrush, QColor, QFont, QIcon, QIntValidator,
+                           QPainter, QPainterPath, QPen, QPixmap, QPolygonF)
+from PySide6.QtWidgets import (QAbstractButton, QApplication, QButtonGroup,
+                               QComboBox, QFontComboBox, QGraphicsItem, QGraphicsLineItem,
+                               QGraphicsPolygonItem, QGraphicsTextItem,
+                               QGraphicsScene, QGraphicsView, QGridLayout,
+                               QHBoxLayout, QLabel, QMainWindow, QMenu,
+                               QMessageBox, QSizePolicy, QToolBox, QToolButton,
+                               QWidget)
+
+import diagramscene_rc  # noqa: F401
+
+
+class Arrow(QGraphicsLineItem):
+    def __init__(self, startItem, endItem, parent=None, scene=None):
+        super().__init__(parent, scene)
+
+        self._arrow_head = QPolygonF()
+
+        self._my_start_item = startItem
+        self._my_end_item = endItem
+        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
+
+    def start_item(self):
+        return self._my_start_item
+
+    def end_item(self):
+        return self._my_end_item
+
+    def boundingRect(self):
+        extra = (self.pen().width() + 20) / 2.0
+        p1 = self.line().p1()
+        p2 = self.line().p2()
+        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()
+        path.addPolygon(self._arrow_head)
+        return path
+
+    def update_position(self):
+        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)):
+            return
+
+        my_start_item = self._my_start_item
+        my_end_item = self._my_end_item
+        my_color = self._my_color
+        my_pen = self.pen()
+        my_pen.setColor(self._my_color)
+        arrow_size = 20.0
+        painter.setPen(my_pen)
+        painter.setBrush(self._my_color)
+
+        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 = QPointF()
+        for i in end_polygon:
+            p2 = i + my_end_item.pos()
+            poly_line = QLineF(p1, p2)
+            intersectType, intersect_point = poly_line.intersects(center_line)
+            if intersectType == QLineF.BoundedIntersection:
+                break
+            p1 = p2
+
+        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_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]:
+            self._arrow_head.append(point)
+
+        painter.drawLine(line)
+        painter.drawPolygon(self._arrow_head)
+        if self.isSelected():
+            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(QGraphicsTextItem):
+    lost_focus = Signal(QGraphicsTextItem)
+
+    selected_change = Signal(QGraphicsItem)
+
+    def __init__(self, parent=None, scene=None):
+        super().__init__(parent, scene)
+
+        self.setFlag(QGraphicsItem.ItemIsMovable)
+        self.setFlag(QGraphicsItem.ItemIsSelectable)
+
+    def itemChange(self, change, value):
+        if change == QGraphicsItem.ItemSelectedChange:
+            self.selected_change.emit(self)
+        return value
+
+    def focusOutEvent(self, event):
+        self.setTextInteractionFlags(Qt.NoTextInteraction)
+        self.lost_focus.emit(self)
+        super(DiagramTextItem, self).focusOutEvent(event)
+
+    def mouseDoubleClickEvent(self, event):
+        if self.textInteractionFlags() == Qt.NoTextInteraction:
+            self.setTextInteractionFlags(Qt.TextEditorInteraction)
+        super(DiagramTextItem, self).mouseDoubleClickEvent(event)
+
+
+class DiagramItem(QGraphicsPolygonItem):
+    Step, Conditional, StartEnd, Io = range(4)
+
+    def __init__(self, diagram_type, contextMenu, parent=None, scene=None):
+        super().__init__(parent, scene)
+
+        self.arrows = []
+
+        self.diagram_type = diagram_type
+        self._my_context_menu = contextMenu
+
+        path = QPainterPath()
+        if self.diagram_type == self.StartEnd:
+            path.moveTo(200, 50)
+            path.arcTo(150, 0, 50, 50, 0, 90)
+            path.arcTo(50, 0, 50, 50, 90, 90)
+            path.arcTo(50, 50, 50, 50, 180, 90)
+            path.arcTo(150, 50, 50, 50, 270, 90)
+            path.lineTo(200, 25)
+            self._my_polygon = path.toFillPolygon()
+        elif self.diagram_type == self.Conditional:
+            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 = QPolygonF([
+                QPointF(-100, -100), QPointF(100, -100),
+                QPointF(100, 100), QPointF(-100, 100),
+                QPointF(-100, -100)])
+        else:
+            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(QGraphicsItem.ItemIsMovable, True)
+        self.setFlag(QGraphicsItem.ItemIsSelectable, True)
+
+    def remove_arrow(self, arrow):
+        try:
+            self.arrows.remove(arrow)
+        except ValueError:
+            pass
+
+    def remove_arrows(self):
+        for arrow in self.arrows[:]:
+            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 = QPixmap(250, 250)
+        pixmap.fill(Qt.transparent)
+        with QPainter(pixmap) as painter:
+            painter.setPen(QPen(Qt.black, 8))
+            painter.translate(125, 125)
+            painter.drawPolyline(self._my_polygon)
+        return pixmap
+
+    def contextMenuEvent(self, event):
+        self.scene().clearSelection()
+        self.setSelected(True)
+        self._my_context_menu.exec(event.screenPos())
+
+    def itemChange(self, change, value):
+        if change == QGraphicsItem.ItemPositionChange:
+            for arrow in self.arrows:
+                arrow.updatePosition()
+
+        return value
+
+
+class DiagramScene(QGraphicsScene):
+    InsertItem, InsertLine, InsertText, MoveItem = range(4)
+
+    item_inserted = Signal(DiagramItem)
+
+    text_inserted = Signal(QGraphicsTextItem)
+
+    item_selected = Signal(QGraphicsItem)
+
+    def __init__(self, itemMenu, parent=None):
+        super().__init__(parent)
+
+        self._my_item_menu = itemMenu
+        self._my_mode = self.MoveItem
+        self._my_item_type = DiagramItem.Step
+        self.line = None
+        self._text_item = None
+        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.set_color(self._my_line_color)
+            self.update()
+
+    def set_text_color(self, color):
+        self._my_text_color = color
+        if self.is_item_change(DiagramTextItem):
+            item = self.selectedItems()[0]
+            item.setDefaultTextColor(self._my_text_color)
+
+    def set_item_color(self, color):
+        self._my_item_color = color
+        if self.is_item_change(DiagramItem):
+            item = self.selectedItems()[0]
+            item.setBrush(self._my_item_color)
+
+    def set_font(self, font):
+        self._my_font = font
+        if self.is_item_change(DiagramTextItem):
+            item = self.selectedItems()[0]
+            item.setFont(self._my_font)
+
+    def set_mode(self, mode):
+        self._my_mode = mode
+
+    def set_item_type(self, type):
+        self._my_item_type = type
+
+    def editor_lost_focus(self, item):
+        cursor = item.textCursor()
+        cursor.clearSelection()
+        item.setTextCursor(cursor)
+
+        if not item.toPlainText():
+            self.removeItem(item)
+            item.deleteLater()
+
+    def mousePressEvent(self, mouseEvent):
+        if (mouseEvent.button() != Qt.LeftButton):
+            return
+
+        if self._my_mode == self.InsertItem:
+            item = DiagramItem(self._my_item_type, self._my_item_menu)
+            item.setBrush(self._my_item_color)
+            self.addItem(item)
+            item.setPos(mouseEvent.scenePos())
+            self.item_inserted.emit(item)
+        elif self._my_mode == self.InsertLine:
+            self.line = QGraphicsLineItem(QLineF(mouseEvent.scenePos(), mouseEvent.scenePos()))
+            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(Qt.TextEditorInteraction)
+            text_item.setZValue(1000.0)
+            text_item.lost_focus.connect(self.editor_lost_focus)
+            text_item.selected_change.connect(self.item_selected)
+            self.addItem(text_item)
+            text_item.setDefaultTextColor(self._my_text_color)
+            text_item.setPos(mouseEvent.scenePos())
+            self.text_inserted.emit(text_item)
+
+        super(DiagramScene, self).mousePressEvent(mouseEvent)
+
+    def mouseMoveEvent(self, mouseEvent):
+        if self._my_mode == self.InsertLine and self.line:
+            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)
+
+    def mouseReleaseEvent(self, mouseEvent):
+        if self.line and self._my_mode == self.InsertLine:
+            start_items = self.items(self.line.line().p1())
+            if len(start_items) and start_items[0] == self.line:
+                start_items.pop(0)
+            end_items = self.items(self.line.line().p2())
+            if len(end_items) and end_items[0] == self.line:
+                end_items.pop(0)
+
+            self.removeItem(self.line)
+            self.line = None
+
+            if (len(start_items) and len(end_items)
+                    and isinstance(start_items[0], DiagramItem)
+                    and isinstance(end_items[0], DiagramItem)
+                    and start_items[0] != end_items[0]):
+                start_item = start_items[0]
+                end_item = end_items[0]
+                arrow = Arrow(start_item, end_item)
+                arrow.set_color(self._my_line_color)
+                start_item.add_arrow(arrow)
+                end_item.add_arrow(arrow)
+                arrow.setZValue(-1000.0)
+                self.addItem(arrow)
+                arrow.update_position()
+
+        self.line = None
+        super(DiagramScene, self).mouseReleaseEvent(mouseEvent)
+
+    def is_item_change(self, type):
+        for item in self.selectedItems():
+            if isinstance(item, type):
+                return True
+        return False
+
+
+class MainWindow(QMainWindow):
+    insert_text_button = 10
+
+    def __init__(self):
+        super().__init__()
+
+        self.create_actions()
+        self.create_menus()
+        self.create_tool_box()
+
+        self.scene = DiagramScene(self._item_menu)
+        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 = QHBoxLayout()
+        layout.addWidget(self._tool_box)
+        self.view = QGraphicsView(self.scene)
+        layout.addWidget(self.view)
+
+        self.widget = QWidget()
+        self.widget.setLayout(layout)
+
+        self.setCentralWidget(self.widget)
+        self.setWindowTitle("Diagramscene")
+
+    @Slot(QAbstractButton)
+    def background_button_group_clicked(self, button):
+        buttons = self._background_button_group.buttons()
+        for myButton in buttons:
+            if myButton != button:
+                button.setChecked(False)
+
+        text = button.text()
+        if text == "Blue Grid":
+            self.scene.setBackgroundBrush(QBrush(QPixmap(':/images/background1.png')))
+        elif text == "White Grid":
+            self.scene.setBackgroundBrush(QBrush(QPixmap(':/images/background2.png')))
+        elif text == "Gray Grid":
+            self.scene.setBackgroundBrush(QBrush(QPixmap(':/images/background3.png')))
+        else:
+            self.scene.setBackgroundBrush(QBrush(QPixmap(':/images/background4.png')))
+
+        self.scene.update()
+        self.view.update()
+
+    @Slot(int)
+    def button_group_clicked(self, idx):
+        buttons = self._button_group.buttons()
+        for button in buttons:
+            if self._button_group.button(idx) != button:
+                button.setChecked(False)
+
+        if idx == self.insert_text_button:
+            self.scene.set_mode(DiagramScene.InsertText)
+        else:
+            self.scene.set_item_type(idx)
+            self.scene.set_mode(DiagramScene.InsertItem)
+
+    @Slot()
+    def delete_item(self):
+        for item in self.scene.selectedItems():
+            if isinstance(item, DiagramItem):
+                item.remove_arrows()
+            self.scene.removeItem(item)
+
+    @Slot(int)
+    def pointer_group_clicked(self, i):
+        self.scene.set_mode(self._pointer_type_group.checkedId())
+
+    @Slot()
+    def bring_to_front(self):
+        if not self.scene.selectedItems():
+            return
+
+        selected_item = self.scene.selectedItems()[0]
+        overlap_items = selected_item.collidingItems()
+
+        z_value = 0
+        for item in overlap_items:
+            if (item.zValue() >= z_value and isinstance(item, DiagramItem)):
+                z_value = item.zValue() + 0.1
+        selected_item.setZValue(z_value)
+
+    @Slot()
+    def send_to_back(self):
+        if not self.scene.selectedItems():
+            return
+
+        selected_item = self.scene.selectedItems()[0]
+        overlap_items = selected_item.collidingItems()
+
+        z_value = 0
+        for item in overlap_items:
+            if (item.zValue() <= z_value and isinstance(item, DiagramItem)):
+                z_value = item.zValue() - 0.1
+        selected_item.setZValue(z_value)
+
+    @Slot(QGraphicsPolygonItem)
+    def item_inserted(self, item):
+        self._pointer_type_group.button(DiagramScene.MoveItem).setChecked(True)
+        self.scene.set_mode(self._pointer_type_group.checkedId())
+        self._button_group.button(item.diagram_type).setChecked(False)
+
+    @Slot(QGraphicsTextItem)
+    def text_inserted(self, item):
+        self._button_group.button(self.insert_text_button).setChecked(False)
+        self.scene.set_mode(self._pointer_type_group.checkedId())
+
+    @Slot(QFont)
+    def current_font_changed(self, font):
+        self.handle_font_change()
+
+    @Slot(int)
+    def font_size_changed(self, font):
+        self.handle_font_change()
+
+    @Slot(str)
+    def scene_scale_changed(self, scale):
+        new_scale = int(scale[:-1]) / 100.0
+        old_matrix = self.view.transform()
+        self.view.resetTransform()
+        self.view.translate(old_matrix.dx(), old_matrix.dy())
+        self.view.scale(new_scale, new_scale)
+
+    @Slot()
+    def text_color_changed(self):
+        self._text_action = self.sender()
+        self._font_color_tool_button.setIcon(self.create_color_tool_button_icon(
+            ':/images/textpointer.png', QColor(self._text_action.data())))
+        self.text_button_triggered()
+
+    @Slot()
+    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', QColor(self._fill_action.data())))
+        self.fill_button_triggered()
+
+    @Slot()
+    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', QColor(self._line_action.data())))
+        self.line_button_triggered()
+
+    @Slot()
+    def text_button_triggered(self):
+        self.scene.set_text_color(QColor(self._text_action.data()))
+
+    @Slot()
+    def fill_button_triggered(self):
+        self.scene.set_item_color(QColor(self._fill_action.data()))
+
+    @Slot()
+    def line_button_triggered(self):
+        self.scene.set_line_color(QColor(self._line_action.data()))
+
+    @Slot()
+    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(QFont.Bold)
+        else:
+            font.setWeight(QFont.Normal)
+        font.setItalic(self._italic_action.isChecked())
+        font.setUnderline(self._underline_action.isChecked())
+
+        self.scene.set_font(font)
+
+    @Slot(QGraphicsItem)
+    def item_selected(self, item):
+        font = item.font()
+        self._font_combo.setCurrentFont(font)
+        self._font_size_combo.setEditText(str(font.pointSize()))
+        self._bold_action.setChecked(font.weight() == QFont.Bold)
+        self._italic_action.setChecked(font.italic())
+        self._underline_action.setChecked(font.underline())
+
+    @Slot()
+    def about(self):
+        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 = QButtonGroup()
+        self._button_group.setExclusive(False)
+        self._button_group.idClicked.connect(self.button_group_clicked)
+
+        layout = QGridLayout()
+        layout.addWidget(self.create_cell_widget("Conditional", DiagramItem.Conditional), 0, 0)
+        layout.addWidget(self.create_cell_widget("Process", DiagramItem.Step), 0, 1)
+        layout.addWidget(self.create_cell_widget("Input/Output", DiagramItem.Io), 1, 0)
+
+        text_button = QToolButton()
+        text_button.setCheckable(True)
+        self._button_group.addButton(text_button, self.insert_text_button)
+        text_button.setIcon(QIcon(QPixmap(':/images/textpointer.png')
+                            .scaled(30, 30)))
+        text_button.setIconSize(QSize(50, 50))
+
+        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 = QWidget()
+        item_widget.setLayout(layout)
+
+        self._background_button_group = QButtonGroup()
+        self._background_button_group.buttonClicked.connect(self.background_button_group_clicked)
+
+        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", ':/images/background2.png'), 0, 1)
+        background_layout.addWidget(
+            self.create_background_cell_widget("Gray Grid", ':/images/background3.png'), 1, 0)
+        background_layout.addWidget(
+            self.create_background_cell_widget("No Grid", ':/images/background4.png'), 1, 1)
+
+        background_layout.setRowStretch(2, 10)
+        background_layout.setColumnStretch(2, 10)
+
+        background_widget = QWidget()
+        background_widget.setLayout(background_layout)
+
+        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 = 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 = 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 = QAction(QIcon(':/images/delete.png'),
+                                      "&Delete", self, shortcut="Delete",
+                                      statusTip="Delete item from diagram",
+                                      triggered=self.delete_item)
+
+        self._exit_action = QAction("E&xit", self, shortcut="Ctrl+X",
+                                    statusTip="Quit Scenediagram example", triggered=self.close)
+
+        self._bold_action = QAction(QIcon(':/images/bold.png'),
+                                    "Bold", self, checkable=True, shortcut="Ctrl+B",
+                                    triggered=self.handle_font_change)
+
+        self._italic_action = QAction(QIcon(':/images/italic.png'),
+                                      "Italic", self, checkable=True, shortcut="Ctrl+I",
+                                      triggered=self.handle_font_change)
+
+        self._underline_action = QAction(
+            QIcon(':/images/underline.png'), "Underline", self,
+            checkable=True, shortcut="Ctrl+U",
+            triggered=self.handle_font_change)
+
+        self._about_action = QAction("A&bout", self, shortcut="Ctrl+B", triggered=self.about)
+
+    def create_menus(self):
+        self._file_menu = self.menuBar().addMenu("&File")
+        self._file_menu.addAction(self._exit_action)
+
+        self._item_menu = self.menuBar().addMenu("&Item")
+        self._item_menu.addAction(self._delete_action)
+        self._item_menu.addSeparator()
+        self._item_menu.addAction(self._to_front_action)
+        self._item_menu.addAction(self._send_back_action)
+
+        self._about_menu = self.menuBar().addMenu("&Help")
+        self._about_menu.addAction(self._about_action)
+
+    def create_toolbars(self):
+        self._edit_tool_bar = self.addToolBar("Edit")
+        self._edit_tool_bar.addAction(self._delete_action)
+        self._edit_tool_bar.addAction(self._to_front_action)
+        self._edit_tool_bar.addAction(self._send_back_action)
+
+        self._font_combo = QFontComboBox()
+        self._font_combo.currentFontChanged.connect(self.current_font_changed)
+
+        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 = 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 = QToolButton()
+        self._font_color_tool_button.setPopupMode(QToolButton.MenuButtonPopup)
+        self._font_color_tool_button.setMenu(
+            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', 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 = QToolButton()
+        self._fill_color_tool_button.setPopupMode(QToolButton.MenuButtonPopup)
+        self._fill_color_tool_button.setMenu(
+            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', Qt.white))
+        self._fill_color_tool_button.clicked.connect(self.fill_button_triggered)
+
+        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, 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', Qt.black))
+        self._line_color_tool_button.clicked.connect(self.line_button_triggered)
+
+        self._text_tool_bar = self.addToolBar("Font")
+        self._text_tool_bar.addWidget(self._font_combo)
+        self._text_tool_bar.addWidget(self._font_size_combo)
+        self._text_tool_bar.addAction(self._bold_action)
+        self._text_tool_bar.addAction(self._italic_action)
+        self._text_tool_bar.addAction(self._underline_action)
+
+        self._color_tool_bar = self.addToolBar("Color")
+        self._color_tool_bar.addWidget(self._font_color_tool_button)
+        self._color_tool_bar.addWidget(self._fill_color_tool_button)
+        self._color_tool_bar.addWidget(self._line_color_tool_button)
+
+        pointer_button = QToolButton()
+        pointer_button.setCheckable(True)
+        pointer_button.setChecked(True)
+        pointer_button.setIcon(QIcon(':/images/pointer.png'))
+        line_pointer_button = QToolButton()
+        line_pointer_button.setCheckable(True)
+        line_pointer_button.setIcon(QIcon(':/images/linepointer.png'))
+
+        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 = 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)
+
+        self._pointer_toolbar = self.addToolBar("Pointer type")
+        self._pointer_toolbar.addWidget(pointer_button)
+        self._pointer_toolbar.addWidget(line_pointer_button)
+        self._pointer_toolbar.addWidget(self._scene_scale_combo)
+
+    def create_background_cell_widget(self, text, image):
+        button = QToolButton()
+        button.setText(text)
+        button.setIcon(QIcon(image))
+        button.setIconSize(QSize(50, 50))
+        button.setCheckable(True)
+        self._background_button_group.addButton(button)
+
+        layout = QGridLayout()
+        layout.addWidget(button, 0, 0, Qt.AlignHCenter)
+        layout.addWidget(QLabel(text), 1, 0, Qt.AlignCenter)
+
+        widget = QWidget()
+        widget.setLayout(layout)
+
+        return widget
+
+    def create_cell_widget(self, text, diagram_type):
+        item = DiagramItem(diagram_type, self._item_menu)
+        icon = QIcon(item.image())
+
+        button = QToolButton()
+        button.setIcon(icon)
+        button.setIconSize(QSize(50, 50))
+        button.setCheckable(True)
+        self._button_group.addButton(button, diagram_type)
+
+        layout = QGridLayout()
+        layout.addWidget(button, 0, 0, Qt.AlignHCenter)
+        layout.addWidget(QLabel(text), 1, 0, Qt.AlignCenter)
+
+        widget = QWidget()
+        widget.setLayout(layout)
+
+        return widget
+
+    def create_color_menu(self, slot, defaultColor):
+        colors = [Qt.black, Qt.white, Qt.red, Qt.blue, Qt.yellow]
+        names = ["black", "white", "red", "blue", "yellow"]
+
+        color_menu = QMenu(self)
+        for color, name in zip(colors, names):
+            action = QAction(self.create_color_icon(color), name, self, triggered=slot)
+            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 = QPixmap(50, 80)
+        pixmap.fill(Qt.transparent)
+
+        with QPainter(pixmap) as painter:
+            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)
+
+        return QIcon(pixmap)
+
+    def create_color_icon(self, color):
+        pixmap = QPixmap(20, 20)
+
+        with QPainter(pixmap) as painter:
+            painter.setPen(Qt.NoPen)
+            painter.fillRect(QRect(0, 0, 20, 20), color)
+
+        return QIcon(pixmap)
+
+
+if __name__ == '__main__':
+    app = QApplication(sys.argv)
+
+    main_window = MainWindow()
+    main_window.setGeometry(100, 100, 800, 500)
+    main_window.show()
+
+    sys.exit(app.exec())