def __init__(self, *args):
QGraphicsScene.__init__(self, *args)
# Add a graphic item, not responsive to gestures??
text = QGraphicsTextItem("Test")
text.setTextInteractionFlags(Qt.TextEditorInteraction)
self.addItem(text)
class ActionItem(GraphicsItem):
def __init__(self, model_item: SimulatorItem, parent=None):
super().__init__(model_item=model_item, parent=parent)
self.setFlag(QGraphicsTextItem.ItemIsPanel, True)
self.text = QGraphicsTextItem(self)
self.text.setFont(self.font)
def update_flags(self):
if self.scene().mode == 0:
self.set_flags(is_selectable=True, is_movable=True, accept_hover_events=True, accept_drops=True)
def update_position(self, x_pos, y_pos):
self.setPos(x_pos, y_pos)
start_x = (self.scene().items_width() - self.labels_width()) / 2
self.number.setPos(start_x, 0)
start_x += self.number.boundingRect().width()
self.text.setPos(start_x, 0)
width = self.scene().items_width()
self.prepareGeometryChange()
self.bounding_rect = QRectF(0, 0, width, self.childrenBoundingRect().height() + 5)
def labels_width(self):
width = self.number.boundingRect().width()
width += self.text.boundingRect().width()
return width
def __init__(self, dir_assets, *args):
super().__init__(*args)
self.name = "Jugador {0}".format(Main_Player.contador)
self.sprite_generator = sprite_generator(dir_assets, 7, 8)
next(self.sprite_generator)
self.experience = 0
self.progress_bar = Progress_Bar(1000)
self.set_health_var()
self.set_pixmap_image()
self.set_attack_timer()
self.set_animation_timer()
self.attack_velocity = 1000
self.move = True
self.atacar = True
self.level_impar = False
self.set_movement_timer()
self.setTransformOriginPoint(50 * self.ponderador,
50 * self.ponderador)
self.score = 0
self.set_score_timer()
self.score_label = QGraphicsTextItem()
self.score_label.setDefaultTextColor(QColor("green"))
Main_Player.contador += 1
def drawNode(self, index, node_pos, is_near):
# 样式设置
node_draw_r = 15
node_draw_x = node_pos.x() - node_draw_r
node_draw_y = node_pos.y() - node_draw_r
# node_draw_pos = QPointF(node_draw_x, node_draw_y)
node_draw_pen = QPen(QColor(204, 47, 105), 3, Qt.SolidLine)
node_draw_brush = QBrush(QColor(255, 110, 151), Qt.SolidPattern)
# 正式画圆
self.gellipse_node = self.gscene_map.addEllipse(
node_draw_x, node_draw_y, 2 * node_draw_r, 2 * node_draw_r,
node_draw_pen, node_draw_brush)
# 索引号
self.text_index = '<div style=\"font:26px;color:black;font-weight:900;\">' + \
str(index) + '</div>'
self.gtext_index = QGraphicsTextItem()
self.gtext_index.setHtml(self.text_index)
self.gtext_index.setParentItem(self.gellipse_node)
self.gtext_index.setPos(node_draw_x + 4, node_draw_y - 2)
if is_near: # 若附近rssi判断有效
node_draw_r = 20
node_draw_x = node_pos.x() - node_draw_r
node_draw_y = node_pos.y() - node_draw_r
node_draw_pen = QPen(QColor(245, 229, 143), 10, Qt.DashLine)
self.gscene_map.addEllipse(node_draw_x, node_draw_y,
2 * node_draw_r, 2 * node_draw_r,
node_draw_pen)
class ActionItem(GraphicsItem):
def __init__(self, model_item: SimulatorItem, parent=None):
super().__init__(model_item=model_item, parent=parent)
self.setFlag(QGraphicsTextItem.ItemIsPanel, True)
self.text = QGraphicsTextItem(self)
self.text.setFont(GraphicsItem.font)
def update_flags(self):
if self.scene().mode == 0:
self.set_flags(is_selectable=True,
is_movable=True,
accept_hover_events=True,
accept_drops=True)
def update_position(self, x_pos, y_pos):
self.setPos(x_pos, y_pos)
start_x = (self.scene().items_width() - self.labels_width()) / 2
self.number.setPos(start_x, 0)
start_x += self.number.boundingRect().width()
self.text.setPos(start_x, 0)
width = self.scene().items_width()
self.prepareGeometryChange()
self.bounding_rect = QRectF(0, 0, width,
self.childrenBoundingRect().height() + 5)
#super().update_position(x_pos, y_pos)
def labels_width(self):
width = self.number.boundingRect().width()
#width += 5
width += self.text.boundingRect().width()
return width
def __showCircle(self):
ratio = 3
pen = QPen()
pen.setBrush(Qt.red)
pen.setWidth(0.01)
font = QFont()
font.setPointSize(200 * ratio)
self.scene.clear()
for i in range(len(self.pointsXYItem)):
(x, y) = self.pointsXYItem[i]
r = self.radius[i] * ratio
circleItem = QGraphicsEllipseItem(x - r, y - r, 2 * r, 2 * r)
circleItem.setPen(pen)
self.scene.addItem(circleItem)
strItem = QGraphicsTextItem()
strItem.setDefaultTextColor(Qt.blue)
strItem.setFont(font)
strItem.setPlainText(self.pointsName[i])
strItem.setPos(x, y)
self.scene.addItem(strItem)
def __init__(self, *args):
self.__boundingRect = None
QGraphicsObject.__init__(self, *args)
self.setFlag(QGraphicsItem.ItemHasNoContents, True)
self.setAcceptedMouseButtons(Qt.RightButton | Qt.LeftButton)
self.setAcceptHoverEvents(True)
self.setZValue(self.Z_VALUE)
self.sourceItem = None
self.sourceAnchor = None
self.sinkItem = None
self.sinkAnchor = None
self.curveItem = LinkCurveItem(self)
self.sourceIndicator = LinkAnchorIndicator(self)
self.sinkIndicator = LinkAnchorIndicator(self)
self.sourceIndicator.hide()
self.sinkIndicator.hide()
self.linkTextItem = QGraphicsTextItem(self)
self.__sourceName = ""
self.__sinkName = ""
self.__dynamic = False
self.__dynamicEnabled = False
self.hover = False
self.prepareGeometryChange()
self.__boundingRect = None
def __init__(self):
super(Video, self).__init__()
self.resize(1920, 1080)
# ITEM
self._item = QGraphicsVideoItem()
self._textItem = QGraphicsTextItem()
self._view = QGraphicsView()
self._scene = QGraphicsScene()
self._view.resize(1920, 1080)
self._view.setScene(self._scene)
self._scene.addItem(self._item)
self._scene.addItem(self._textItem)
self._textItem.setPlainText('SRT TEXT')
self._textItem.setDefaultTextColor(Qt.red)
font = self._textItem.font()
font.setPixelSize(50)
self._textItem.setFont(font)
self._view.show()
self._item.setSize(QSizeF(1920, 1080))
self._player = QMediaPlayer(self)
self._player.setMedia(
QMediaContent(
QUrl.fromLocalFile(
'/Users/huangkai/Documents/PycharmProjects/AllTest/Qt插入背景/AddVideos/Videos/yellow.mov'
)))
self._player.setVideoOutput(self._item)
self._player.play()
self.setCentralWidget(self._view)
self._item.setPos(400, 500)
# BUTTON
self._btn = QPushButton(self)
self._btn.resize(100, 50)
self._btn.move(500, 500)
self._btn.setText('test')
self._btn.clicked.connect(self._change_text)
def __init__(self, model_item=None, prefix="", parent=None):
"""
Creates a visualization item.
"""
QAbstractGraphicsShapeItem.__init__(self, parent)
self.setFlags(QGraphicsItem.ItemIsSelectable
| QGraphicsItem.ItemIsMovable
| QGraphicsItem.ItemSendsGeometryChanges
| QGraphicsItem.ItemSendsScenePositionChanges)
self._model_item = model_item
if self._model_item is not None:
self._model_item.model().dataChanged.connect(self.onDataChanged)
# initialize members
self._prefix = prefix
self._auto_text_keys = self.defaultAutoTextKeys[:]
self._text = ""
self._text_bg_brush = None
self._text_item = QGraphicsTextItem(self)
self._text_item.setPos(0, 0)
self._text_item.setAcceptHoverEvents(False)
self._text_item.setFlags(QGraphicsItem.ItemIgnoresTransformations)
self._text_item.setHtml(self._compile_text())
self._valid = True
if len(self.cycleValuesOnKeypress) > 0:
logging.warning(
"cycleValueOnKeypress is deprecated and will be removed in the future. "
+ "Set BaseItem.hotkeys instead with cycleValue()")
self.changeColor()
class Arc(QGraphicsLineItem):
def __init__(self, first_node, second_node, weight, scene):
QGraphicsLineItem.__init__(self)
pen = QPen(QColor("green"), 5)
self.first_node = first_node
self.second_node = second_node
self.weight = weight
self.setZValue(1)
self.setPen(pen)
self.setLine(self.first_node.x() + 25,
self.first_node.y() + 25,
self.second_node.x() + 25,
self.second_node.y() + 25)
self.number = QGraphicsTextItem(str(weight))
self.number.setZValue(6)
x = (first_node.x() + second_node.x()) / 2
y = (first_node.y() + second_node.y()) / 2
self.number.setPos(x, y)
scene.addItem(self)
scene.addItem(self.number)
def __str__(self):
return "{" + str(self.first_node.getNumber()) + ", " + str(
self.second_node.getNumber()) + ", " + str(self.weight) + "}"
def reverse(self):
temp = self.first_node
self.first_node = self.second_node
self.second_node = temp
def __init__(self, name, index, addr, rect, text, manager):
self.text = QGraphicsTextItem(text)
self.text_width = self.text.boundingRect().width()
if self.text_width > rect.width() - 6:
rect.setWidth(self.text_width + 6)
self.text_height = self.text.boundingRect().height()
if self.text_height > rect.height() - 6:
rect.setHeight(self.text_height + 6)
super(StateNode, self).__init__(rect)
self.name = name
self.index = index
self.addr = addr
self.text.setPos(rect.topLeft() +
QPointF((rect.width() - self.text_width) / 2, 0))
self.manager = manager
self.setZValue(1)
self.setFlag(QGraphicsItem.ItemIsMovable)
self.setFlag(QGraphicsItem.ItemIsSelectable)
self.setFlag(QGraphicsItem.ItemSendsGeometryChanges)
self.edges = []
self.str_to_node = {
'right': self.right_node,
'top': self.top_node,
'left': self.left_node,
'down': self.down_node,
'top_left': self.tl_node,
'top_right': self.tr_node,
'down_left': self.dl_node,
'down_right': self.dr_node,
}
def __init__(self, parent, text="", color=Qt.white, text_col=Qt.black):
super().__init__(None)
polygon = QPolygonF()
self.width = 175
self.height = 24
polygon.append(QPointF(0, 0))
polygon.append(QPointF(0, self.height))
polygon.append(QPointF(self.width, self.height))
polygon.append(QPointF(self.width, 0))
self.setPolygon(polygon)
# we want black background
bg = QBrush()
col = QColor(color)
col.setAlpha(200)
bg.setColor(col)
bg.setStyle(Qt.SolidPattern)
self.setBrush(bg)
self.text = QGraphicsTextItem(self)
self.text.setDefaultTextColor(QColor(text_col))
self.text.setPlainText(text)
self.show()
def _showLetter(self, i, j):
"""
Graphical representation of a square to fill is created here.
"""
x = j * self.SQUARE_SIZE
y = i * self.SQUARE_SIZE
self.scene.addRect(x, y, self.SQUARE_SIZE, self.SQUARE_SIZE,
QPen(Qt.black, 1, Qt.SolidLine), QBrush(Qt.NoBrush))
square = self.model.grid[i][j]
if len(square) == 1:
numberTextItem = QGraphicsTextItem(str(square[0]))
numberTextItem.setDefaultTextColor(Qt.darkGreen)
numberTextItem.setPos(x + self.SQUARE_SIZE / 3,
y + self.SQUARE_SIZE / 3)
self.scene.addItem(numberTextItem)
else:
for number in square:
numberTextItem = QGraphicsTextItem(str(number))
xPos = x + ((number - 1) % 3) * self.SQUARE_SIZE / 3
yPos = y + ((number - 1) / 3) * self.SQUARE_SIZE / 3
numberTextItem.setPos(xPos, yPos)
self.scene.addItem(numberTextItem)
def focusOutEvent(self, event):
'''Handle focus out event.
Argument(s):
event (QFocusEvent ): Focus event
'''
QGraphicsTextItem.focusOutEvent(self, event)
# Create a fake node to test if label is valid with pydot
fakeNode = ("fake[" + NodeDotAttrs.label.value +
"=" + self.toPlainText() + "]")
pydotGraph = graph_from_dot_data("graph{" + fakeNode + "}")
# Label is valid: we can do the update
if pydotGraph:
dicDotAttrs = {
NodeDotAttrs.label.value:
NodeDotLabelUtils.formatLabel(self.toPlainText())
}
# Update text in other views
node = self.parentItem()
node.graphicsGraphView.controller.onEditNode(node.id, dicDotAttrs)
# Disable edit text
self.setTextInteractionFlags(Qt.NoTextInteraction)
# Label is invalid: force user to write a correct label
else:
QMessageBox.warning(None, "Syntax error",
"The label is invalid.")
self.setFocus()
def addGraphicsItems(self):
self.mainRect = QGraphicsRectItem(QRectF(-15, -15, 30, 30), self)
self.nodeTitle = QGraphicsTextItem(type(self).name, self)
titleFont = QFont()
titleFont.setBold(True)
self.nodeTitle.setFont(titleFont)
self.selectedChanged(self.isSelected())
def __init__(self,
pos,
size,
type_,
parent=None,
scene=None,
areaBorder=2,
index=0,
textSize=50):
QGraphicsRectItem.__init__(self, 0, 0, size.width(), size.height(),
parent)
self.setPos(pos)
self.newEvent = IsClicked()
self.newEvent.area = self
#self.setAcceptedMouseButtons(QtCore.Qt.NoButton)
self.setFlags(QGraphicsItem.ItemIsMovable
| QGraphicsItem.ItemIsFocusable
| QGraphicsItem.ItemIsSelectable)
## set index label
self.text = QGraphicsTextItem("%d" % index, self)
self.setTextSize(textSize)
## TODO: How to create constants for the type?
## (such as constants in Qt) (enum?)
self.kind = type_
pen = QPen(self.color, areaBorder, Qt.SolidLine, Qt.RoundCap,
Qt.RoundJoin)
self.setPen(pen)
def __init__(self, parent):
super().__init__(parent)
self.setRenderHint(QPainter.Antialiasing)
self.chart = self.chart()
self.chart.legend().setVisible(False)
self._chart_loaded = False
self._chart_horizontal_line = QGraphicsLineItem(0, 0, 0, 0)
pen = self._chart_horizontal_line.pen()
pen.setStyle(Qt.DashLine)
self._chart_horizontal_line.setPen(pen)
self.scene().addItem(self._chart_horizontal_line)
self._chart_vertical_line = QGraphicsLineItem(0, 0, 0, 0)
self._chart_vertical_line.setPen(pen)
self.scene().addItem(self._chart_vertical_line)
self._chart_tooltip = QGraphicsTextItem("")
self._chart_tooltip.setPos(100, 20)
self.scene().addItem(self._chart_tooltip)
self._chart_crosshair = QGraphicsTextItem("")
self._chart_crosshair.setPos(600, 20)
self.scene().addItem(self._chart_crosshair)
margins = self.chart.margins()
margins.setTop(margins.top() + 80)
self.chart.setMargins(margins)
def mouseDoubleClickEvent(self, event):
if self.textInteractionFlags() == Qt.NoTextInteraction and \
self.interactionEnabled:
self.setTextInteractionFlags(Qt.TextEditorInteraction)
self.textEditStarted.emit()
QGraphicsTextItem.mouseDoubleClickEvent(self, event)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.setupUi(self)
self.text_aligns = [
('center', 'По центру'),
('left', 'По левому краю'),
('right', 'По правому краю'),
]
self.text_align = 'center'
for align, align_text in self.text_aligns:
self.textPosH.addItem(align_text)
self.item: QGraphicsRectItem = QGraphicsRectItem()
self.main_view: QGraphicsView = QGraphicsView()
self.fontSelect.currentFontChanged.connect(self.render_text)
self.fontSize.valueChanged.connect(self.render_text)
self.textPosH.currentTextChanged.connect(self.render_text)
self.exText.textChanged.connect(self.render_text)
self.font_color = QColor('black')
self.scene = QGraphicsScene()
self.graphicsView.setScene(self.scene)
self.text = QGraphicsTextItem()
self.buttonBox.accepted.connect(self.accepted)
self.colorPicker.clicked.connect(self.select_color)
def __init__(self, name, height=200, width=50, parent=None):
'''name: str '''
super().__init__(parent)
# Set locked atribute
self.locked = False
# create my signal
self.s = ButtonSignal()
# draw the rect
self.setRect(0, 0, height, width)
# change color of rect
brush = QBrush()
brush.setStyle(Qt.SolidPattern)
brush.setColor(Qt.darkCyan)
self.setBrush(brush)
# draw the text
self.text = QGraphicsTextItem(name, self)
x_pos = self.rect().width() / 2 - self.text.boundingRect().width() / 2
y_pos = self.rect().height() / 2 - self.text.boundingRect().height() / 2
self.text.setPos(x_pos, y_pos)
# allow responding to hover events
self.setAcceptHoverEvents(True)
def __init__(self, model_item: SimulatorItem, parent=None):
super().__init__(model_item=model_item, parent=parent)
self.setFlag(QGraphicsTextItem.ItemIsPanel, True)
self.text = QGraphicsTextItem(self)
self.text.setFont(GraphicsItem.font)
def __init__(self, parent=None):
super().__init__(parent)
self.view = VideoGraphicsView()
self.setCentralWidget(self.view)
self.view.videoItem.nativeSizeChanged.connect(
self.handle_native_size_changed)
url = QUrl(
"https://www.learningcontainer.com/wp-content/uploads/2020/05/sample-mp4-file.mp4"
)
self.view.player.setMedia(QMediaContent(url))
self.view.player.play()
self.resize(640, 480)
self.text_item = QGraphicsTextItem(self.view.videoItem)
self.text_item.setHtml(
"""<div style="color: #41CD52; font-weight: bold; font-size: 20px;">Qt is awesome</div>"""
)
self.text_item.hide()
self.animation = QVariantAnimation()
self.animation.setDuration(1000)
self.animation.setStartValue(QPointF(0.0, 0.0))
self.animation.setEndValue(QPointF(0.0, 0.0))
self.animation.valueChanged.connect(self.text_item.setPos)
self.animation.finished.connect(self.start_of_start_animation)
def __drawPoint(self, x, y, index):
#横线
line1 = QGraphicsLineItem()
line1.setPen(self.pen)
line1.setLine(x - self.lineRadius, y, x + self.lineRadius, y)
#竖线
line2 = QGraphicsLineItem()
line2.setPen(self.pen)
line2.setLine(x, y - self.lineRadius, x, y + self.lineRadius)
#文字说明
text = QGraphicsTextItem()
text.setDefaultTextColor(Qt.blue)
text.setFont(self.font)
text.setPlainText(self.pointsName[index])
text.setPos(x, y)
#放到组中
pointGroup = QGraphicsItemGroup()
pointGroup.addToGroup(line1)
pointGroup.addToGroup(line2)
pointGroup.addToGroup(text)
#显示
if self.pointsItem[index] is not None:
self.scene.removeItem(self.pointsItem[index])
#保存到字典
self.pointsItem[index] = pointGroup
#显示该点
self.scene.addItem(self.pointsItem[index])
class ReadoutView(View):
class Orientation(Enum):
horizontal = 1
vertical = 2
def __init__(self, model):
super().__init__(model)
self.graphics_item = QGraphicsRectItem(0, 0, 9, 9)
self.graphics_item.setBrush(Qt.black)
inner_rect_item = QGraphicsRectItem(1, 1, 7, 7, self.graphics_item)
inner_rect_item.setBrush(Qt.white)
self.text_item = None
self.orientation = ReadoutView.Orientation.horizontal
def line(self):
for child in self.graphics_item.childItems():
if isinstance(child, QGraphicsLineItem):
return child.line()
def line_item(self):
for child in self.graphics_item.childItems():
if isinstance(child, QGraphicsLineItem):
return child
def init_text(self):
width = self.graphics_item.boundingRect().width()
height = self.graphics_item.boundingRect().height()
self.text_item = QGraphicsTextItem(self.graphics_item)
self.text_item.setPos(width / 2 + 2, -height)
def init(self, parent=None):
QGraphicsTextItem.__init__(self, parent)
self.setPlainText("Wave: 0 Score: 0")
self.setFont(QFont("Robotica", 15))
self.setDefaultTextColor(QColor(255, 255, 0))
self.setPos(10, 670)
def focusOutEvent(self, event):
'''Handle focus out event.
Argument(s):
event (QFocusEvent ): Focus event
'''
QGraphicsTextItem.focusOutEvent(self, event)
# Create a fake node to test if label is valid with pydot
fakeNode = ("fake[" + NodeDotAttrs.label.value +
"=" + self.toPlainText() + "]")
pydotGraph = graph_from_dot_data("graph{" + fakeNode + "}")
# Label is valid: we can do the update
if pydotGraph:
dicDotAttrs = {
NodeDotAttrs.label.value:
NodeDotLabelUtils.formatLabel(self.toPlainText())
}
# Update text in other views
node = self.parentItem()
node.graphicsGraphView.controller.onEditNode(node.id, dicDotAttrs)
# Disable edit text
self.setTextInteractionFlags(Qt.NoTextInteraction)
# Label is invalid: force user to write a correct label
else:
QMessageBox.warning(None, "Syntax error",
"The label is invalid.")
self.setFocus()
def __init__(self, row, column, enabled, *args):
self._detector_id = box_id(row, column)
self._enabled = enabled
self._selected = False
self._rect = QRectF(*args)
self._rect.setHeight(self.length)
self._rect.setWidth(self.length)
super().__init__(self._rect)
self.setPen(self.invisible_pen)
self.setAcceptHoverEvents(True)
if enabled:
self.setBrush(self.enabled_brush)
else:
self.setBrush(self.disabled_brush)
# states: enabled, disabled, hovered, selected
self._label = QGraphicsTextItem(str(self.detector_id), self)
self._label.setTransform(flip_vertical, True)
self._label.setFont(QFont('Arial', 14))
self._label.setDefaultTextColor(QColor('white'))
self._detector_selector = None
def _constructTree(self, node, x, y, par_x, par_y, text, squared=True, depth=1, h_index=0):
if squared:
node_item = BinTreeSquareNodeGraphicsItem(text, depth=depth)
else:
node_item = BinTreeNodeGraphicsItem(text, depth=depth)
self.nodeCount += 1
node_item.setBrush(Qt.white)
if node.data in self.regionPoints:
node_item.setPen(Qt.green)
self.addItem(node_item)
node_item.moveBy(x, y)
dx, dy = self.width() / (2 ** (depth + 2)), 2 * self.nodeWidth
text_item = QGraphicsTextItem(text)
text_item.moveBy(x-self.nodeWidth/4, y-self.nodeWidth/4)
self.addItem(text_item)
edge = QGraphicsLineItem(x, y, par_x, par_y)
edge.setZValue(-1)
self.addItem(edge)
if node.left:
self._constructTree(node.left, x-dx, y+dy, x, y, str(node.left.data), not squared, depth+1, 2*h_index)
if node.right:
self._constructTree(node.right, x+dx, y+dy, x, y, str(node.right.data), not squared, depth+1, 2*h_index+1)
def __init__(self, origin: QGraphicsRectItem, destination: QGraphicsRectItem, scene):
super(GraphicLine, self).__init__()
self.origin = origin
self.destination = destination
self.scene = scene
# This flag confirms a legal connection
self.is_valid = True
# Get the four sides of the rects
destination_lines = u.get_sides_of(self.destination.sceneBoundingRect())
origin_lines = u.get_sides_of(self.origin.sceneBoundingRect())
# Get the shortest edge between the two blocks
self.setLine(self.gen_endpoints(origin_lines, destination_lines))
self.brush = QBrush(QColor(style.GREY_0))
self.pen = QPen(QColor(style.GREY_0))
self.pen.setWidth(4)
self.pen.setCapStyle(Qt.RoundCap)
self.pen.setJoinStyle(Qt.RoundJoin)
self.setPen(self.pen)
# Dimensions labels
self.dim_label = QGraphicsTextItem()
self.dim_label.setZValue(6)
self.scene.addItem(self.dim_label)
# Arrow head
self.arrow_head = QGraphicsPolygonItem()
self.arrow_head.setPen(self.pen)
self.arrow_head.setBrush(self.brush)
self.arrow_size = 15.0
self.draw_arrow()
class LabelItem(GraphicsItem):
font_bold_italic = None
def __init__(self, model_item: SimulatorProtocolLabel, parent=None):
assert isinstance(model_item, SimulatorProtocolLabel)
super().__init__(model_item=model_item, parent=parent)
self.name = QGraphicsTextItem(self)
self.name.setFont(GraphicsItem.font)
def update_flags(self):
if self.scene().mode == 1:
self.set_flags(is_selectable=True, accept_hover_events=True)
def update_numbering(self):
pass
def paint(self, painter, option, widget):
painter.setBrush(constants.LABEL_COLORS[self.model_item.color_index])
painter.drawRect(self.boundingRect())
if self.scene().mode == 1:
super().paint(painter, option, widget)
def boundingRect(self):
return self.childrenBoundingRect()
def refresh(self):
self.name.setPlainText(self.model_item.name)
def setPlainText(self, text):
'''Sets the item's text to text.
Argument(s):
text (str): New text
'''
QGraphicsTextItem.setPlainText(self, text)
self.parentItem().updateShapeAndEdges()
def mousePressEvent(self, e):
modifiers = QApplication.keyboardModifiers()
if modifiers == Qt.ControlModifier:
e.ignore()
else:
for item in self.scene().selectedItems():
item.setSelected(False)
QGraphicsTextItem.mousePressEvent(self, e)
def keyPressEvent(self, event):
'''Handle key pressed event.
Argument(s):
event (QKeyEvent): Key event
'''
QGraphicsTextItem.keyPressEvent(self, event)
self.parentItem().updateShapeAndEdges()
def setPlainText(self, text):
'''Sets the item's text to text.
Argument(s):
text (str): New text
'''
QGraphicsTextItem.setPlainText(self, text)
self.parentItem().updateShapeAndEdges()
def initTitle(self):
"""Title is instanciated as `QGraphicsTextItem`"""
# Draw the _title
self.title_item = QGraphicsTextItem(self)
self.title_item.node = self.node # add reference to the node
self.title_item.setDefaultTextColor(self._title_color)
self.title_item.setFont(self._title_font)
self.title_item.setPos(self.title_horizontal_padding, 0)
def mousePressEvent(self, e):
modifiers = QApplication.keyboardModifiers()
if modifiers == Qt.ControlModifier:
e.ignore()
else:
for item in self.scene().selectedItems():
item.setSelected(False)
QGraphicsTextItem.mousePressEvent(self, e)
def __init__(self, model_item: SimulatorRuleCondition, parent=None):
assert isinstance(model_item, SimulatorRuleCondition)
super().__init__(model_item=model_item, parent=parent)
self.number.setFont(self.font_bold)
self.text = QGraphicsTextItem(self)
self.text.setPlainText(self.model_item.type.value)
self.text.setFont(self.font_bold)
self.desc = QGraphicsTextItem(self)
self.desc.setFont(self.font)
def __init__(self, parent=None):
QGraphicsView.__init__(self, parent)
self.updateSecs = 0.5
# Border
self.setLineWidth(0)
self.setFrameShape(QtWidgets.QFrame.NoFrame)
# Size
sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
sizePolicy.setHeightForWidth(True)
self.setSizePolicy(sizePolicy)
# No scrollbars
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
# Scene
self.scene = QGraphicsScene()
self.setScene(self.scene)
self.setBackgroundBrush(QColor("black"))
# Text of clock
self.textItem = QGraphicsTextItem()
self.textItem.color = QColor(QColor("black"))
self.textItem.setFont(QFont("Segoe UI", 80))
self.textItem.setDefaultTextColor(QColor("white"))
self.textItem.setHtml("")
self.textItem.setZValue(20)
self.scene.addItem(self.textItem)
# Start ticking
self.start()
def __init__(self, model_item: SimulatorItem, parent=None):
super().__init__(model_item=model_item, parent=parent)
self.setFlag(QGraphicsTextItem.ItemIsPanel, True)
self.text = QGraphicsTextItem(self)
self.text.setFont(self.font)
def addGraphicsItems(self):
self.mainRect = QGraphicsRectItem(QRectF(-15, -15, 30, 30), self)
self.nodeTitle = QGraphicsTextItem(type(self).name, self)
titleFont = QFont()
titleFont.setBold(True)
self.nodeTitle.setFont(titleFont)
self.selectedChanged(self.isSelected())
def _setupTextItem(self):
#Set up the text
self.textItem=QGraphicsTextItem("",parent=self)
textItem=self.textItem
font=QFont()
font.setPointSize(self._fontSize)
textItem.setFont(font)
textItem.setPos(QPointF(0,0)) #upper left corner relative to the father
textItem.setDefaultTextColor(self._fontColor)
if self._dbg:
#another text item only for debug
self.textItemBottom=QGraphicsTextItem("",parent=self)
self.textItemBottom.setPos(QPointF(self.width,self.height))
self.textItemBottom.setDefaultTextColor(QColor(255, 255, 255))
self._updateTextBottom("shape " +str(self.shape))
def __init__(self, model_item: SimulatorMessage, parent=None):
assert isinstance(model_item, SimulatorMessage)
super().__init__(model_item=model_item, parent=parent)
self.setFlag(QGraphicsItem.ItemIsPanel, True)
self.arrow = MessageArrowItem(self)
self.repeat_text = QGraphicsTextItem(self)
self.repeat_text.setFont(self.font)
def __init__(self, parent=None, graphicView=None, graphicScene=None):
super(ClassModel, self).__init__()
self.set_default_data()
self.className = QGraphicsTextItem(self)
self.functionsItem = FunctionsContainerModel(self)
self.className.setPlainText(self.defaultClassName)
self.setFlag(self.ItemIsMovable)
self.setFlag(self.ItemSendsGeometryChanges)
self.functionsItem.setPos(0, self.__get_title_height())
self.attributesItem = FunctionsContainerModel(self)
self.attributesItem.setPos(0, self.functionsItem.get_height())
def __init__(self, model_item: Participant, parent=None):
super().__init__(parent)
self.model_item = model_item
self.text = QGraphicsTextItem(self)
self.line = QGraphicsLineItem(self)
self.line.setPen(QPen(Qt.darkGray, 1, Qt.DashLine, Qt.RoundCap, Qt.RoundJoin))
self.refresh()
def reshape(self):
''' Update the shape of the edge (redefined function) '''
path = QPainterPath()
# If there is a starting point, draw a line to the first curve point
if self.start_point:
path.moveTo(self.source_connection.center)
path.lineTo(self.bezier[0])
else:
path.moveTo(self.source_connection.center)
# Loop over the curve points:
for group in self.bezier[1:]:
path.cubicTo(*[point.center for point in group])
# If there is an ending point, draw a line to it
if self.end_point:
path.lineTo(self.end_connection.center)
end_point = path.currentPosition()
arrowhead = self.angle_arrow(path)
path.lineTo(arrowhead[0])
path.moveTo(end_point)
path.lineTo(arrowhead[1])
path.moveTo(end_point)
try:
# Add the transition label, if any (none for the START edge)
font = QFont('arial', pointSize=8)
metrics = QFontMetrics(font)
label = self.edge.get('label', '')
lines = label.split('\n')
width = metrics.width(max(lines)) # longest line
height = metrics.height() * len(lines)
# lp is the position of the center of the text
pos = self.mapFromScene(*self.edge['lp'])
if not self.text_label:
self.text_label = QGraphicsTextItem(
self.edge.get('label', ''), parent=self)
self.text_label.setX(pos.x() - width / 2)
self.text_label.setY(pos.y() - height / 2)
self.text_label.setFont(font)
# Make horizontal center alignment, as dot does
self.text_label.setTextWidth(self.text_label.boundingRect().width())
fmt = QTextBlockFormat()
fmt.setAlignment(Qt.AlignHCenter)
cursor = self.text_label.textCursor()
cursor.select(QTextCursor.Document)
cursor.mergeBlockFormat(fmt)
cursor.clearSelection()
self.text_label.setTextCursor(cursor)
self.text_label.show()
except KeyError:
# no label
pass
self.setPath(path)
def set_functions_list(self, functionsList, prefix="", sufix=""):
self.funtionsList = functionsList
self.funtionsListItems = []
self.maxHeight = 0
tempHeight = 0
for element in functionsList:
tempElement = QGraphicsTextItem(self)
tempElement.setPlainText(prefix + element + sufix)
tempElement.setPos(0, tempHeight)
tempHeight += tempElement.document().size().height()
if self.maxWidth < tempElement.document().size().width():
self.maxWidth = tempElement.document().size().width()
self.funtionsListItems.append(tempElement)
self.maxHeight = tempHeight
def define(self, cells):
index = 0
cell_sum = 0
for y in range(self.height):
for x in range(self.width):
try:
required_bridges = int(cells[y][x])
new_island = Island(index, x, y, required_bridges)
self.islands.append(new_island)
self.grid[y][x] = new_island
text_item = QGraphicsTextItem(str(required_bridges))
text_item.setFont(self.font)
text_item.setPos(30*x+5, 30*y-2)
self.scene.addItem(text_item)
cell_sum += required_bridges
index += 1
except ValueError:
pass
if cell_sum % 2 == 0:
self.total_required_bridges = int(cell_sum / 2)
print("Found {} islands that require a total of {} bridges".format(index, self.total_required_bridges))
else:
print("The grid is not valid!")
def textkeyPressEvent(self, event):
"""
Must intercept invalid input events. Make changes here
"""
a = event.key()
text = event.text()
if a in [Qt.Key_Space, Qt.Key_Tab]:
return
elif a in [Qt.Key_Return, Qt.Key_Enter]:
self.inputMethodEventHandler(event)
return
# elif unicode(text).isalpha():
elif text.isalpha():
return
else:
return QGraphicsTextItem.keyPressEvent(self._label, event)
def updateIcon(self, id, uav_state, image_num=0):
if uav_state.get_lon() == 0.0:
#haven't received a Pose message yet
return
if id not in self.__plane_icons:
#make the plane's label first
label = QGraphicsTextItem(str(id), self.__plane_layer)
label.setZValue(2)
label.setDefaultTextColor(Qt.red)
self.__plane_layer.addToGroup(label)
label.show()
self.__plane_labels[id] = label
self.__plane_icons[id] = MapGraphicsIcon(id, label,
self.__plane_layer)
self.__plane_icons[id].centerIconAt(uav_state.get_lon(),
-uav_state.get_lat())
self.__plane_icons[id].textureIcon(self.__plane_icon_pixmaps[image_num])
#plane icons need to be drawn on top of map tiles:
self.__plane_icons[id].setZValue(1)
self.__plane_layer.addToGroup(self.__plane_icons[id])
#key 0 = last update time
self.__plane_icons[id].setData(0, 0)
#refresh:
#HACK: don't know why zooming works to refresh. Couldn't
#get scene.invalidate() nor scene.update() to work
self.onZoom(self.__current_detail_layer)
#end if
now = time.time()
#if we don't have new pose data, then we don't update the plane icon
if (self.__plane_icons[id].data(0) is None
or self.__plane_icons[id].data(0) >= uav_state.get_last_pose_update()):
return
#place icon
self.__plane_icons[id].centerIconAt(uav_state.get_lon(), -uav_state.get_lat())
#give correct heading:
quat = uav_state.get_quat()
heading = acs_math.yaw_from_quat(quat[0], quat[1], quat[2], quat[3])
self.__plane_icons[id].setHeading(heading)
#set last update time
self.__plane_icons[id].setData(0, now)
def keyPressEvent(self, event: QKeyEvent):
"""Must intercept invalid input events. Make changes here
"""
a = event.key()
text = event.text()
if a in [Qt.Key_Space, Qt.Key_Tab]:
return
elif a in [Qt.Key_Escape]:
self.updateLabel()
self.focusOut()
return
elif a in [Qt.Key_Return, Qt.Key_Enter]:
self.inputMethodEvent(event)
return
elif text.isalpha():
return
else:
return QGraphicsTextItem.keyPressEvent(self, event)
def wait_for_first_image(self):
if not self.display_real_image:
return
self.reset_zoom()
self.display_real_image = False
self.text_item = QGraphicsTextItem()
self.text_item.setDefaultTextColor(QColor("white"))
self.text_item.setPos(100, 70)
self.text_item.setPlainText("In Trigger Mode. Waiting for first image...")
bg = QPixmap(1280, 720)
bg.fill(QColor("grey"))
self.pix.setPixmap(bg)
self.image_counter += 1
self.scene.addItem(self.text_item)
def __init__(self, scene, widthClkTextArea, heightClkTextArea, borders, updateSecs):
self.masterScene = scene
self.widthClkTextArea = widthClkTextArea
self.heightClkTextArea = heightClkTextArea
self.borders = borders
self.updateSecs = updateSecs
# Background
self.textBkgd = QGraphicsRectItem(0, 0, self.widthClkTextArea, self.heightClkTextArea)
self.textBkgd.setPos(self.borders[3], self.borders[0])
self.textBkgd.setBrush(QColor("light green"))
self.textBkgd.setZValue(10)
scene.addItem(self.textBkgd)
# Text Item
self.textItem = QGraphicsTextItem()
self.textItem.setFont(QFont("Segoe UI", 80))
self.textItem.setDefaultTextColor(QColor("black"))
self.textItem.setPos(QPointF(self.borders[3]+10,self.borders[0]+5))
self.textItem.setHtml("<B>Clock</B>")
self.textItem.setZValue(20)
self.textItem.setTextWidth(self.widthClkTextArea-20)
scene.addItem(self.textItem)
def create_map_points(self):
self.map_points_text_items = []
self.map_points_items = []
for map_point in self.map_data.map_points:
color = QColor().fromRgb(map_point.r, map_point.g, map_point.b)
rect = QGraphicsRectItem(
QRectF(
QPointF(map_point.x, map_point.y),
QSizeF(5 / self.scale_ratio, 5 / self.scale_ratio)
)
)
rect.setPen(QPen(Qt.black, 1 / self.scale_ratio))
rect.setBrush(color)
self.map_points_items.append(rect)
text = QGraphicsTextItem(map_point.text)
text.setDefaultTextColor(color)
text.setPos(map_point.x, map_point.y)
text.setFont(QFont('Times New Roman', 8 / self.scale_ratio, 2))
self.map_points_text_items.append(text)
def __init__(self, pos, size, type_, parent = None, scene = None,
areaBorder = 2, index = 0, textSize = 50):
QGraphicsRectItem.__init__(self, 0, 0, size.width(), size.height(),
parent)
self.setPos(pos)
self.newEvent = IsClicked()
self.newEvent.area = self
#self.setAcceptedMouseButtons(QtCore.Qt.NoButton)
self.setFlags(QGraphicsItem.ItemIsMovable |
QGraphicsItem.ItemIsFocusable |
QGraphicsItem.ItemIsSelectable)
## set index label
self.text = QGraphicsTextItem("%d" % index, self)
self.setTextSize(textSize)
## TODO: How to create constants for the type?
## (such as constants in Qt) (enum?)
self.kind = type_
pen = QPen(self.color, areaBorder, Qt.SolidLine,
Qt.RoundCap, Qt.RoundJoin)
self.setPen(pen)
def buildDiagram(self):
"""
Public method to build the class shapes of the package diagram.
The algorithm is borrowed from Boa Constructor.
"""
self.allClasses = {}
initlist = glob.glob(os.path.join(self.package, '__init__.*'))
if len(initlist) == 0:
ct = QGraphicsTextItem(None)
self.scene.addItem(ct)
ct.setHtml(
self.tr("The directory <b>'{0}'</b> is not a package.")
.format(self.package))
return
modules = self.__buildModulesDict()
if not modules:
ct = QGraphicsTextItem(None)
self.scene.addItem(ct)
ct.setHtml(
self.tr(
"The package <b>'{0}'</b> does not contain any modules.")
.format(self.package))
return
# step 1: build all classes found in the modules
classesFound = False
for modName in list(modules.keys()):
module = modules[modName]
for cls in list(module.classes.keys()):
classesFound = True
self.__addLocalClass(cls, module.classes[cls], 0, 0)
if not classesFound:
ct = QGraphicsTextItem(None)
self.scene.addItem(ct)
ct.setHtml(
self.tr(
"The package <b>'{0}'</b> does not contain any classes.")
.format(self.package))
return
# step 2: build the class hierarchies
routes = []
nodes = []
for modName in list(modules.keys()):
module = modules[modName]
todo = [module.createHierarchy()]
while todo:
hierarchy = todo[0]
for className in list(hierarchy.keys()):
cw = self.__getCurrentShape(className)
if not cw and className.find('.') >= 0:
cw = self.__getCurrentShape(className.split('.')[-1])
if cw:
self.allClasses[className] = cw
if cw and cw.noAttrs != self.noAttrs:
cw = None
if cw and not (cw.external and
(className in module.classes or
className in module.modules)
):
if className not in nodes:
nodes.append(className)
else:
if className in module.classes:
# this is a local class (defined in this module)
self.__addLocalClass(
className, module.classes[className],
0, 0)
elif className in module.modules:
# this is a local module (defined in this module)
self.__addLocalClass(
className, module.modules[className],
0, 0, True)
else:
self.__addExternalClass(className, 0, 0)
nodes.append(className)
if hierarchy.get(className):
todo.append(hierarchy.get(className))
children = list(hierarchy.get(className).keys())
for child in children:
if (className, child) not in routes:
routes.append((className, child))
del todo[0]
# step 3: build the subpackages
subpackages = self.__buildSubpackagesDict()
for subpackage in sorted(subpackages.keys()):
self.__addPackage(subpackage, subpackages[subpackage], 0, 0)
nodes.append(subpackage)
self.__arrangeClasses(nodes, routes[:])
self.__createAssociations(routes)
self.umlView.autoAdjustSceneSize(limit=True)
class Edge(Connection):
''' B-spline/Bezier connection shape '''
def __init__(self, edge, graph):
''' Set generic parameters from Connection class '''
self.text_label = None
super(Edge, self).__init__(edge['source'], edge['target'])
self.edge = edge
self.graph = graph
# Set connection points as not visible, by default
self.bezier_visible = False
# Initialize control point coordinates
self.bezier = [self.mapFromScene(*self.edge['spline'][0])]
# Bezier control points (groups of three points):
assert(len(self.edge['spline']) % 3 == 1)
for i in xrange(1, len(self.edge['spline']), 3):
self.bezier.append([Controlpoint(
self.mapFromScene(*self.edge['spline'][i + j]), self)
for j in range(3)])
# Create connection points at start and end of the edge
self.source_connection = Connectionpoint(
self.start_point or self.bezier[0], self, self.parent)
self.parent.movable_points.append(self.source_connection)
self.end_connection = Connectionpoint(
self.end_point or self.bezier[-1], self, self.child)
self.child.movable_points.append(self.end_connection)
self.reshape()
@property
def start_point(self):
''' Compute connection origin - redefine in subclasses '''
# Start point is optional - graphviz decision
return self.mapFromScene(*self.edge['start']) \
if self.edge.get('start') else None
@property
def end_point(self):
''' Compute connection end point - redefine in subclasses '''
return self.mapFromScene(*self.edge['end']) \
if self.edge.get('end') else None
def bezier_set_visible(self, visible=True):
''' Display or hide the edge control points '''
self.bezier_visible = visible
for group in self.bezier[1:]:
for ctrl_point in group:
if visible:
ctrl_point.show()
else:
ctrl_point.hide()
if visible:
self.end_connection.show()
self.source_connection.show()
else:
self.end_connection.hide()
self.source_connection.hide()
self.update()
def mousePressEvent(self, event):
''' On a mouse click, display the control points '''
self.bezier_set_visible(True)
# pylint: disable=R0914
def reshape(self):
''' Update the shape of the edge (redefined function) '''
path = QPainterPath()
# If there is a starting point, draw a line to the first curve point
if self.start_point:
path.moveTo(self.source_connection.center)
path.lineTo(self.bezier[0])
else:
path.moveTo(self.source_connection.center)
# Loop over the curve points:
for group in self.bezier[1:]:
path.cubicTo(*[point.center for point in group])
# If there is an ending point, draw a line to it
if self.end_point:
path.lineTo(self.end_connection.center)
end_point = path.currentPosition()
arrowhead = self.angle_arrow(path)
path.lineTo(arrowhead[0])
path.moveTo(end_point)
path.lineTo(arrowhead[1])
path.moveTo(end_point)
try:
# Add the transition label, if any (none for the START edge)
font = QFont('arial', pointSize=8)
metrics = QFontMetrics(font)
label = self.edge.get('label', '')
lines = label.split('\n')
width = metrics.width(max(lines)) # longest line
height = metrics.height() * len(lines)
# lp is the position of the center of the text
pos = self.mapFromScene(*self.edge['lp'])
if not self.text_label:
self.text_label = QGraphicsTextItem(
self.edge.get('label', ''), parent=self)
self.text_label.setX(pos.x() - width / 2)
self.text_label.setY(pos.y() - height / 2)
self.text_label.setFont(font)
# Make horizontal center alignment, as dot does
self.text_label.setTextWidth(self.text_label.boundingRect().width())
fmt = QTextBlockFormat()
fmt.setAlignment(Qt.AlignHCenter)
cursor = self.text_label.textCursor()
cursor.select(QTextCursor.Document)
cursor.mergeBlockFormat(fmt)
cursor.clearSelection()
self.text_label.setTextCursor(cursor)
self.text_label.show()
except KeyError:
# no label
pass
self.setPath(path)
def __str__(self):
''' user-friendly information about the edge coordinates '''
return('Edge between ' + self.edge['source'].name + ' and ' +
self.edge['target'].name + str(self.edge['spline'][0]))
def paint(self, painter, option, widget):
''' Apply anti-aliasing to Edge Connections '''
painter.setRenderHint(QPainter.Antialiasing, True)
super(Edge, self).paint(painter, option, widget)
# Draw lines between connection points, if visible
if self.bezier_visible:
painter.setPen(
QPen(Qt.lightGray, 0, Qt.SolidLine))
painter.setBrush(Qt.NoBrush)
points_flat = [point.center
for sub1 in self.bezier[1:] for point in sub1]
painter.drawPolyline([self.source_connection.center]
+ points_flat + [self.end_connection.center])
def focusOutEvent(self, event):
self.inputMethodEvent(event)
QGraphicsTextItem.focusOutEvent(self, event)
def event(self, event):
if event.type() == QEvent.KeyPress and event.key() == Qt.Key_Tab:
# print("tab pressed")
return True
return QGraphicsTextItem.event(self, event)
def __init__(self, label=""):
# Parent constructor(s)
QGraphicsTextItem.__init__(self, label)
class SimpleBlackbox(PyreeNode):
"""Blackbox node template with inputs on the left and outputs on the right"""
# Here we define some information about the node
author = "DrLuke" # Author of this node (only used for namespacing, never visible to users)
modulename = "simplebb" # Internal name of the module, make this something distinguishable
name = "Simple Blackbox" # Human-readable name
placeable = False # Whether or not this node should be placeable from within the editor
Category = ["Builtin"] # Nested categories this Node should be sorted in
# Description, similar to python docstrings (Brief summary on first line followed by a long description)
description = """This node is the base class for all nodes.
It should never be placeable in the editor. However if you DO see this in the editor, something went wrong!"""
# Class implementing this node.
implementation = BaseImplementation
def defineIO(self):
raise NotImplementedError("This method must be implemented in derived class")
def addInput(self, type, name, displayname):
self.inputs.append([type, name, displayname])
def addOutput(self, type, name, displayname):
self.outputs.append([type, name, displayname])
def addIO(self):
"""Add/Update IO"""
self.inputs = []
self.outputs = []
self.defineIO()
indexOffset = 2
verticalIoSpacing = 20 # Vertical Space between 2 IOs
verticalIoStartOffset = (verticalIoSpacing * (max(len(self.inputs), len(self.outputs)) + indexOffset)) / 2
horizontalIoDistance = 10
maxInputWidth = 0
maxOutputWidth = 0
nodeTitleWidth = self.nodeTitle.boundingRect().width()
titlePadding = 10
horizontalTextToIoDistance = 5
for ioDefinition in self.inputs:
if ioDefinition[0] is not None:
if ioDefinition[0] is execType:
ioDefinition.append(ExecInput(ioDefinition[0], parent=self, name=ioDefinition[1], displaystr=ioDefinition[2]))
else:
ioDefinition.append(NodeInput(ioDefinition[0], parent=self, name=ioDefinition[1], displaystr=ioDefinition[2]))
ioDefinition.append(QGraphicsTextItem(ioDefinition[2], ioDefinition[3]))
maxInputWidth = max(maxInputWidth, ioDefinition[4].boundingRect().width())
ioDefinition[4].setPos(QPointF(horizontalTextToIoDistance, - ioDefinition[3].boundingRect().height() / 2 - ioDefinition[4].boundingRect().height() / 4))
self.IO[ioDefinition[1]] = ioDefinition[3]
for ioDefinition in self.outputs:
if ioDefinition[0] is not None:
if ioDefinition[0] is execType:
ioDefinition.append(ExecOutput(ioDefinition[0], parent=self, name=ioDefinition[1], displaystr=ioDefinition[2]))
else:
ioDefinition.append(NodeOutput(ioDefinition[0], parent=self, name=ioDefinition[1], displaystr=ioDefinition[2]))
ioDefinition.append(QGraphicsTextItem(ioDefinition[2], ioDefinition[3]))
maxOutputWidth = max(maxInputWidth, ioDefinition[4].boundingRect().width())
ioDefinition[4].setPos(QPointF(- horizontalTextToIoDistance - ioDefinition[4].boundingRect().width(), - ioDefinition[3].boundingRect().height() / 2 - ioDefinition[4].boundingRect().height() / 4))
self.IO[ioDefinition[1]] = ioDefinition[3]
width = max(maxInputWidth + maxOutputWidth + horizontalIoDistance, nodeTitleWidth + titlePadding)
height = verticalIoSpacing * (max(len(self.inputs), len(self.outputs)) + indexOffset - 1)
self.mainRect.setRect(QRectF(-width/2, -height/2, width, height))
for ioDefinition in self.inputs:
if ioDefinition[0] is not None:
ioDefinition[3].setPos(QPointF(-width/2, - verticalIoStartOffset + (self.inputs.index(ioDefinition) + indexOffset) * verticalIoSpacing))
for ioDefinition in self.outputs:
if ioDefinition[0] is not None:
ioDefinition[3].setPos(QPointF(width / 2, - verticalIoStartOffset + (self.outputs.index(ioDefinition) + indexOffset) * verticalIoSpacing))
self.nodeTitle.setPos(QPointF(- nodeTitleWidth / 2, -height / 2))
def boundingRect(self):
return self.mainRect.rect()
def addGraphicsItems(self):
self.mainRect = QGraphicsRectItem(QRectF(-15, -15, 30, 30), self)
self.nodeTitle = QGraphicsTextItem(type(self).name, self)
titleFont = QFont()
titleFont.setBold(True)
self.nodeTitle.setFont(titleFont)
self.selectedChanged(self.isSelected())
def selectedChanged(self, state):
if state:
self.mainRect.setPen(QPen(Qt.red))
else:
self.mainRect.setPen(QPen(Qt.black))
def serialize(self):
return None
def deserialize(self, data):
pass
