examples/widgets/graphicsview/diagramscene#
(You can also check this code in the repository)
<!DOCTYPE RCC><RCC version="1.0">
<qresource>
<file>images/pointer.png</file>
<file>images/linepointer.png</file>
<file>images/textpointer.png</file>
<file>images/bold.png</file>
<file>images/italic.png</file>
<file>images/underline.png</file>
<file>images/floodfill.png</file>
<file>images/bringtofront.png</file>
<file>images/delete.png</file>
<file>images/sendtoback.png</file>
<file>images/linecolor.png</file>
<file>images/background1.png</file>
<file>images/background2.png</file>
<file>images/background3.png</file>
<file>images/background4.png</file>
</qresource>
</RCC>
# 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
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())