def __init__(self, toolbox, x, y, w, h, name):
"""Importer icon for the Design View.
Args:
toolbox (ToolBoxUI): QMainWindow instance
x (float): Icon x coordinate
y (float): Icon y coordinate
w (float): Width of master icon
h (float): Height of master icon
name (str): Item name
"""
super().__init__(
toolbox,
x,
y,
w,
h,
name,
":/icons/project_item_icons/database-import.svg",
icon_color=QColor("#990000"),
background_color=QColor("#ffcccc"),
)
src_item = QGraphicsTextItem("\uf15c")
src_item.setDefaultTextColor("#0000ff")
dst_item = QGraphicsTextItem("\uf1c0")
dst_item.setDefaultTextColor("#cc33ff")
self.animation = ImportExportAnimation(self, src_item, dst_item)
self.start_animation = self.animation.start
self.stop_animation = self.animation.stop
class StartScene(QGraphicsScene):
def __init__(self, mask_scene, stage=1):
super().__init__()
self.mask_scene = mask_scene
self.y_list = [300, 400]
self.selected = 0
self.stage = stage
self.one_play_text_item = QGraphicsTextItem()
self.two_plays_text_item = QGraphicsTextItem()
self.indicator_item = None
self.start = False
self.init()
def init(self):
brush = QBrush()
brush.setColor(Qt.black)
brush.setStyle(Qt.SolidPattern)
self.setBackgroundBrush(brush)
font = QFont()
font.setPointSize(20)
font.setBold(True)
self.one_play_text_item.setPlainText('One Player')
self.two_plays_text_item.setPlainText('Two Players')
self.one_play_text_item.setDefaultTextColor(Qt.white)
self.two_plays_text_item.setDefaultTextColor(Qt.white)
self.one_play_text_item.setFont(font)
self.two_plays_text_item.setFont(font)
self.one_play_text_item.setX(300)
self.two_plays_text_item.setX(300)
self.one_play_text_item.setY(self.y_list[0])
self.two_plays_text_item.setY(self.y_list[1])
self.addItem(self.one_play_text_item)
self.addItem(self.two_plays_text_item)
png = QPixmap()
png.load('../images/%s' % TankType.PLAYER_ONE.pic)
png = png.scaled(25, 25)
self.indicator_item = QGraphicsPixmapItem(png)
self.indicator_item.setRotation(90)
self.indicator_item.setX(260)
self.indicator_item.setY(self.y_list[self.selected] + 8)
self.addItem(self.indicator_item)
def keyPressEvent(self, event: QKeyEvent):
if event.key() == Qt.Key_Up:
self.selected -= 1
if self.selected < 0:
self.selected = len(self.y_list) - 1
if event.key() == Qt.Key_Down:
self.selected += 1
if self.selected >= len(self.y_list):
self.selected = 0
self.indicator_item.setY(self.y_list[self.selected] + 8)
if event.key() == Qt.Key_Space:
if not self.start:
self.start = True
self.mask_scene.start_animation(self.selected)
def overlay_text(
self,
message: str,
color: int,
size: int,
x: int,
y: int,
timeout: int,
font_name: str,
centered: bool,
shadow: bool,
):
gfx = QGraphicsTextItem(message)
gfx.setDefaultTextColor(decode_color(color))
font = QFont(font_name, min(50, size))
font.setStyleHint(QFont.SansSerif)
gfx.setFont(font)
if shadow:
effect = QGraphicsDropShadowEffect(gfx)
effect.setBlurRadius(0)
effect.setColor(Qt.GlobalColor.black)
effect.setOffset(1, 1)
gfx.setGraphicsEffect(effect)
if centered:
# The provided x, y is at the center of the text
bound = gfx.boundingRect()
gfx.setPos(x - (bound.width() / 2), y - (bound.height() / 2))
else:
gfx.setPos(x, y)
self._finalize_gfx(gfx, timeout)
class FilterIcon(QGraphicsEllipseItem):
"""An icon to show that a Link has filters."""
def __init__(self, x, y, w, h, parent):
super().__init__(x, y, w, h, parent)
self._parent = parent
color = QColor("slateblue")
self.setBrush(qApp.palette().window()) # pylint: disable=undefined-variable
self._text_item = QGraphicsTextItem(self)
font = QFont('Font Awesome 5 Free Solid')
self._text_item.setFont(font)
self._text_item.setPos(0, 0)
self._text_item.setPlainText("\uf0b0")
self._text_item.setDefaultTextColor(color)
self._text_item.setPos(self.sceneBoundingRect().center() -
self._text_item.sceneBoundingRect().center())
self.setFlag(QGraphicsItem.ItemIsSelectable, enabled=True)
self.setCursor(Qt.PointingHandCursor)
def itemChange(self, change, value):
"""Selects the parent item instead of this."""
if change == QGraphicsItem.GraphicsItemChange.ItemSelectedChange and value == 1:
if not self._parent.isSelected():
self._parent.setSelected(True)
return not value
return super().itemChange(change, value)
def draw_message_text(item: QGraphicsTextItem, font: QFont, text: str, x: int,
y: int, max_width: int):
item.setDefaultTextColor(QColor.fromRgba(0xFF440400))
item.setFont(font)
item.setPos(x, y)
# Calculate how many character to trim *without* making copies of the string.
font_metrics = QFontMetrics(font)
cur_width = font_metrics.width(text)
cur_end = len(text) - 1
while cur_width > max_width:
cur_width -= font_metrics.charWidth(text, cur_end)
cur_end -= 1
item.setPlainText(text[:cur_end + 1])
class FilterIcon(QGraphicsEllipseItem):
"""An icon to show that a Link has filters."""
def __init__(self, x, y, w, h, parent):
super().__init__(x, y, w, h, parent)
self._parent = parent
color = QColor("slateblue")
self.setBrush(qApp.palette().window()) # pylint: disable=undefined-variable
self._text_item = QGraphicsTextItem(self)
font = QFont('Font Awesome 5 Free Solid')
self._text_item.setFont(font)
self._text_item.setPos(0, 0)
self._text_item.setPlainText("\uf0b0")
self._text_item.setDefaultTextColor(color)
self._text_item.setPos(self.sceneBoundingRect().center() - self._text_item.sceneBoundingRect().center())
self.setFlag(QGraphicsItem.ItemIsSelectable, enabled=False)
class _LinkIcon(QGraphicsEllipseItem):
"""An icon to show over a Link."""
def __init__(self, x, y, w, h, parent):
super().__init__(x, y, w, h, parent)
self._parent = parent
color = QColor("slateblue")
self.setBrush(qApp.palette().window()) # pylint: disable=undefined-variable
self._text_item = QGraphicsTextItem(self)
font = QFont('Font Awesome 5 Free Solid')
self._text_item.setFont(font)
self._text_item.setDefaultTextColor(color)
self._svg_item = QGraphicsSvgItem(self)
self._datapkg_renderer = QSvgRenderer()
self._datapkg_renderer.load(":/icons/datapkg.svg")
self.setFlag(QGraphicsItem.ItemIsSelectable, enabled=False)
self._block_updates = False
def update_icon(self):
"""Sets the icon (filter, datapkg, or none), depending on Connection state."""
connection = self._parent.connection
if connection.use_datapackage:
self.setVisible(True)
self._svg_item.setVisible(True)
self._svg_item.setSharedRenderer(self._datapkg_renderer)
scale = 0.8 * self.rect().width(
) / self._datapkg_renderer.defaultSize().width()
self._svg_item.setScale(scale)
self._svg_item.setPos(0, 0)
self._svg_item.setPos(self.sceneBoundingRect().center() -
self._svg_item.sceneBoundingRect().center())
self._text_item.setVisible(False)
return
if connection.has_filters():
self.setVisible(True)
self._text_item.setVisible(True)
self._text_item.setPlainText("\uf0b0")
self._svg_item.setPos(0, 0)
self._text_item.setPos(
self.sceneBoundingRect().center() -
self._text_item.sceneBoundingRect().center())
self._svg_item.setVisible(False)
return
self.setVisible(False)
self._text_item.setVisible(False)
self._svg_item.setVisible(False)
class NodeItem(AbstractNodeItem):
"""
Base Node item.
Args:
name (str): name displayed on the node.
parent (QtWidgets.QGraphicsItem): parent item.
"""
def __init__(self, name='node', parent=None):
super(NodeItem, self).__init__(name, parent)
pixmap = QtGui.QPixmap(ICON_NODE_BASE)
if pixmap.size().height() > NODE_ICON_SIZE:
pixmap = pixmap.scaledToHeight(NODE_ICON_SIZE,
QtCore.Qt.SmoothTransformation)
self._properties['icon'] = ICON_NODE_BASE
self._icon_item = QGraphicsPixmapItem(pixmap, self)
self._icon_item.setTransformationMode(QtCore.Qt.SmoothTransformation)
self._text_item = QGraphicsTextItem(self.name, self)
self._x_item = XDisabledItem(self, 'DISABLED')
self._input_items = {}
self._output_items = {}
self._widgets = {}
def paint(self, painter, option, widget):
"""
Draws the node base not the ports.
Args:
painter (QtGui.QPainter): painter used for drawing the item.
option (QtGui.QStyleOptionGraphicsItem):
used to describe the parameters needed to draw.
widget (QtWidgets.QWidget): not used.
"""
painter.save()
bg_border = 1.0
rect = QtCore.QRectF(0.5 - (bg_border / 2), 0.5 - (bg_border / 2),
self._width + bg_border, self._height + bg_border)
radius = 2
border_color = QtGui.QColor(*self.border_color)
path = QtGui.QPainterPath()
path.addRoundedRect(rect, radius, radius)
painter.setPen(QtGui.QPen(border_color.darker(200), 1.5))
painter.drawPath(path)
rect = self.boundingRect()
bg_color = QtGui.QColor(*self.color)
painter.setBrush(bg_color)
painter.setPen(QtCore.Qt.NoPen)
painter.drawRoundRect(rect, radius, radius)
if self.selected and NODE_SEL_COLOR:
painter.setBrush(QtGui.QColor(*NODE_SEL_COLOR))
painter.drawRoundRect(rect, radius, radius)
label_rect = QtCore.QRectF(rect.left() + (radius / 2),
rect.top() + (radius / 2),
self._width - (radius / 1.25), 28)
path = QtGui.QPainterPath()
path.addRoundedRect(label_rect, radius / 1.5, radius / 1.5)
painter.setBrush(QtGui.QColor(0, 0, 0, 50))
painter.fillPath(path, painter.brush())
border_width = 0.8
if self.selected and NODE_SEL_BORDER_COLOR:
border_width = 1.2
border_color = QtGui.QColor(*NODE_SEL_BORDER_COLOR)
border_rect = QtCore.QRectF(rect.left() - (border_width / 2),
rect.top() - (border_width / 2),
rect.width() + border_width,
rect.height() + border_width)
pen = QtGui.QPen(border_color, border_width)
pen.setCosmetic(self.viewer().get_zoom() < 0.0)
path = QtGui.QPainterPath()
path.addRoundedRect(border_rect, radius, radius)
painter.setBrush(QtCore.Qt.NoBrush)
painter.setPen(pen)
painter.drawPath(path)
painter.restore()
def mousePressEvent(self, event):
if event.button() == QtCore.Qt.MouseButton.LeftButton:
start = PortItem().boundingRect().width()
end = self.boundingRect().width() - start
x_pos = event.pos().x()
if not start <= x_pos <= end:
event.ignore()
super(NodeItem, self).mousePressEvent(event)
def mouseReleaseEvent(self, event):
if event.modifiers() == QtCore.Qt.AltModifier:
event.ignore()
return
super(NodeItem, self).mouseReleaseEvent(event)
def itemChange(self, change, value):
if change == self.ItemSelectedChange and self.scene():
self.reset_pipes()
if value:
self.hightlight_pipes()
self.setZValue(Z_VAL_NODE)
if not self.selected:
self.setZValue(Z_VAL_NODE + 1)
return super(NodeItem, self).itemChange(change, value)
def _tooltip_disable(self, state):
tooltip = '<b>{}</b>'.format(self._properties['name'])
if state:
tooltip += ' <font color="red"><b>(DISABLED)</b></font>'
tooltip += '<br/>{}<br/>'.format(self._properties['type'])
self.setToolTip(tooltip)
def _set_base_size(self):
"""
setup initial base size.
"""
self._width = NODE_WIDTH
self._height = NODE_HEIGHT
width, height = self.calc_size()
if width > self._width:
self._width = width
if height > self._height:
self._height = height
def _set_text_color(self, color):
"""
set text color.
Args:
color (tuple): color value in (r, g, b, a).
"""
text_color = QtGui.QColor(*color)
for port, text in self._input_items.items():
text.setDefaultTextColor(text_color)
for port, text in self._output_items.items():
text.setDefaultTextColor(text_color)
self._text_item.setDefaultTextColor(text_color)
def activate_pipes(self):
"""
active pipe color.
"""
ports = self.inputs + self.outputs
for port in ports:
for pipe in port.connected_pipes:
pipe.activate()
def hightlight_pipes(self):
"""
highlight pipe color.
"""
ports = self.inputs + self.outputs
for port in ports:
for pipe in port.connected_pipes:
pipe.highlight()
def reset_pipes(self):
"""
reset the pipe color.
"""
ports = self.inputs + self.outputs
for port in ports:
for pipe in port.connected_pipes:
pipe.reset()
def calc_size(self):
"""
calculate minimum node size.
"""
width = 0.0
if self._widgets:
widget_widths = [
w.boundingRect().width() for w in self._widgets.values()
]
width = max(widget_widths)
if self._text_item.boundingRect().width() > width:
width = self._text_item.boundingRect().width()
port_height = 0.0
if self._input_items:
input_widths = []
for port, text in self._input_items.items():
input_width = port.boundingRect().width() * 2
if text.isVisible():
input_width += text.boundingRect().width()
input_widths.append(input_width)
width += max(input_widths)
port = list(self._input_items.keys())[0]
port_height = port.boundingRect().height() * 2
if self._output_items:
output_widths = []
for port, text in self._output_items.items():
output_width = port.boundingRect().width() * 2
if text.isVisible():
output_width += text.boundingRect().width()
output_widths.append(output_width)
width += max(output_widths)
port = list(self._output_items.keys())[0]
port_height = port.boundingRect().height() * 2
in_count = len([p for p in self.inputs if p.isVisible()])
out_count = len([p for p in self.outputs if p.isVisible()])
height = port_height * (max([in_count, out_count]) + 2)
if self._widgets:
wid_height = sum(
[w.boundingRect().height() for w in self._widgets.values()])
if wid_height > height:
height = wid_height + (wid_height / len(self._widgets))
height += 10
return width, height
def arrange_icon(self):
"""
Arrange node icon to the default top left of the node.
"""
self._icon_item.setPos(2.0, 2.0)
def arrange_label(self):
"""
Arrange node label to the default top center of the node.
"""
text_rect = self._text_item.boundingRect()
text_x = (self._width / 2) - (text_rect.width() / 2)
self._text_item.setPos(text_x, 1.0)
def arrange_widgets(self):
"""
Arrange node widgets to the default center of the node.
"""
if not self._widgets:
return
wid_heights = sum(
[w.boundingRect().height() for w in self._widgets.values()])
pos_y = self._height / 2
pos_y -= wid_heights / 2
for name, widget in self._widgets.items():
rect = widget.boundingRect()
pos_x = (self._width / 2) - (rect.width() / 2)
widget.setPos(pos_x, pos_y)
pos_y += rect.height()
def arrange_ports(self, padding_x=0.0, padding_y=0.0):
"""
Arrange input, output ports in the node layout.
Args:
padding_x (float): horizontal padding.
padding_y: (float): vertical padding.
"""
width = self._width - padding_x
height = self._height - padding_y
# adjust input position
inputs = [p for p in self.inputs if p.isVisible()]
if inputs:
port_width = inputs[0].boundingRect().width()
port_height = inputs[0].boundingRect().height()
chunk = (height / len(inputs))
port_x = (port_width / 2) * -1
port_y = (chunk / 2) - (port_height / 2)
for port in inputs:
port.setPos(port_x + padding_x, port_y + (padding_y / 2))
port_y += chunk
# adjust input text position
for port, text in self._input_items.items():
if not port.isVisible():
continue
txt_height = text.boundingRect().height() - 8.0
txt_x = port.x() + port.boundingRect().width()
txt_y = port.y() - (txt_height / 2)
text.setPos(txt_x + 3.0, txt_y)
# adjust output position
outputs = [p for p in self.outputs if p.isVisible()]
if outputs:
port_width = outputs[0].boundingRect().width()
port_height = outputs[0].boundingRect().height()
chunk = height / len(outputs)
port_x = width - (port_width / 2)
port_y = (chunk / 2) - (port_height / 2)
for port in outputs:
port.setPos(port_x, port_y + (padding_y / 2))
port_y += chunk
# adjust output text position
for port, text in self._output_items.items():
if not port.isVisible():
continue
txt_width = text.boundingRect().width()
txt_height = text.boundingRect().height() - 8.0
txt_x = width - txt_width - (port.boundingRect().width() / 2)
txt_y = port.y() - (txt_height / 2)
text.setPos(txt_x - 1.0, txt_y)
def offset_icon(self, x=0.0, y=0.0):
"""
offset the icon in the node layout.
Args:
x (float): horizontal x offset
y (float): vertical y offset
"""
if self._icon_item:
icon_x = self._icon_item.pos().x() + x
icon_y = self._icon_item.pos().y() + y
self._icon_item.setPos(icon_x, icon_y)
def offset_label(self, x=0.0, y=0.0):
"""
offset the label in the node layout.
Args:
x (float): horizontal x offset
y (float): vertical y offset
"""
icon_x = self._text_item.pos().x() + x
icon_y = self._text_item.pos().y() + y
self._text_item.setPos(icon_x, icon_y)
def offset_widgets(self, x=0.0, y=0.0):
"""
offset the node widgets in the node layout.
Args:
x (float): horizontal x offset
y (float): vertical y offset
"""
for name, widget in self._widgets.items():
pos_x = widget.pos().x()
pos_y = widget.pos().y()
widget.setPos(pos_x + x, pos_y + y)
def offset_ports(self, x=0.0, y=0.0):
"""
offset the ports in the node layout.
Args:
x (float): horizontal x offset
y (float): vertical y offset
"""
for port, text in self._input_items.items():
port_x, port_y = port.pos().x(), port.pos().y()
text_x, text_y = text.pos().x(), text.pos().y()
port.setPos(port_x + x, port_y + y)
text.setPos(text_x + x, text_y + y)
for port, text in self._output_items.items():
port_x, port_y = port.pos().x(), port.pos().y()
text_x, text_y = text.pos().x(), text.pos().y()
port.setPos(port_x + x, port_y + y)
text.setPos(text_x + x, text_y + y)
def post_init(self, viewer=None, pos=None):
"""
Called after node has been added into the scene.
Adjust the node layout and form after the node has been added.
Args:
viewer (NodeGraphQt.widgets.viewer.NodeViewer): not used
pos (tuple): cursor position.
"""
# setup initial base size.
self._set_base_size()
# set text color when node is initialized.
self._set_text_color(self.text_color)
# set the tooltip
self._tooltip_disable(self.disabled)
# --- setup node layout ---
# arrange label text
self.arrange_label()
self.offset_label(0.0, 5.0)
# arrange icon
self.arrange_icon()
self.offset_icon(5.0, 2.0)
# arrange node widgets
self.arrange_widgets()
self.offset_widgets(0.0, 10.0)
# arrange input and output ports.
self.arrange_ports(padding_y=35.0)
self.offset_ports(0.0, 15.0)
# set initial node position.
if pos:
self.xy_pos = pos
@property
def icon(self):
return self._properties['icon']
@icon.setter
def icon(self, path=None):
self._properties['icon'] = path
path = path or ICON_NODE_BASE
pixmap = QtGui.QPixmap(path)
if pixmap.size().height() > NODE_ICON_SIZE:
pixmap = pixmap.scaledToHeight(NODE_ICON_SIZE,
QtCore.Qt.SmoothTransformation)
self._icon_item.setPixmap(pixmap)
if self.scene():
self.post_init()
@AbstractNodeItem.width.setter
def width(self, width=0.0):
w, h = self.calc_size()
width = width if width > w else w
AbstractNodeItem.width.fset(self, width)
@AbstractNodeItem.height.setter
def height(self, height=0.0):
w, h = self.calc_size()
h = 70 if h < 70 else h
height = height if height > h else h
AbstractNodeItem.height.fset(self, height)
@AbstractNodeItem.disabled.setter
def disabled(self, state=False):
AbstractNodeItem.disabled.fset(self, state)
for n, w in self._widgets.items():
w.widget.setDisabled(state)
self._tooltip_disable(state)
self._x_item.setVisible(state)
@AbstractNodeItem.selected.setter
def selected(self, selected=False):
AbstractNodeItem.selected.fset(self, selected)
if selected:
self.hightlight_pipes()
@AbstractNodeItem.name.setter
def name(self, name=''):
AbstractNodeItem.name.fset(self, name)
self._text_item.setPlainText(name)
if self.scene():
self.post_init()
@property
def inputs(self):
"""
Returns:
list[PortItem]: input port graphic items.
"""
return list(self._input_items.keys())
@property
def outputs(self):
"""
Returns:
list[PortItem]: output port graphic items.
"""
return list(self._output_items.keys())
def add_input(self, name='input', multi_port=False, display_name=True):
"""
Args:
name (str): name for the port.
multi_port (bool): allow multiple connections.
display_name (bool): display the port name.
Returns:
PortItem: input item widget
"""
port = PortItem(self)
port.name = name
port.port_type = IN_PORT
port.multi_connection = multi_port
port.display_name = display_name
text = QGraphicsTextItem(port.name, self)
text.font().setPointSize(8)
text.setFont(text.font())
text.setVisible(display_name)
self._input_items[port] = text
if self.scene():
self.post_init()
return port
def add_output(self, name='output', multi_port=False, display_name=True):
"""
Args:
name (str): name for the port.
multi_port (bool): allow multiple connections.
display_name (bool): display the port name.
Returns:
PortItem: output item widget
"""
port = PortItem(self)
port.name = name
port.port_type = OUT_PORT
port.multi_connection = multi_port
port.display_name = display_name
text = QGraphicsTextItem(port.name, self)
text.font().setPointSize(8)
text.setFont(text.font())
text.setVisible(display_name)
self._output_items[port] = text
if self.scene():
self.post_init()
return port
def get_input_text_item(self, port_item):
"""
Args:
port_item (PortItem): port item.
Returns:
QGraphicsTextItem: graphic item used for the port text.
"""
return self._input_items[port_item]
def get_output_text_item(self, port_item):
"""
Args:
port_item (PortItem): port item.
Returns:
QGraphicsTextItem: graphic item used for the port text.
"""
return self._output_items[port_item]
@property
def widgets(self):
return dict(self._widgets)
def add_combo_menu(self, name='', label='', items=None, tooltip=''):
items = items or []
widget = NodeComboBox(self, name, label, items)
widget.setToolTip(tooltip)
self.add_widget(widget)
return widget
def add_text_input(self, name='', label='', text='', tooltip=''):
widget = NodeLineEdit(self, name, label, text)
widget.setToolTip(tooltip)
self.add_widget(widget)
return widget
def add_checkbox(self,
name='',
label='',
text='',
state=False,
tooltip=''):
widget = NodeCheckBox(self, name, label, text, state)
widget.setToolTip(tooltip)
self.add_widget(widget)
return widget
def add_widget(self, widget):
if isinstance(widget, NodeBaseWidget):
self._widgets[widget.name] = widget
else:
raise TypeError('{} is not an instance of a node widget.')
def get_widget(self, name):
widget = self._widgets.get(name)
if widget:
return widget
raise KeyError('node has no widget "{}"'.format(name))
def delete(self):
for port, text in self._input_items.items():
port.delete()
for port, text in self._output_items.items():
port.delete()
super(NodeItem, self).delete()
def from_dict(self, node_dict):
super(NodeItem, self).from_dict(node_dict)
widgets = node_dict.pop('widgets', {})
for name, value in widgets.items():
if self._widgets.get(name):
self._widgets[name].value = value
class MaskScene(QGraphicsScene):
_stage_text = 'STAGE %s'
def __init__(self, main_window, stage=1):
super().__init__()
self.main_window = main_window
self.stage = stage
self.upper_mask = QGraphicsRectItem(0, 0, content_width, 0)
self.lower_mask = QGraphicsRectItem(0, content_height, content_width, 0)
self.stage_text_item = QGraphicsTextItem()
self.mask_height = 0
self.animation_timer_1 = QTimer()
self.animation_timer_2 = QTimer()
self.animation_timer_3 = QTimer()
self.selected = None
self.init()
def init(self):
mask_brush = QBrush()
mask_brush.setColor(Qt.gray)
mask_brush.setStyle(Qt.SolidPattern)
mask_pen = QPen()
mask_pen.setColor(Qt.gray)
self.upper_mask.setBrush(mask_brush)
self.lower_mask.setBrush(mask_brush)
self.upper_mask.setPen(mask_pen)
self.lower_mask.setPen(mask_pen)
self.addItem(self.upper_mask)
self.addItem(self.lower_mask)
font = QFont()
font.setPointSize(20)
font.setBold(True)
self.stage_text_item.setPlainText(self._stage_text % self.stage)
self.stage_text_item.setFont(font)
self.stage_text_item.setDefaultTextColor(Qt.black)
self.stage_text_item.setX(content_width / 2 - int(self.stage_text_item.boundingRect().width() / 2))
self.stage_text_item.setY(content_height / 2 - int(self.stage_text_item.boundingRect().height() / 2))
self.animation_timer_1.setInterval(interval)
self.animation_timer_1.timeout.connect(self.animation_in)
self.animation_timer_2.setSingleShot(True)
self.animation_timer_2.timeout.connect(self.animation_hold)
self.animation_timer_2.setInterval(800)
self.animation_timer_3.setInterval(interval)
self.animation_timer_3.timeout.connect(self.animation_out)
def next_stage(self):
self.stage += 1
self.stage_text_item.setPlainText(self._stage_text % self.stage)
def reset_stage(self):
self.stage = 0
self.stage_text_item.setPlainText(self._stage_text % self.stage)
def animation_in(self):
self.mask_height += 10
finished = False
if self.mask_height > content_height / 2:
self.mask_height = content_height / 2
finished = True
self.upper_mask.setRect(0, 0, content_width, self.mask_height)
self.lower_mask.setRect(0, content_height - self.mask_height, content_width, self.mask_height)
if finished:
self.addItem(self.stage_text_item)
self.animation_timer_1.stop()
self.animation_timer_2.start()
def animation_out(self):
self.mask_height -= 10
finished = False
if self.mask_height < 0:
self.mask_height = 0
finished = True
self.upper_mask.setRect(0, 0, content_width, self.mask_height)
self.lower_mask.setRect(0, content_height - self.mask_height, content_width, self.mask_height)
if finished:
self.animation_timer_3.stop()
self.main_window.start_game(self.selected)
def animation_hold(self):
self.removeItem(self.stage_text_item)
self.animation_timer_3.start()
self.main_window.enter_game_scene()
def start_animation(self, selected: int):
self.animation_timer_1.start()
self.selected = selected
class ExecutionIcon(QGraphicsEllipseItem):
"""An icon to show information about the item's execution."""
_CHECK = "\uf00c"
_CROSS = "\uf00d"
_CLOCK = "\uf017"
def __init__(self, parent):
"""
Args:
parent (ProjectItemIcon): the parent item
"""
super().__init__(parent)
self._parent = parent
self._execution_state = "not started"
self._text_item = QGraphicsTextItem(self)
font = QFont('Font Awesome 5 Free Solid')
self._text_item.setFont(font)
parent_rect = parent.rect()
self.setRect(0, 0, 0.5 * parent_rect.width(),
0.5 * parent_rect.height())
self.setPen(Qt.NoPen)
# pylint: disable=undefined-variable
self.normal_brush = qApp.palette().window()
self.selected_brush = qApp.palette().highlight()
self.setBrush(self.normal_brush)
self.setAcceptHoverEvents(True)
self.setFlag(QGraphicsItem.ItemIsSelectable, enabled=False)
self.hide()
def item_name(self):
return self._parent.name()
def _repaint(self, text, color):
self._text_item.prepareGeometryChange()
self._text_item.setPos(0, 0)
self._text_item.setPlainText(text)
self._text_item.setDefaultTextColor(color)
size = self._text_item.boundingRect().size()
dim_max = max(size.width(), size.height())
rect_w = self.rect().width()
self._text_item.setScale(rect_w / dim_max)
self._text_item.setPos(self.sceneBoundingRect().center() -
self._text_item.sceneBoundingRect().center())
self.show()
def mark_execution_wating(self):
self._execution_state = "waiting for dependencies"
self._repaint(self._CLOCK, QColor("orange"))
def mark_execution_started(self):
self._execution_state = "in progress"
self._repaint(self._CHECK, QColor("orange"))
def mark_execution_finished(self, success, skipped):
if success:
self._execution_state = "skipped" if skipped else "completed"
colorname = "orange" if skipped else "green"
self._repaint(self._CHECK, QColor(colorname))
else:
self._execution_state = "failed"
self._repaint(self._CROSS, QColor("red"))
def hoverEnterEvent(self, event):
tip = f"<p><b>Execution {self._execution_state}</b>. Select this item to see Console and Log messages.</p>"
QToolTip.showText(event.screenPos(), tip)
def hoverLeaveEvent(self, event):
QToolTip.hideText()
class ScaleLine:
def __init__(self,
parent,
color,
text_color,
text_start="",
margins=(0, 0, 0, 0),
dp=1,
is_upload=False):
self._parent = parent
self._color = color
self._text_color = text_color
self._text_start = text_start
self._left, self._top, self._right, self._bottom = margins
self._dp = dp
self._is_upload = is_upload
self._line = QGraphicsLineItem(self._parent)
self._line.setZValue(12)
pen = QPen(self._color)
pen.setWidth(1)
pen.setStyle(Qt.DashLine)
self._line.setPen(pen)
if not self._is_upload:
self._text_item = QGraphicsTextItem(self._parent)
self._text_item.setZValue(11)
self._text_item.setDefaultTextColor(self._text_color)
font = self._text_item.font()
font_size = 10 * self._dp
if font_size > 0:
self._text_item.setFont(QFont(font.family(), font_size))
def set_line(self, max_value=0, resize=False):
height = self._parent.size().height() + self._top + self._bottom
shift = int(height - height / 1.1)
y = -self._top + shift
if not self._is_upload:
value = 0
max_value = int(max_value / 1.1)
megabyte = 1024 * 1024
if max_value > megabyte:
value = "{} MB".format(round(max_value / megabyte, 1))
elif max_value > 1024:
max_value //= 1024
if max_value >= 10:
max_value = max_value // 10 * 10
value = "{} KB".format(max_value)
elif max_value > 0:
if max_value >= 10:
max_value = max_value // 10 * 10
value = "{} B".format(max_value)
scale_text = self._text_start if not value \
else "{}{}/s".format(self._text_start, value)
font_height = QFontMetrics(self._text_item.font())\
.boundingRect(scale_text).height()
x = 10
self._text_item.setPos(x, y - font_height - 10)
self._text_item.setPlainText(scale_text)
if not resize:
return
self._line.setLine(QLineF(0, y, self._parent.size().width() + 30, y))
def draw_message(self,
text: str,
name: str,
window_type="standard",
mode=0,
left=True) -> QGraphicsItemGroup:
# Create the message box
talk_window: QPixmap = self.view.talk_windows[window_type][mode]
message_box = self.scene.addPixmap(talk_window)
talk_window_x = _TALK_WINDOW_MODE_0_X if not mode else -3
talk_window_y = _TALK_WINDOW_Y if not mode else _TALK_WINDOW_Y - 5
message_box.setPos(talk_window_x, talk_window_y)
# Create the name plate
name_plate_texture: QPixmap = self.view.talk_windows["name_plate"][
"plate"]
name_plate = self.scene.addPixmap(name_plate_texture)
name_plate_x = _NAME_PLATE_LEFT_X if left else _NAME_PLATE_RIGHT_X
name_plate.setPos(name_plate_x, _NAME_PLATE_Y)
# Create the name plate text
name_plate_text = QGraphicsTextItem()
name_plate_text.setPlainText(name)
name_plate_text.setDefaultTextColor(QColor.fromRgba(0xFFFFFFB3))
name_plate_text.setFont(self.view.name_plate_font)
name_plate_text.setTextWidth(name_plate_texture.width())
name_plate_text.setPos(name_plate_x, _NAME_PLATE_Y)
# Center the name plate text
block_format = QTextBlockFormat()
block_format.setAlignment(QtGui.Qt.AlignCenter)
cursor = name_plate_text.textCursor()
cursor.select(QTextCursor.Document)
cursor.mergeBlockFormat(block_format)
cursor.clearSelection()
name_plate_text.setTextCursor(cursor)
self.scene.addItem(name_plate_text)
# Create the message box text. Draw two lines if required.
# Truncate lines with width > 312
split_text = text.split("\n")
message_box_text = QGraphicsTextItem()
message_box_text_2 = QGraphicsTextItem()
if split_text and split_text[0]:
text_utils.draw_message_text(message_box_text,
self.view.name_plate_font,
split_text[0],
_TALK_WINDOW_MODE_0_X + 20,
_TALK_WINDOW_Y + 5, 312)
if len(split_text) > 1 and split_text[1]:
text_utils.draw_message_text(message_box_text_2,
self.view.name_plate_font,
split_text[1],
_TALK_WINDOW_MODE_0_X + 20,
_TALK_WINDOW_Y + 21, 312)
group = self.scene.createItemGroup([
message_box, message_box_text, message_box_text_2, name_plate,
name_plate_text
])
group.setZValue(2.0)
return group
class GraphicsPortPainter:
"""The GraphicsPortPainter class provides a set of functions and configurations for
painting a GraphicsPort object.
"""
class DrawingState(Enum):
Normal = 0
Target = 1
class PortNamePosition(Enum):
Left = 0
Right = 1
drawing_state = DrawingState.Normal
target_port_type = None
def __init__(self, graphics_port: "GraphicsPort",
port_name_position: "PortNamePosition"):
self.__graphics_port = graphics_port
self.__port_name = QGraphicsTextItem(parent=graphics_port)
self.__port_name.setPlainText(graphics_port._port.name)
self.__port_name.setDefaultTextColor("#FFFFFF")
self.__port_name.setFlag(QGraphicsItem.ItemStacksBehindParent)
self.port_name_position = port_name_position
# Colors/Pens/Brushes
self.__color = TypeColor.get_color_for(graphics_port._port.port_type)
self.__outline_pen = QPen(self.__color.darker())
self.__outline_pen.setWidthF(2)
self.__background_brush = QBrush(self.__color)
self.__dashed_outline_pen = QPen(self.__color)
self.__dashed_outline_pen.setStyle(Qt.DashLine)
self.__dashed_outline_pen.setWidth(2)
@property
def port_name_position(self) -> "PortNamePosition":
return self.__port_name_position
@port_name_position.setter
def port_name_position(self, position: "PortNamePosition"):
if position == self.PortNamePosition.Left:
self.__port_name.setPos(
-self.__port_name.boundingRect().width() - 3, 1)
elif position == self.PortNamePosition.Right:
self.__port_name.setPos(3, 1)
self.__port_name_position = position
@property
def color(self):
return self.__color
def paint_area(self):
return QRectF(
-self.__graphics_port.radius,
-self.__graphics_port.radius,
2 * self.__graphics_port.radius,
2 * self.__graphics_port.radius,
)
def paint(
self,
painter: "QPainter",
option: "QStyleOptionGraphicsItem",
widget: "QWidget" = None,
):
if (GraphicsPortPainter.drawing_state
== GraphicsPortPainter.DrawingState.Target
and self.__graphics_port.port_type
== GraphicsPortPainter.target_port_type):
painter.setPen(self.__dashed_outline_pen)
painter.setBrush(Qt.NoBrush)
painter.drawEllipse(self.__graphics_port.boundingRect())
painter.setPen(self.__outline_pen)
painter.setBrush(self.__background_brush)
painter.drawEllipse(self.paint_area())
class AbstractNode(AbstractGeneralGraphicsItemClass):
__metaclass__ = AbstractGeneralGraphicsItem_Meta
def __init__(self, graphWidget, state):
super(AbstractNode, self).__init__()
self.graph = weakref.ref(graphWidget)
self.isAcceptable = state.isAcceptable
self.isCurrent = state.isCurrent
self.newPos = QPointF()
self.setFlag(QGraphicsItem.ItemIsMovable)
self.setFlag(QGraphicsItem.ItemIsSelectable)
self.setFlag(QGraphicsItem.ItemSendsGeometryChanges)
self.setCacheMode(self.DeviceCoordinateCache)
self.setZValue(-1)
self.setAcceptHoverEvents(True)
self._edges = []
self.currentFill = self.fillQColor
self.border = QGraphicsEllipseItem(-self.radius, -self.radius,
self.radius * 2, self.radius * 2)
self.finalNodeBorder = QGraphicsEllipseItem(-self.radius + 5,
-self.radius + 5,
self.radius * 2 - 10,
self.radius * 2 - 10)
self.finalNodeBorder.mapToParent(self.border.pos())
if self.isAcceptable == False:
pen = self.finalNodeBorder.pen()
pen.setColor(QColor(25, 255, 5))
self.finalNodeBorder.update()
if self.isCurrent == True:
self.resolveFillColor()
self.labelBox = QGraphicsTextItem(self)
self.labelBox.setPos(-self.radius / 2, -self.radius / 2)
self.labelBox.setDefaultTextColor(QColor(0, 0, 0))
@property
@abstractmethod
def borderQColor(self):
pass
@property
@abstractmethod
def fillQColor(self):
pass
@property
@abstractmethod
def currentStateFillQColor(self):
pass
@property
@abstractmethod
def radius(self):
pass
@abstractmethod
def setLabel(self, value):
pass
def toggleCurrentState(self):
self.isCurrent = not self.isCurrent
self.resolveFillColor()
def resolveFillColor(self):
brush = QBrush()
if self.isCurrent == True:
brush.setColor(self.currentStateFillQColor)
brush.setStyle(Qt.SolidPattern)
self.currentFill = self.currentStateFillQColor
else:
brush.setColor(self.fillQColor)
brush.setStyle(Qt.SolidPattern)
self.currentFill = self.fillQColor
self.border.setBrush(brush)
self.update()
def toggleFinalNodeBorder(self):
self.isAcceptable = not self.isAcceptable
self.resolveFinalNodeBorder()
def resolveFinalNodeBorder(self):
pen = QPen()
if self.isAcceptable == True:
pen.setColor(self.borderQColor)
pen.setWidth(2)
else:
pen.setColor(self.currentFill)
pen.setWidth(1)
self.finalNodeBorder.setPen(pen)
self.update()
def addEdge(self, edge):
self._edges.append(weakref.ref(edge))
edge.adjust()
def getEdges(self):
return self._edges
def getEdgesForInput(self, input):
edges = []
for edge in self._edges:
if edge.onInput == input:
edges.append(edge)
return edges
def getEdgesFromSelf(self, input):
edges = []
for edge in self._edges:
if edge.onInput == input and edge.fromNode is self:
edges.append(edge)
return edges
def getEdgeToNode(self, toNode):
toReturn = None
for edge in self._edges:
if edge.toNode() is toNode:
toReturn = edge
return toReturn
def boundingRect(self):
adjust = 2.0
return QRectF(-self.radius - adjust, -self.radius - adjust,
(self.radius + adjust) * 2, (self.radius + adjust) * 2)
def shape(self):
path = QtGui.QPainterPath()
path.addEllipse(-self.radius, -self.radius, self.radius * 2,
self.radius * 2)
return path
def paint(self, painter, option, widget):
pen = QPen()
pen.setWidth(2)
pen.setColor(self.borderQColor)
brush = QBrush()
self.border.setPen(pen)
self.border.setBrush(brush)
self.resolveFillColor()
self.resolveFinalNodeBorder()
self.border.paint(painter, option, widget)
self.finalNodeBorder.paint(painter, option, widget)
self.labelBox.setTextWidth(35)
self.labelBox.setDefaultTextColor(QColor(0, 0, 0))
def itemChange(self, change, value):
if change == QGraphicsItem.ItemPositionChange:
for edge in self._edges:
edge().adjust()
return QGraphicsItem.itemChange(self, change, value)
def mousePressEvent(self, event):
self.update()
QGraphicsItem.mousePressEvent(self, event)
def mouseReleaseEvent(self, event):
QGraphicsItem.mouseReleaseEvent(self, event)
self.update()
class GraphicsNodePainter:
def __init__(self, graphics_node: "GraphicsNode"):
self.__graphics_node = graphics_node
# Dimensions
self.padding = 12
self.clickable_margin = 15
self.round_edge_size = 10
self.window_outline_width = 4
# Colors/Pens/Brushes
self.__title_color = Qt.white
self.__outline_selected_color = QColor("#FFA637")
self.__outline_default_color = QColor("#000000")
self.__outline_pen = QPen(self.__outline_default_color)
self.__title_background_brush = QBrush(QColor("#FF313131"))
self.__background_brush = QBrush(QColor("#E3212121"))
self.__window_markers_pen = QPen(self.__outline_default_color)
self.__window_markers_brush = QBrush(self.__outline_default_color)
# Graphics Components
self.__graphics_title = QGraphicsTextItem(parent=graphics_node)
self.__graphics_title.setDefaultTextColor(self.__title_color)
self.__graphics_title.setPlainText(self.__graphics_node.title)
self.__graphics_title.setPos(self.padding, 0)
# Position ProxyWidget
self.repositionWidget()
# position GraphicsPort objects
def position_graphics_ports(x_offset, graphics_ports_dict):
for i, graphics_port in enumerate(graphics_ports_dict.values()):
graphics_port.setPos(
x_offset,
self.title_height() + (graphics_port.radius * 4) * (i + 1))
position_graphics_ports(0, self.__graphics_node.inputs)
position_graphics_ports(self.boundingRect().width(),
self.__graphics_node.outputs)
@property
def outline_selected_color(self) -> "QColor":
return self.__outline_selected_color
@outline_selected_color.setter
def outline_selected_color(self, color: "QColor"):
self.__outline_selected_color = color
@property
def outline_default_color(self) -> "QColor":
return self.__outline_default_color
@outline_default_color.setter
def outline_default_color(self, color: "QColor"):
self.__outline_default_color = color
def boundingRect(self) -> "QRectF":
return self.background_paint_area()
def background_paint_area(self) -> "QRectF":
proxy_rect = self.__graphics_node._proxy_widget.boundingRect()
return proxy_rect.adjusted(
0,
0,
self.padding * 2,
self.title_height() + self.padding * 2,
).normalized()
def repositionWidget(self):
self.__graphics_node._proxy_widget.setPos(
self.padding,
self.title_height() + self.padding)
def recalculateGeometry(self):
for graphics_port in self.__graphics_node.outputs.values():
graphics_port.setX(self.boundingRect().width())
def itemChange(self, change: "QGraphicsItem.GraphicsItemChange",
value: Any) -> Any:
if change == QGraphicsItem.ItemSelectedChange:
self.__outline_pen.setColor(self.__outline_selected_color if value
else self.__outline_default_color)
return value
def title_height(self) -> int:
"""Returns the height of the title graphics item."""
return self.__graphics_title.boundingRect().height()
def paint(self, painter: "QPainter", option: "QStyleOptionGraphicsItem",
widget: "QWidget"):
"""Paints the GraphicsNode item."""
self.__paint_background(painter)
self.__paint_title_background(painter)
self.__paint_outline(painter)
self.__paint_window_markers(painter)
def __paint_background(self, painter: "QPainter"):
"""Paints the background of the node. Plain color, no lines."""
path_background = QPainterPath()
path_background.addRoundedRect(
self.background_paint_area(),
self.round_edge_size,
self.round_edge_size,
)
painter.setPen(Qt.NoPen)
painter.setBrush(self.__background_brush)
painter.drawPath(path_background.simplified())
def __paint_title_background(self, painter: "QPainter"):
"""Paints a little background behind the title text, at the top of the node."""
title_rect = self.__graphics_title.boundingRect()
path_title_background = QPainterPath()
path_title_background.setFillRule(Qt.WindingFill)
path_title_background.addRoundedRect(
0,
0,
self.background_paint_area().width(),
title_rect.height(),
self.round_edge_size,
self.round_edge_size,
)
# (Drawing rects to hide the two botton round edges)
path_title_background.addRect(
0,
title_rect.height() - self.round_edge_size,
self.round_edge_size,
self.round_edge_size,
)
path_title_background.addRect(
self.background_paint_area().width() - self.round_edge_size,
title_rect.height() - self.round_edge_size,
self.round_edge_size,
self.round_edge_size,
)
painter.setPen(Qt.NoPen)
painter.setBrush(self.__title_background_brush)
painter.drawPath(path_title_background.simplified())
def __paint_window_markers(self, painter: "QPainter"):
title_width = self.__graphics_title.boundingRect().width()
for i, parent_window in reversed(
list(enumerate(self.__graphics_node.parent_node_windows))):
self.__window_markers_brush.setColor(
parent_window.color_identifier)
self.__window_markers_pen.setColor(
parent_window.color_identifier.darker())
painter.setPen(self.__window_markers_pen)
painter.setBrush(self.__window_markers_brush)
painter.drawRect(title_width + 20 + i * 25, 8, 15, 15)
def __paint_outline(self, painter: "QPainter"):
"""Paints the outline of the node. Depending on if its selected or not, the
color of the outline changes."""
path_outline = QPainterPath()
path_outline.addRoundedRect(
self.boundingRect(),
self.round_edge_size,
self.round_edge_size,
)
painter.setPen(self.__outline_pen)
painter.setBrush(Qt.NoBrush)
painter.drawPath(path_outline.simplified())
