def update_data(self,
rect: QRectF,
angle: float,
keep_original: bool = True) -> None:
"""
Method to update position and angle of this item
:param rect: The new bounding rect of this item
:param angle: The new angle of this item
:param keep_original: If true, the position and angle before the change will be stored.
Used for preview purposes
:return: None
"""
if not keep_original:
self.rect = rect
self.x = rect.x()
self.y = rect.y()
self.width = rect.width()
self.height = rect.height()
self.center = rect.center().x(), rect.center().y()
self.angle = angle
self.preview = False
self.changed = True
else:
self.preview = True
self.setRotation(0)
self.setRect(rect)
self.setTransformOriginPoint(rect.center())
self.setRotation(angle)
self.edit_rect.setRotation(0)
self.edit_rect.setRect(rect)
self.edit_rect.setTransformOriginPoint(rect.center())
self.edit_rect.setRotation(angle)
def painter_rotate(painter: QPainter, rect: QRectF, angle: int = 0) -> QRectF:
"""Context manager rotating and restoring the painter
:param painter: Painter, which is rotated
:param rect: Rect to be painted in
:param angle: Rotataion angle must be in (0, 90, 180, 270)
"""
supported_angles = 0, 90, 180, 270
angle = int(angle)
if angle not in supported_angles:
msg = "Rotation angle {} not in {}".format(angle, supported_angles)
raise Warning(msg)
return
center_x, center_y = rect.center().x(), rect.center().y()
with painter_save(painter):
painter.translate(center_x, center_y)
painter.rotate(angle)
if angle in (0, 180):
painter.translate(-center_x, -center_y)
elif angle in (90, 270):
painter.translate(-center_y, -center_x)
rect = QRectF(rect.y(), rect.x(), rect.height(), rect.width())
yield rect
def drawValue(self, p: QPainter, baseRect: QRectF, value: float, delta: float):
if value == self.m_min:
return
if self.m_barStyle == self.BarStyle.EXPAND:
p.setBrush(self.palette().highlight())
p.setPen(QPen(self.palette().shadow().color(), self.m_dataPenWidth))
radius = (baseRect.height() / 2) / delta
p.drawEllipse(baseRect.center(), radius, radius)
return
if self.m_barStyle == self.BarStyle.LINE:
p.setPen(QPen(self.palette().highlight().color(), self.m_dataPenWidth))
p.setBrush(Qt.NoBrush)
if value == self.m_max:
p.drawEllipse(baseRect.adjusted(self.m_outlinePenWidth / 2, self.m_outlinePenWidth / 2,
-self.m_outlinePenWidth / 2, -self.m_outlinePenWidth / 2))
else:
arcLength = 360 / delta
p.drawArc(baseRect.adjusted(self.m_outlinePenWidth / 2, self.m_outlinePenWidth / 2,
-self.m_outlinePenWidth / 2, -self.m_outlinePenWidth / 2),
int(self.m_nullPosition * 16),
int(-arcLength * 16))
return
dataPath = QPainterPath()
dataPath.setFillRule(Qt.WindingFill)
if value == self.m_max:
dataPath.addEllipse(baseRect)
else:
arcLength = 360 / delta
dataPath.moveTo(baseRect.center())
dataPath.arcTo(baseRect, self.m_nullPosition, -arcLength)
dataPath.lineTo(baseRect.center())
p.setBrush(self.palette().highlight())
p.setPen(QPen(self.palette().shadow().color(), self.m_dataPenWidth))
p.drawPath(dataPath)
class CartPoleShape:
def __init__(self):
self._boundingBox = QRectF(-239 / 2, -216 / 2, 239, 216)
self._cartBody = QRectF(self._boundingBox.left(),
self._boundingBox.top() + 82,
self._boundingBox.width(), 106)
self._cartJointBody = QRectF(
self._cartBody.center().x() - 53 / 2,
self._boundingBox.top() + 53 / 2, 53,
self._cartBody.top() - self._boundingBox.top() - 53 / 2)
self._cartJointBall = QRectF(
self._cartJointBody.center().x() - self._cartJointBody.width() / 2,
self._cartJointBody.top() - self._cartJointBody.width() / 2,
self._cartJointBody.width(), self._cartJointBody.width())
self._poleCenter = self._cartJointBall.center()
self._leftGear = QRectF(self._boundingBox.left() + 43 - 26,
self._boundingBox.top() + 188 - 26, 26 * 2,
26 * 2)
self._leftGearJoint = QRectF(self._boundingBox.left() + 43 - 2,
self._boundingBox.top() + 188 - 2, 4, 4)
self._rightGear = QRectF(self._boundingBox.left() + 194 - 26,
self._boundingBox.top() + 188 - 26, 26 * 2,
26 * 2)
self._rightGearJoint = QRectF(self._boundingBox.left() + 194 - 2,
self._boundingBox.top() + 188 - 2, 4, 4)
def draw(self, qp, pen):
qp.setPen(pen)
qp.drawRect(self._cartBody)
qp.drawLines([
QLineF(self._cartJointBody.topLeft(),
self._cartJointBody.bottomLeft()),
QLineF(self._cartJointBody.topRight(),
self._cartJointBody.bottomRight()),
QLineF(self._cartJointBody.bottomLeft(),
self._cartJointBody.bottomRight())
])
qp.drawArc(self._cartJointBall, 0, 180 * 16)
qp.drawEllipse(self._leftGear)
qp.drawEllipse(self._leftGearJoint)
qp.drawEllipse(self._rightGear)
qp.drawEllipse(self._rightGearJoint)
# Computes the model matrix that moves the cart in center and has
# size width
def modelMatrix(self, center, width):
return QTransform.fromScale(width / 239,
width / 239) * QTransform.fromTranslate(
-center.x(), -center.y())
def __init__(self, parentItem, segments, colour): QGraphicsItem.__init__(self, parent=parentItem) self.colour_name = colour self.shape = QPainterPath() self.labels = QGraphicsItemGroup(self) self.bbox = QRectF(0, 0, 0, 0) for (p1, p2), label in segments: lvect = QVector2D(p2 - p1) lpath = QPainterPath() m = TWY_line_margin l = lvect.length() plst = [QPointF(-m, 0), QPointF(-m/3, -m), QPointF(l + m/3, -m), QPointF(l + m, 0), QPointF(l + m/3, m), QPointF(-m/3, m)] lpath.addPolygon(QPolygonF(plst)) lrot = QTransform() lrot.rotateRadians(atan2(lvect.y(), lvect.x())) lpath = lrot.map(lpath) lpath.translate(p1) self.shape.addPath(lpath) rect = QRectF(p1, p2).normalized() if label != None: self.labels.addToGroup(TaxiwayLabelItem(label, rect.center(), self)) self.bbox |= rect self.shape.setFillRule(Qt.WindingFill) self.mouse_highlight = False self.labels.setVisible(False)
def paintEvent(self, e: QPaintEvent):
contRect = self.contentsRect()
handleRadius = round(0.24 * contRect.height())
p = QPainter(self)
p.setRenderHint(QPainter.Antialiasing)
p.setPen(self._transparent_pen)
barRect = QRectF(
0, 0,
contRect.width() - handleRadius, 0.40 * contRect.height()
)
barRect.moveCenter(contRect.center())
rounding = barRect.height() / 2
# the handle will move along this line
trailLength = contRect.width() - 2 * handleRadius
xPos = contRect.x() + handleRadius + trailLength * self._handle_position
if self.pulse_anim.state() == QPropertyAnimation.Running:
p.setBrush(
self._pulse_checked_animation if
self.isChecked() else self._pulse_unchecked_animation)
p.drawEllipse(QPointF(xPos, barRect.center().y()),
self._pulse_radius, self._pulse_radius)
if self.isChecked():
p.setBrush(self._bar_checked_brush)
p.drawRoundedRect(barRect, rounding, rounding)
p.setBrush(self._handle_checked_brush)
else:
p.setBrush(self._bar_brush)
p.drawRoundedRect(barRect, rounding, rounding)
p.setPen(self._light_grey_pen)
p.setBrush(self._handle_brush)
p.drawEllipse(
QPointF(xPos, barRect.center().y()),
handleRadius, handleRadius)
p.end()
def resizeEvent(self, e):
geo = QRectF(self.sceneRect())
self.drawingOverlay.setRect(geo)
self.noSelectionHighlight.setRect(geo)
hr = self.helpOverlay.boundingRect()
hr.moveCenter(geo.center())
self.helpOverlay.setPos(hr.x(), hr.y())
self._updateLayout()
def getLinePoint(self, end):
#rect = QRectF(self.pos(), QPoint(self.pos().x()+120, self.pos().y()+60))
rect = QRectF(self.pos(), QSizeF(120, 60))
#calculate center points
left = QPointF(rect.topLeft().x(), rect.center().y())
right = QPointF(rect.bottomRight().x(), rect.center().y())
top = QPointF(rect.center().x(), rect.topLeft().y())
bottom = QPointF(rect.center().x(), rect.bottomRight().y())
if rect.topLeft().x() < end.x():
#point is not left from rect
if rect.bottomRight().x() < end.x():
y1 = GeoHelper.getY(-1,
rect.bottomRight().x(),
rect.topLeft().y(), end.x())
if end.y() < y1:
return "top", top
y1 = GeoHelper.getY(1,
rect.bottomRight().x(),
rect.bottomRight().y(), end.x())
if end.y() < y1:
return "right", right
return "bottom", bottom
elif rect.center().y() < end.y():
return "bottom", bottom
else:
return "top", top
else:
#point is left from rect
y1 = GeoHelper.getY(1,
rect.topLeft().x(),
rect.topLeft().y(), end.x())
if end.y() < y1:
return "top", top
y1 = GeoHelper.getY(-1,
rect.topLeft().x(),
rect.bottomRight().y(), end.x())
if end.y() < y1:
return "left", left
return "bottom", bottom
def reset_view(self):
# The SceneRect controls how far you can pan, make it larger than
# just the bounding box so middle-click panning works
panning_rect = QRectF(self.scene_bounding_rect)
panning_rect_center = panning_rect.center()
panning_rect_size = max(panning_rect.width(), panning_rect.height())*3
panning_rect.setSize(QSizeF(panning_rect_size, panning_rect_size))
panning_rect.moveCenter(panning_rect_center)
self.setSceneRect(panning_rect)
self.fitInView(self.scene_bounding_rect, Qt.KeepAspectRatio)
self.zoom_view(0.8)
self.update_grid()
def _paint_stimulus_points_cell(self, painter, option, model_index):
points = model_index.data(
role=ProtocolSequence.Roles.STIMULUS_POINTS.value)
if points:
font_metrics = QFontMetrics(option.font)
font_height = font_metrics.height()
pixmap_plus1 = QPixmap()
pixmap_plus1.load(Resources.get('one.png'))
pixmap_random = QPixmap()
pixmap_random.load(Resources.get('dice.png'))
padding = 1
max_img_height = max(pixmap_plus1.height(), pixmap_random.height())
max_img_width = max(pixmap_plus1.width(), pixmap_random.width())
cell_centre = (option.rect.x() + 0.5 * option.rect.width(),
option.rect.y() + 0.5 * option.rect.height())
container_height = font_height + max_img_height + 2 * padding
container_width = max_img_width + 2 * padding
start_x = cell_centre[0] - container_width * (len(points) / 2)
container = QRectF(start_x,
cell_centre[1] - 0.5 * container_height,
container_width, container_height)
self.container_height = max(self.container_height,
container.height())
for point in points:
pixmap = point.pattern.pixmap(max_img_height)
painter.drawPixmap(container.topLeft().x() + padding,
container.topLeft().y() + padding, pixmap)
text = str(point.index())
text_bounding_rect = font_metrics.boundingRect(text)
painter.drawText(
container.center().x() - 0.5 * text_bounding_rect.width(),
container.bottomLeft().y() - padding, text)
container.translate(container_width, 0)
self.sizeHintChanged.emit(model_index)
def _generate_bounding_rect(self):
n1_p = Vector(*self.source_node.get_position())
n2_p = Vector(*self.link.target.get_position())
uv = (n2_p - n1_p).unit()
start = n1_p + uv * self.source_node.get_radius()
end = n2_p - uv * self.link.target.get_radius()
#if multiple links ( always )
if self.link.link_num % 2 == 0:
targetDistance = self.link.link_num * 2
else:
targetDistance = (-self.link.link_num + 1) * 2
start = start.rotated_new(self.arrow_separation * targetDistance, n1_p)
end = end.rotated_new(-self.arrow_separation * targetDistance, n2_p)
if self.link._failed:
link_color = Qt.red
else:
link_color = Qt.green
#rect calculation
r = self.weight_rectangle_size
mid = (start + end) / 2
w_len = len(str(self.link.label)) * 4
weight_v = Vector(r if w_len <= r else w_len, r)
weight_rectangle = QRectF(*(mid - weight_v), *(2 * weight_v))
if end.unit()[0] - start.unit()[0] > 0:
link_paint = QLineF(QPointF(*start), QPointF(*end))
else:
link_paint = QLineF(QPointF(*end), QPointF(*start))
center_of_rec_x = weight_rectangle.center().x()
center_of_rec_y = weight_rectangle.center().y()
rx = -(weight_v[0] * 0.5)
ry = -(weight_v[1])
#new_rec = QRectF(rx , ry, weight_v[0], 2 * weight_v[1])
new_rec = QRectF(center_of_rec_x - 10, center_of_rec_y - 10, 15,
15).normalized()
return new_rec
def grab_svg(scene):
"""
Return a SVG rendering of the scene contents.
Parameters
----------
scene : :class:`CanvasScene`
"""
from PyQt5.QtSvg import QSvgGenerator
svg_buffer = QBuffer()
gen = QSvgGenerator()
gen.setOutputDevice(svg_buffer)
items_rect = scene.itemsBoundingRect().adjusted(-10, -10, 10, 10)
if items_rect.isNull():
items_rect = QRectF(0, 0, 10, 10)
width, height = items_rect.width(), items_rect.height()
rect_ratio = float(width) / height
# Keep a fixed aspect ratio.
aspect_ratio = 1.618
if rect_ratio > aspect_ratio:
height = int(height * rect_ratio / aspect_ratio)
else:
width = int(width * aspect_ratio / rect_ratio)
target_rect = QRectF(0, 0, width, height)
source_rect = QRectF(0, 0, width, height)
source_rect.moveCenter(items_rect.center())
gen.setSize(target_rect.size().toSize())
gen.setViewBox(target_rect)
painter = QPainter(gen)
# Draw background.
painter.setBrush(QBrush(Qt.white))
painter.drawRect(target_rect)
# Render the scene
scene.render(painter, target_rect, source_rect)
painter.end()
buffer_str = bytes(svg_buffer.buffer())
return buffer_str.decode("utf-8")
def _debug_draw(self, painter, option, model_index):
num_points = 9
font_metrics = QFontMetrics(option.font)
pixmap = QPixmap()
pixmap.load(Resources.get('dice.png'))
padding = 1
max_img_height = pixmap.height()
cell_centre = (option.rect.x() + 0.5 * option.rect.width(),
option.rect.y() + 0.5 * option.rect.height())
font_height = font_metrics.height()
container_height = font_height + max_img_height + 2 * padding
container_width = pixmap.width() + 2 * padding
start_x = cell_centre[0] - container_width * (num_points / 2)
painter.drawLine(QPointF(cell_centre[0], 0),
QPointF(cell_centre[0], option.rect.height()))
painter.drawLine(QPointF(0, cell_centre[1]),
QPointF(option.rect.width(), cell_centre[1]))
container = QRectF(start_x, cell_centre[1] - 0.5 * container_height,
container_width, container_height)
for i in range(0, num_points):
painter.drawRect(container)
painter.drawPixmap(container.topLeft().x() + padding,
container.topLeft().y() + padding, pixmap)
text = str(i)
text_bounding_rect = font_metrics.boundingRect(text)
painter.drawText(
container.center().x() - 0.5 * text_bounding_rect.width(),
container.bottomLeft().y() - padding, text)
container.translate(container_width, 0)
def ScalePicture(self):
if self.isStripModel:
self.graphicsItem.setPos(0, 0)
rect = QRectF(self.graphicsItem.pos(), QSizeF(
self.pixMap.size()))
flags = Qt.KeepAspectRatio
unity = self.graphicsView.transform().mapRect(QRectF(0, 0, 1, 1))
width = unity.width()
height = unity.height()
if width <= 0 or height <= 0:
return
self.graphicsView.scale(1 / width, 1 / height)
viewRect = self.graphicsView.viewport().rect()
sceneRect = self.graphicsView.transform().mapRect(rect)
if sceneRect.width() <= 0 or sceneRect.height() <= 0:
return
x_ratio = viewRect.width() / sceneRect.width()
y_ratio = viewRect.height() / sceneRect.height()
if not self.isStripModel:
x_ratio = y_ratio = min(x_ratio, y_ratio)
else:
x_ratio = y_ratio = max(x_ratio, y_ratio)
# self.graphicsItem.setPos(p.x(), p.y()+height3)
# self.graphicsView.move(p.x(), p.y()+height2)
# self.graphicsView.move(p.x(), p.y()+height3)
self.graphicsView.scale(x_ratio, y_ratio)
if self.isStripModel:
height2 = self.pixMap.size().height() / 2
height3 = self.graphicsView.size().height()/2
# height4 = self.graphicsView.geometry().height()/2
# height5 = self.graphicsView.frameGeometry().height()/2
height3 = height3/x_ratio
# pos = height2
p = self.graphicsItem.pos()
# self.graphicsItem.setPos(0, 0)
self.graphicsItem.setPos(p.x(), p.y()+height2-height3)
self.graphicsView.centerOn(rect.center())
for _ in range(abs(self.scaleCnt)):
if self.scaleCnt > 0:
self.graphicsView.scale(1.1, 1.1)
else:
self.graphicsView.scale(1/1.1, 1/1.1)
def drawToolButtonContent(self, option, painter, widget):
if option.state & QStyle.State_Enabled:
pixmap = widget.pixmap(QIcon.Normal)
else:
pixmap = widget.pixmap(QIcon.Disabled)
if not pixmap.isNull():
margin = self._pixel_metrics[QStyle.PM_DefaultFrameWidth] + self._pixel_metrics[QStyle.PM_ButtonMargin]
if option.features & QStyleOptionToolButton.MenuButtonPopup and option.direction == Qt.LeftToRight:
right_offset = 1
else:
right_offset = 0
content_rect = QRectF(
self.proxy().subControlRect(QStyle.CC_ToolButton, option, QStyle.SC_ToolButton, widget)
).adjusted(margin, margin, -margin - right_offset, -margin)
pixmap_rect = QRectF(pixmap.rect())
pixmap_rect.moveCenter(content_rect.center())
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setCompositionMode(QPainter.CompositionMode_SourceOver)
painter.drawPixmap(pixmap_rect.topLeft(), pixmap)
def drawToolButtonContent(self, option, painter, widget):
if option.state & QStyle.State_Enabled:
pixmap = widget.pixmap(QIcon.Normal)
else:
pixmap = widget.pixmap(QIcon.Disabled)
if not pixmap.isNull():
margin = self._pixel_metrics[
QStyle.PM_DefaultFrameWidth] + self._pixel_metrics[
QStyle.PM_ButtonMargin]
if option.features & QStyleOptionToolButton.MenuButtonPopup and option.direction == Qt.LeftToRight:
right_offset = 1
else:
right_offset = 0
content_rect = QRectF(self.proxy().subControlRect(
QStyle.CC_ToolButton, option, QStyle.SC_ToolButton,
widget)).adjusted(margin, margin, -margin - right_offset,
-margin)
pixmap_rect = QRectF(pixmap.rect())
pixmap_rect.moveCenter(content_rect.center())
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setCompositionMode(QPainter.CompositionMode_SourceOver)
painter.drawPixmap(pixmap_rect.topLeft(), pixmap)
def setSelected(self, value):
"""
Sets *value*-th glyph as the selected glyph, or none if *value* is
None.
*value* should be less than the number of glyphRecords present in the
widget.
"""
self._selected = value
if self._selected is not None and self._glyphRecordsRects is not None:
scrollArea = self._scrollArea
if scrollArea is not None:
rect = None
for r, indexRecord in self._glyphRecordsRects.items():
if indexRecord == self._selected:
rect = QRectF(*r)
break
if rect is not None:
center = rect.center()
scrollArea.ensureVisible(
center.x(), center.y(), .6 * rect.width(), .6 * rect.height())
self.update()
def paint(self, painter, option, widget=None):
super(Link, self).paint(painter, option, widget)
util = self.link.utilization()
orangeColor = QColor(255, 165, 0)
colour_values = {
self.blue_threshold: QtCore.Qt.blue,
self.green_threshold: QtCore.Qt.green,
self.yellow_threshold: QtCore.Qt.yellow,
self.orange_threshold: orangeColor,
}
colour_values_list = sorted(colour_values)
link_color_index = bisect_left(colour_values_list, util)
if self.link._failed:
link_color = QtCore.Qt.red
elif util == 0:
link_color = QtCore.Qt.black
elif util > int(orange_threshold):
link_color = QtCore.Qt.magenta
else:
try:
link_color_key = colour_values_list[link_color_index]
link_color = colour_values[link_color_key]
# print(util, link_color, link_color_index, link_color_key)
except:
# guard agains <100% thresholds value
link_color = QtCore.Qt.magenta
painter.save()
painter.setFont(QFont(self.font_family, self.font_size / 3))
if self.link.link_num % 2 == 0:
targetDistance = self.link.link_num * 5
else:
targetDistance = (-self.link.link_num + 1) * 5
# hours of calculation and still can't figure out where it's wrong
n1_p = Vector(*self.source_node.get_position())
n2_p = Vector(*self.link.target.get_position())
x1_x0 = n2_p[0] - n1_p[0]
y1_y0 = n2_p[1] - n1_p[1]
if y1_y0 == 0:
x2_x0 = 0
y2_y0 = targetDistance
else:
angle = math.atan((x1_x0) / (y1_y0))
x2_x0 = -targetDistance * math.cos(angle)
y2_y0 = targetDistance * math.sin(angle)
d0x = n1_p[0] + (1 * x2_x0)
d0y = n1_p[1] + (1 * y2_y0)
d1x = n2_p[0] + (1 * x2_x0)
d1y = n2_p[1] + (1 * y2_y0)
dx = (d1x - d0x,)
dy = (d1y - d0y,)
dr = math.sqrt(dx[0] * dx[0] + dy[0] * dy[0])
endX = (d1x + d0x) / 2
endY = (d1y + d0y) / 2
len1 = dr - ((dr / 2) * math.sqrt(3))
endX = endX + (len1 / dr)
endY = endY + (len1 / dr)
n1_p = Vector(d0x, d0y)
n2_p = Vector(endX, endY)
uv = (n2_p - n1_p).unit()
d = distance(n1_p, n2_p)
r = self.link.target.get_radius()
arrow_head_pos = n2_p
d = distance(n1_p, arrow_head_pos)
uv_arrow = (arrow_head_pos - n1_p).unit()
arrow_base_pos = n1_p + uv_arrow * (d - 2 * 2)
nv_arrow = uv_arrow.rotated(math.pi / 2)
painter.setRenderHints(
QtGui.QPainter.Antialiasing
| QtGui.QPainter.TextAntialiasing
| QtGui.QPainter.SmoothPixmapTransform
| QtGui.QPainter.HighQualityAntialiasing,
True,
)
if self.link.highlight:
painter.setPen(QPen(link_color, 3, 3))
elif option.state & QtWidgets.QStyle.State_Selected:
painter.setPen(QPen(link_color, 2, 4))
else:
painter.setPen(QPen(link_color, Qt.SolidLine))
painter.setBrush(QBrush(link_color, Qt.SolidPattern))
painter.drawPolygon(
QPointF(*arrow_head_pos),
QPointF(*(arrow_base_pos + nv_arrow * 2)),
QPointF(*(arrow_base_pos - nv_arrow * 2)),
)
painter.drawLine(QPointF(d0x, d0y), QPointF(endX, endY))
painter.setPen(QtGui.QPen(link_color, 1))
# text
if endX - d0x > 0:
link_paint = QLineF(QPointF(d0x, d0y), QPointF(endX, endY))
else:
link_paint = QLineF(QPointF(endX, endY), QPointF(d0x, d0y))
mid = (arrow_base_pos + n1_p) / 2
if self.show_latency:
w_len = (
len(str(self.link.metric) + str(self.link.latency) + "------") / 3 * r
+ r / 3
)
else:
w_len = len(str(self.link.metric)) / 3 * r + r / 3
weight_v = Vector(w_len, 2)
weight_rectangle = QRectF(*(mid - weight_v), *(2 * weight_v))
painter.save()
center_of_rec_x = weight_rectangle.center().x()
center_of_rec_y = weight_rectangle.center().y()
painter.translate(center_of_rec_x, center_of_rec_y)
rx = -(weight_v[0] * 0.5)
ry = -(weight_v[1])
painter.rotate(-link_paint.angle())
new_rec = QRect(rx, ry, weight_v[0], 2 * weight_v[1])
if self.link._failed:
painter.setBrush(QBrush(Qt.red, Qt.SolidPattern))
elif option.state & QtWidgets.QStyle.State_Selected:
pass
painter.setBrush(QBrush(Qt.black, Qt.SolidPattern))
painter.setPen(QtGui.QPen(Qt.black, Qt.SolidLine))
painter.drawRect(QRect(rx, ry, weight_v[0], 2 * weight_v[1]))
painter.setFont(QFont(self.font_family, self.font_size / 3.3))
painter.setPen(QPen(Qt.white, Qt.SolidLine))
if self.show_latency:
painter.drawText(
new_rec,
Qt.AlignCenter,
str(self.link.metric) + " -- " + str(self.link.latency) + "/ms",
)
else:
painter.drawText(new_rec, Qt.AlignCenter, str(self.link.metric))
painter.restore()
painter.restore()
class TestPathFinding(TestCase):
################################################################################
def setUp(self):
"""
"""
# --left --right
# ' '
# I | II | III
# ------+==========+------ --top
# VIII | IX (in) | IV
# ------+==========+------ --bottom
# VII | VI | V
self._offset = 10
self._rect = QRectF(QPointF(-20, -10), QPointF(20, 10))
self._pointI = QPointF(self._rect.left()-self._offset, self._rect.top()-self._offset)
self._pointII = QPointF(self._rect.center().x(), self._rect.top()-self._offset)
self._pointIII = QPointF(self._rect.right()+ self._offset, self._rect.top()- self._offset)
self._pointIV = QPointF(self._rect.right()+self._offset, self._rect.center().y())
self._pointV = QPointF(self._rect.right()+self._offset, self._rect.bottom()+self._offset)
self._pointVI = QPointF(self._rect.center().x(), self._rect.bottom()+self._offset)
self._pointVII = QPointF(self._rect.left()-self._offset, self._rect.bottom()+self._offset)
self._pointVIII = QPointF(self._rect.left()-self._offset, self._rect.center().y())
self._pointIX = self._rect.center()
self._lineI_VII = QLineF(self._pointI, self._pointVII)
self._lineI_V = QLineF(self._pointI, self._pointV)
self._lineII = QLineF(self._pointII, QPointF(self._rect.center().x(), self._rect.top()))
self._lineII_IV = QLineF(QPointF(self._rect.right()-self._offset, self._rect.top()-self._offset),
QPointF(self._rect.right()+self._offset, self._rect.top()+self._offset))
################################################################################
def testPointRectDist(self):
"""
"""
lineI = PathFinding.pointRectDist(self._pointI, self._rect)
self.assertEqual(lineI.p2(), self._rect.topLeft())
self.assertEqual(lineI.length(), pow(pow(self._offset, 2)+pow(self._offset, 2), 0.5))
lineII = PathFinding.pointRectDist(self._pointII, self._rect)
self.assertEqual(lineII.p2(), QPointF(self._rect.center().x(), self._rect.top()))
self.assertEqual(lineII.length(), self._offset)
lineIII = PathFinding.pointRectDist(self._pointIII, self._rect)
self.assertEqual(lineIII.p2(), self._rect.topRight())
self.assertEqual(lineIII.length(), pow(pow(self._offset, 2)+pow(self._offset, 2), 0.5))
lineIV = PathFinding.pointRectDist(self._pointIV, self._rect)
self.assertEqual(lineIV.p2(), QPointF(self._rect.right(), self._rect.center().y()))
self.assertEqual(lineIV.length(), self._offset)
lineV = PathFinding.pointRectDist(self._pointV, self._rect)
self.assertEqual(lineV.p2(), self._rect.bottomRight())
self.assertEqual(lineV.length(), pow(pow(self._offset, 2)+pow(self._offset, 2), 0.5))
lineVI = PathFinding.pointRectDist(self._pointVI, self._rect)
self.assertEqual(lineVI.p2(), QPointF(self._rect.center().x(), self._rect.bottom()))
self.assertEqual(lineVI.length(), self._offset)
lineVII = PathFinding.pointRectDist(self._pointVII, self._rect)
self.assertEqual(lineVII.p2(), self._rect.bottomLeft())
self.assertEqual(lineVII.length(), pow(pow(self._offset, 2)+pow(self._offset, 2), 0.5))
lineVIII = PathFinding.pointRectDist(self._pointVIII, self._rect)
self.assertEqual(lineVIII.p2(), QPointF(self._rect.left(), self._rect.center().y()))
self.assertEqual(lineVIII.length(), self._offset)
lineIX = PathFinding.pointRectDist(self._pointIX, self._rect)
self.assertEqual(lineIX.p2(), self._pointIX)
self.assertEqual(lineIX.length(), 0)
################################################################################
def testIntersects(self):
"""
"""
rect = QRectF(QPointF(-50, -10), QPointF(50, 10))
# line completely outside of the rectangle
self.assertFalse(PathFinding.intersects(rect, QLineF(QPointF(-100, -50), QPointF(-100, 50))))
# the line is a top side of the rectangle
self.assertFalse(PathFinding.intersects(rect, QLineF(rect.topLeft(), rect.topRight())))
# the line starts at the left corner of the rectangle and is not perpendicular to any of the rectangle sides;
# the line ends outside of the rectangle, not going through it
self.assertFalse(PathFinding.intersects(rect, QLineF(rect.topLeft(), QPointF(-100, -100))))
# the line starts at the left corner of the rectangle and is perpendicular to the top side of the rectangle;
# the line ends outside of the rectangle, not going through it
self.assertFalse(PathFinding.intersects(rect, QLineF(rect.topLeft(), QPointF(rect.left(), rect.top() - 100))))
# the line is horizontal and goes straight through the center of the rectangle
self.assertTrue(PathFinding.intersects(rect, QLineF(QPointF(-100, 0), QPointF(100, 0))))
# the line is vertical and goes straight through the center of the rectangle
self.assertTrue(PathFinding.intersects(rect, QLineF(QPointF(0, -100), QPointF(0, 100))))
# the line is vertical and goes up from the bottom right corner of the rectangle
self.assertFalse(PathFinding.intersects(rect, QLineF(rect.bottomRight(), QPointF(rect.right(), rect.top()-100))))
# the line is diagonal of the rectangle
self.assertTrue(PathFinding.intersects(rect, QLineF(rect.topLeft(), rect.bottomRight())))
class Callout(QGraphicsItem):
def __init__(self, chart):
super().__init__(chart)
self.m_chart = chart
self.m_text = ""
self.m_textRect = QRectF()
self.m_rect = QRectF()
self.m_anchor = QPointF()
self.m_font = QFont()
def boundingRect(self):
anchor = self.mapFromParent(self.m_chart.mapToPosition(self.m_anchor))
rect = QRectF()
rect.setLeft(min(self.m_rect.left(), anchor.x()))
rect.setRight(max(self.m_rect.right(), anchor.x()))
rect.setTop(min(self.m_rect.top(), anchor.y()))
rect.setBottom(max(self.m_rect.bottom(), anchor.y()))
return rect
def paint(self, painter, option, widget=None):
path = QPainterPath()
path.addRoundedRect(self.m_rect, 5, 5)
anchor = self.mapFromParent(self.m_chart.mapToPosition(self.m_anchor))
if not self.m_rect.contains(anchor):
point1 = QPointF()
point2 = QPointF()
# establish the position of the anchor point in relation to m_rect
above = anchor.y() <= self.m_rect.top()
aboveCenter = (anchor.y() > self.m_rect.top()
and anchor.y() <= self.m_rect.center().y())
belowCenter = (anchor.y() > self.m_rect.center().y()
and anchor.y() <= self.m_rect.bottom())
below = anchor.y() > self.m_rect.bottom()
onLeft = anchor.x() <= self.m_rect.left()
leftOfCenter = (anchor.x() > self.m_rect.left()
and anchor.x() <= self.m_rect.center().x())
rightOfCenter = (anchor.x() > self.m_rect.center().x()
and anchor.x() <= self.m_rect.right())
onRight = anchor.x() > self.m_rect.right()
# get the nearest m_rect corner.
x = (onRight + rightOfCenter) * self.m_rect.width()
y = (below + belowCenter) * self.m_rect.height()
cornerCase = ((above and onLeft) or (above and onRight)
or (below and onLeft) or (below and onRight))
vertical = abs(anchor.x() - x) > abs(anchor.y() - y)
x1 = (x + leftOfCenter * 10 - rightOfCenter * 20 +
cornerCase * int(not vertical) *
(onLeft * 10 - onRight * 20))
y1 = (y + aboveCenter * 10 - belowCenter * 20 +
cornerCase * int(vertical) * (above * 10 - below * 20))
point1.setX(x1)
point1.setY(y1)
x2 = (x + leftOfCenter * 20 - rightOfCenter * 10 +
cornerCase * int(not vertical) *
(onLeft * 20 - onRight * 10))
y2 = (y + aboveCenter * 20 - belowCenter * 10 +
cornerCase * int(vertical) * (above * 20 - below * 10))
point2.setX(x2)
point2.setY(y2)
path.moveTo(point1)
path.lineTo(anchor)
path.lineTo(point2)
path = path.simplified()
painter.setBrush(QColor(255, 255, 255))
painter.drawPath(path)
painter.drawText(self.m_textRect, self.m_text)
def mousePressEvent(self, event):
event.setAccepted(True)
def mouseMoveEvent(self, event):
if event.buttons() & Qt.LeftButton:
self.setPos(
self.mapToParent(event.pos() -
event.buttonDownPos(Qt.LeftButton)))
event.setAccepted(True)
else:
event.setAccepted(False)
def setText(self, text):
self.m_text = text
metrics = QFontMetrics(self.m_font)
self.m_textRect = QRectF(
metrics.boundingRect(QRect(0, 0, 150, 150), Qt.AlignLeft,
self.m_text))
self.m_textRect.translate(5, 5)
self.prepareGeometryChange()
self.m_rect = self.m_textRect.adjusted(-5, -5, 5, 5)
def setAnchor(self, point):
self.m_anchor = point
def updateGeometry(self):
self.prepareGeometryChange()
self.setPos(
self.m_chart.mapToPosition(self.m_anchor) + QPoint(10, -50))
# extra2.addEllipse(-0.35*IW, 0.5*IW, 0.7*IW, 0.3*IW)
# FWDPXI_PP += extra1
# FWDPXI_PP -= extra2
# REVPXI_PP.moveTo(-0.5*IW, -0.7*IW)
# REVPXI_PP.lineTo(0., 0.2*IW)
# REVPXI_PP.lineTo(0.5*IW, -0.7*IW)
# extra1 = QPainterPath()
# extra1.addEllipse(-0.5*IW, -0.9*IW, IW, 0.4*IW)
# REVPXI_PP += extra1
_RADIUS = styles.GRID_HELIX_RADIUS
_WEDGE_RECT_GAIN = 0.25
WEDGE_RECT = QRectF(0, 0, 2 * _RADIUS, 2 * _RADIUS)
WEDGE_RECT = WEDGE_RECT.adjusted(0, 0, _WEDGE_RECT_GAIN, _WEDGE_RECT_GAIN)
_WEDGE_RECT_CENTERPT = WEDGE_RECT.center()
class PropertyWrapperObject(QObject):
"""Summary
Attributes:
animations (dict): Description
bondp2 (TYPE): Description
item (TYPE): Description
pen_alpha (TYPE): Description
rotation (TYPE): Description
"""
def __init__(self, item):
"""Summary
def paint(self, painter):
painter.setRenderHint(QPainter.Antialiasing)
pixelRatio = self.devicePixelRatioF()
rect = QRectF(0, 0,
self.width() * pixelRatio,
self.height() * pixelRatio)
sz = QSizeF(self.width() * pixelRatio,
self.height() * pixelRatio).toSize()
self.resizePixmap(sz)
yOffset = rect.toRect().topLeft().y() + (100 - self.value() -
10) * sz.height() / 100
# draw water
waterImage = QImage(sz, QImage.Format_ARGB32_Premultiplied)
waterPainter = QPainter()
waterPainter.begin(waterImage)
waterPainter.setRenderHint(QPainter.Antialiasing)
waterPainter.setCompositionMode(QPainter.CompositionMode_Source)
pointStart = QPointF(sz.width() / 2, 0)
pointEnd = QPointF(sz.width() / 2, sz.height())
linear = QLinearGradient(pointStart, pointEnd)
startColor = QColor('#1F08FF')
startColor.setAlphaF(1)
endColor = QColor('#50FFF7')
endColor.setAlphaF(0.28)
linear.setColorAt(0, startColor)
linear.setColorAt(1, endColor)
linear.setSpread(QGradient.PadSpread)
waterPainter.setPen(Qt.NoPen)
waterPainter.setBrush(linear)
waterPainter.drawEllipse(waterImage.rect().center(),
sz.width() / 2 + 1,
sz.height() / 2 + 1)
waterPainter.setCompositionMode(QPainter.CompositionMode_SourceOver)
waterPainter.drawImage(int(self.backXOffset), yOffset,
self.waterBackImage)
waterPainter.drawImage(
int(self.backXOffset) - self.waterBackImage.width(), yOffset,
self.waterBackImage)
waterPainter.drawImage(int(self.frontXOffset), yOffset,
self.waterFrontImage)
waterPainter.drawImage(
int(self.frontXOffset) - self.waterFrontImage.width(), yOffset,
self.waterFrontImage)
# draw pop
if self.value() > 30:
for pop in self.pops:
popPath = QPainterPath()
popPath.addEllipse(pop.xOffset * sz.width() / 100,
(100 - pop.yOffset) * sz.height() / 100,
pop.size * sz.width() / 100,
pop.size * sz.height() / 100)
waterPainter.fillPath(popPath, QColor(255, 255, 255,
255 * 0.3))
if self.isTextVisible():
font = waterPainter.font()
rectValue = QRect()
progressText = self.text().strip('%')
if progressText == '100':
font.setPixelSize(sz.height() * 35 / 100)
waterPainter.setFont(font)
rectValue.setWidth(sz.width() * 60 / 100)
rectValue.setHeight(sz.height() * 35 / 100)
rectValue.moveCenter(rect.center().toPoint())
waterPainter.setPen(Qt.white)
waterPainter.drawText(rectValue, Qt.AlignCenter, progressText)
else:
font.setPixelSize(sz.height() * 40 / 100)
waterPainter.setFont(font)
rectValue.setWidth(sz.width() * 45 / 100)
rectValue.setHeight(sz.height() * 40 / 100)
rectValue.moveCenter(rect.center().toPoint())
rectValue.moveLeft(rect.left() + rect.width() * 0.45 * 0.5)
waterPainter.setPen(Qt.white)
waterPainter.drawText(rectValue, Qt.AlignCenter, progressText)
font.setPixelSize(font.pixelSize() / 2)
waterPainter.setFont(font)
rectPerent = QRect(
QPoint(rectValue.right(),
rectValue.bottom() - rect.height() * 20 / 100),
QPoint(rectValue.right() + rect.width() * 20 / 100,
rectValue.bottom()))
waterPainter.drawText(rectPerent, Qt.AlignCenter, '%')
waterPainter.end()
maskPixmap = QPixmap(sz)
maskPixmap.fill(Qt.transparent)
path = QPainterPath()
path.addEllipse(QRectF(0, 0, sz.width(), sz.height()))
maskPainter = QPainter()
maskPainter.begin(maskPixmap)
maskPainter.setRenderHint(QPainter.Antialiasing)
maskPainter.setPen(QPen(Qt.white, 1))
maskPainter.fillPath(path, QBrush(Qt.white))
maskPainter.end()
mode = QPainter.CompositionMode_SourceIn
contentImage = QImage(sz, QImage.Format_ARGB32_Premultiplied)
contentPainter = QPainter()
contentPainter.begin(contentImage)
contentPainter.setCompositionMode(QPainter.CompositionMode_Source)
contentPainter.fillRect(contentImage.rect(), Qt.transparent)
contentPainter.setCompositionMode(QPainter.CompositionMode_SourceOver)
contentPainter.drawImage(0, 0, maskPixmap.toImage())
contentPainter.setCompositionMode(mode)
contentPainter.drawImage(0, 0, waterImage)
contentPainter.setCompositionMode(
QPainter.CompositionMode_DestinationOver)
contentPainter.end()
contentImage.setDevicePixelRatio(pixelRatio)
painter.drawImage(self.rect(), contentImage)
def paintEvent(self,event):
global monster_data
global dmg
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.drawPixmap(event.rect(),self.pixmap)
if self.card is not None and self.card.ID is not 0:
card = self.card
# Draw card level at the bottom centered
pen = QPen()
if np.floor(card.lv) == monster_data[card.ID]['max_level']:
lvstr = 'Lv.Max'
brush = QBrush(QColor(252,232,131))
else:
lvstr = 'Lv.%d' % np.floor(card.lv)
brush = QBrush(Qt.white)
path = QPainterPath()
pen.setWidth(0);
pen.setBrush(Qt.black)
font = QFont()
font.setPointSize(11)
font.setWeight(QFont.Black)
path.addText(event.rect().x(),event.rect().y()+48,font,lvstr)
rect = path.boundingRect()
target = (event.rect().x()+event.rect().width())/2
# center the rect in event.rect()
path.translate(target-rect.center().x(), 0)
painter.setPen(pen)
painter.setBrush(QBrush(Qt.black))
painter.drawPath(path.translated(.5,.5))
painter.setPen(pen)
painter.setBrush(brush)
painter.drawPath(path)
# Draw +eggs at the top right
eggs = card.plus_atk+card.plus_hp+card.plus_rcv
if eggs > 0:
eggstr = '+%d' % eggs
pen.setBrush(Qt.yellow)
brush = QBrush(Qt.yellow)
path = QPainterPath()
pen.setWidth(0)
pen.setBrush(Qt.black)
font = QFont()
font.setPointSize(11)
font.setWeight(QFont.Black)
path.addText(event.rect().x(),event.rect().y()+12,font,eggstr)
path.translate(50-path.boundingRect().right()-3,0)
#painter.setFont(font)
painter.setPen(pen)
painter.setBrush(QBrush(Qt.black))
painter.drawPath(path.translated(.5,.5))
painter.setPen(pen)
painter.setBrush(brush)
painter.drawPath(path)
#painter.drawText(event.rect().adjusted(0,0,0,0),Qt.AlignRight, eggstr)
# Draw awakenings at the top left in a green circle
if card.current_awakening > 0:
path = QPainterPath()
rect = QRectF(event.rect()).adjusted(4,4,-36,-36)
path.addEllipse(rect)
painter.setBrush(QBrush(QColor(34,139,34)))
pen.setBrush(Qt.white)
pen.setWidth(1)
painter.setPen(pen)
painter.drawPath(path)
path = QPainterPath()
font.setPointSize(9)
awkstr = ('%d' % card.current_awakening if
card.current_awakening < card.max_awakening else
'★')
path.addText(rect.x(),rect.bottom(),font,awkstr)
br = path.boundingRect()
path.translate(rect.center().x()-br.center().x(),
rect.center().y()-br.center().y())
pen.setBrush(QColor(0,0,0,0))
pen.setWidth(0)
painter.setPen(pen)
painter.setBrush(QBrush(Qt.yellow))
painter.drawPath(path)
# Draw main attack damage
#print(self.main_attack)
if self.main_attack > 0:
matkstr = '%d' % self.main_attack
painter.setBrush(QBrush(COLORS[self.card.element[0]]))
path = QPainterPath()
font = QFont()
font.setFamily('Helvetica')
font.setWeight(QFont.Black)
#font.setStretch(25)
font.setPointSize(13)
path.addText(rect.x(),rect.bottom(),font,matkstr)
rect = QRectF(event.rect())
br = path.boundingRect()
path.translate(rect.center().x()-br.center().x(),
rect.center().y()-br.bottom()-1)
#
pen.setBrush(Qt.black)
pen.setWidthF(.75)
painter.setPen(pen)
painter.drawPath(path)
# Draw sub attack damage
#print(self.main_attack)
if self.sub_attack > 0:
satkstr = '%d' % self.sub_attack
painter.setBrush(QBrush(COLORS[self.card.element[1]]))
path = QPainterPath()
font = QFont()
font.setFamily('Helvetica')
font.setWeight(QFont.Black)
#font.setStretch(25)
font.setPointSize(12)
path.addText(rect.x(),rect.bottom(),font,satkstr)
rect = QRectF(event.rect())
br = path.boundingRect()
path.translate(rect.center().x()-br.center().x(),
rect.center().y()-br.top()+1)
#
pen.setBrush(Qt.black)
pen.setWidthF(.75)
painter.setPen(pen)
painter.drawPath(path)
# extra2.addEllipse(-0.35*IW, 0.5*IW, 0.7*IW, 0.3*IW)
# FWDPXI_PP += extra1
# FWDPXI_PP -= extra2
# REVPXI_PP.moveTo(-0.5*IW, -0.7*IW)
# REVPXI_PP.lineTo(0., 0.2*IW)
# REVPXI_PP.lineTo(0.5*IW, -0.7*IW)
# extra1 = QPainterPath()
# extra1.addEllipse(-0.5*IW, -0.9*IW, IW, 0.4*IW)
# REVPXI_PP += extra1
_RADIUS = styles.SLICE_HELIX_RADIUS
_WEDGE_RECT_GAIN = 0.25
WEDGE_RECT = QRectF(0, 0, 2 * _RADIUS, 2 * _RADIUS)
WEDGE_RECT = WEDGE_RECT.adjusted(0, 0, _WEDGE_RECT_GAIN, _WEDGE_RECT_GAIN)
_WEDGE_RECT_CENTERPT = WEDGE_RECT.center()
class PropertyWrapperObject(QObject):
def __init__(self, item):
"""Summary
Args:
item (TYPE): Description
"""
super(PropertyWrapperObject, self).__init__()
self.item = item
self.animations = {}
def __get_bondP2(self):
"""Summary
def paint(self, painter, option, widget=None):
super(L1CircuitItem, self).paint(painter, option, widget)
painter.save()
n1_p = Vector(*self.source_node.get_position())
n2_p = Vector(*self.link.target.get_position())
uv = (n2_p - n1_p).unit()
start = n1_p + uv * self.source_node.get_radius()
end = n2_p - uv * self.link.target.get_radius()
#if multiple links ( always )
if self.link.link_num % 2 == 0:
targetDistance = self.link.link_num * 2
else:
targetDistance = (-self.link.link_num + 1) * 2
start = start.rotated_new(self.arrow_separation * targetDistance, n1_p)
end = end.rotated_new(-self.arrow_separation * targetDistance, n2_p)
if self.link._failed:
link_color = Qt.red
else:
link_color = Qt.green
painter.setPen(QPen(link_color, Qt.SolidLine))
painter.drawLine(QPointF(*start), QPointF(*end))
painter.setPen(QPen(Qt.black, Qt.SolidLine))
painter.setBrush(QBrush(
Qt.black,
Qt.SolidPattern,
))
#rect calculation
r = self.weight_rectangle_size
mid = (start + end) / 2
w_len = len(str(self.link.label)) * 4
weight_v = Vector(r if w_len <= r else w_len, r)
weight_rectangle = QRectF(*(mid - weight_v), *(2 * weight_v))
if end.unit()[0] - start.unit()[0] > 0:
link_paint = QLineF(QPointF(*start), QPointF(*end))
else:
link_paint = QLineF(QPointF(*end), QPointF(*start))
center_of_rec_x = weight_rectangle.center().x()
center_of_rec_y = weight_rectangle.center().y()
painter.translate(center_of_rec_x, center_of_rec_y)
rx = -(weight_v[0] * 0.5)
ry = -(weight_v[1])
painter.rotate(-link_paint.angle())
new_rec = QRect(rx, ry, weight_v[0], 2 * weight_v[1])
painter.drawRect(QRect(rx, ry, weight_v[0], 2 * weight_v[1]))
painter.setFont(QFont(self.font_family, self.font_size / 4))
painter.setPen(QPen(Qt.white, Qt.SolidLine))
painter.drawText(new_rec, Qt.AlignCenter, str(self.link.label))
painter.restore()
painter.setPen(QPen(Qt.black, Qt.SolidLine))
painter.setFont(QFont(self.font_family, self.font_size / 3))
class QtSocket(QGraphicsItem):
def __init__(self,
socket_row,
mode,
shape,
hover_text="",
parent_item=None):
# If creating a temporary connection, we create a fake socket, whose parent != socket row
if parent_item is None:
parent_item = socket_row
super(QtSocket, self).__init__(parent_item)
self._parentSocketRow = weakref.ref(socket_row)
assert mode in ("input", "output"), mode
self._mode = mode
assert shape in (SocketTypes.circle, SocketTypes.square), shape
self._shape = shape
self._rect = QRectF(0, 0, 12, 12)
self._color = QColor(200, 200, 200)
self._brush = QBrush(self.color())
self._pen = QPen(Qt.NoPen)
self._hoverText = hover_text
self._mixedColor = False
self.setFlag(QGraphicsItem.ItemSendsScenePositionChanges, True)
self._pen.setWidthF(1.0)
self.setAcceptHoverEvents(True)
self.setToolTip(hover_text)
self._draggingConnection = None
self._connections = []
def mode(self):
return self._mode
def isInput(self):
return self._mode == "input"
def isOutput(self):
return self._mode == "output"
def parentNode(self):
return self._parentSocketRow().parentNode()
def parentSocketRow(self):
return self._parentSocketRow()
def borderEnabled(self):
return self._pen.getStyle() == Qt.SolidLine
def setBorderEnabled(self, value):
if value:
self._pen.setStyle(Qt.SolidLine)
else:
self._pen.setStyle(Qt.NoPen)
def addConnection(self, connection):
self._connections.append(connection)
def removeConnection(self, connection):
self._connections.remove(connection)
def findConnection(self, socket):
for connection in self._connections:
if connection.endSocket() is socket:
return connection
if connection.startSocket() is socket:
return connection
def reorderConnection(self, connection, index):
current_index = self._connections.index(connection)
del self._connections[current_index]
self._connections.insert(index, connection)
# Update all paths
for _connection in self._connections:
_connection.updatePath()
print("UPDATE PATHS")
def getIndexInfo(self, connection):
index = self._connections.index(connection)
return index, len(self._connections)
def hoverEnterEvent(self, event):
self.parentNode().view().onSocketHoverEnter(self, event)
for connection in self._connections:
connection.onSocketHoverEnter()
def hoverLeaveEvent(self, event):
for connection in self._connections:
connection.onSocketHoverExit()
self.parentNode().view().onSocketHoverExit(self)
def setMixedColor(self, value=True):
self._mixedColor = value
def setShape(self, shape):
self._shape = shape
def setColor(self, color):
self._color.setRgb(color.red(), color.green(), color.blue())
self._brush.setColor(self._color)
self._pen.setColor(self._color.darker(150))
def color(self):
return QColor(self._color)
def setColorRef(self, color):
self._color = color
def colorRef(self):
return self._color
def mousePressEvent(self, event):
if event.button() == Qt.LeftButton and event.modifiers(
) == Qt.NoModifier:
from .connection import Connection
if self.isOutput():
connection = self._draggingConnection = Connection(self)
self.scene().addItem(connection)
connection.setActive(False)
connection.show()
elif event.button() == Qt.MiddleButton or \
(event.button() == Qt.LeftButton and event.modifiers() == Qt.ControlModifier):
self.parentNode().view().guiOnSocketInteract(self)
def mouseMoveEvent(self, event):
connection = self._draggingConnection
if self.isOutput() and connection is not None:
mouse_pos = connection.mapFromScene(event.scenePos())
end_socket = connection.endSocket()
end_socket.setPos(mouse_pos)
connection.setActiveState(False)
connection.updateEndPos()
# QGraphicsItem.mouseMoveEvent(self, event)
def mouseReleaseEvent(self, event):
if event.button() == Qt.LeftButton and event.modifiers(
) == Qt.NoModifier:
if self.isOutput():
connection = self._draggingConnection
start_socket = connection.startSocket()
target_socket = connection.findClosestSocket()
connection.onDeleted()
self.scene().removeItem(connection)
self._draggingConnection = None
if target_socket is not None:
node = self.parentNode()
try:
node.view().guiCreateConnection(
start_socket, target_socket)
except NodeConnectionError:
pass
# QGraphicsItem.mouseReleaseEvent(self, event)
def setVisible(self, flag):
QGraphicsItem.setVisible(self, flag)
for connection in self._connections:
connection.updateVisibility()
def updateConnectionPositions(self):
"""Update connection positions when nodes are moved"""
for connection in self._connections:
if connection.startSocket() is self:
connection.updateStartPos()
else:
connection.updateEndPos()
def boundingRect(self):
return self._rect
def paint(self, painter, option, widget):
painter.setBrush(self._brush)
painter.setPen(self._pen)
if self._shape == SocketTypes.circle:
painter.drawEllipse(self._rect)
elif self._shape == SocketTypes.square:
painter.save()
c = self._rect.center()
painter.translate(c)
painter.rotate(45)
painter.scale(0.8, 0.8)
painter.drawRect(self._rect.translated(-c))
painter.restore()
else:
raise ValueError(self._shape)
if self._mixedColor:
painter.setBrush(painter.brush().color().darker(130))
painter.drawChord(self._rect, 1 * 16, 180 * 16)
def onDeleted(self):
pass
def multiplyDiameter(self, factor):
r1 = self.rect()
r2 = QRectF(0, 0, r1.width() * factor, r1.height() * factor)
self.setRect(r2)
self.setPos(self.pos() + r1.center() - r2.center())
def multiplyDiameter(self, factor):
r1 = self.rect()
r2 = QRectF(0, 0, r1.width() * factor, r1.height() * factor)
self.setRect(r2)
self.setPos(self.pos() + r1.center() - r2.center())
def _generate_bounding_rect(self):
if self.link.link_num % 2 == 0:
targetDistance = self.link.link_num * 5
else:
targetDistance = (-self.link.link_num + 1) * 5
# hours of calculation and still can't figure out where it's wrong
n1_p = Vector(*self.source_node.get_position())
n2_p = Vector(*self.link.target.get_position())
x1_x0 = n2_p[0] - n1_p[0]
y1_y0 = n2_p[1] - n1_p[1]
if y1_y0 == 0:
x2_x0 = 0
y2_y0 = targetDistance
else:
angle = math.atan((x1_x0) / (y1_y0))
x2_x0 = -targetDistance * math.cos(angle)
y2_y0 = targetDistance * math.sin(angle)
d0x = n1_p[0] + (1 * x2_x0)
d0y = n1_p[1] + (1 * y2_y0)
d1x = n2_p[0] + (1 * x2_x0)
d1y = n2_p[1] + (1 * y2_y0)
dx = (d1x - d0x,)
dy = (d1y - d0y,)
dr = math.sqrt(dx[0] * dx[0] + dy[0] * dy[0])
endX = (d1x + d0x) / 2
endY = (d1y + d0y) / 2
len1 = dr - ((dr / 2) * math.sqrt(3))
endX = endX + (len1 / dr)
endY = endY + (len1 / dr)
n1_p = Vector(d0x, d0y)
n2_p = Vector(endX, endY)
uv = (n2_p - n1_p).unit()
d = distance(n1_p, n2_p)
r = self.link.target.get_radius()
arrow_head_pos = n2_p
d = distance(n1_p, arrow_head_pos)
uv_arrow = (arrow_head_pos - n1_p).unit()
arrow_base_pos = n1_p + uv_arrow * (d - 2 * 2)
nv_arrow = uv_arrow.rotated(math.pi / 2)
# text
if endX - d0x > 0:
link_paint = QLineF(QPointF(d0x, d0y), QPointF(endX, endY))
else:
link_paint = QLineF(QPointF(endX, endY), QPointF(d0x, d0y))
mid = (arrow_base_pos + n1_p) / 2
w_len = len(str(self.link.metric)) / 3 * r + r / 3
weight_v = Vector(w_len, 2)
weight_rectangle = QRectF(*(mid - weight_v), *(2 * weight_v))
center_of_rec_x = weight_rectangle.center().x()
center_of_rec_y = weight_rectangle.center().y()
new_rec = QRectF(
center_of_rec_x - 10, center_of_rec_y - 10, 20, 20
).normalized()
return new_rec
def drawPic(self, painter):
painter.save()
nItemY = 0
#nWidth = self.width()
nWidth = 755
nWidth = nWidth if nWidth % 2 == 0 else nWidth + 1
topLeft = QPointF(0, nItemY + 30)
bottomRight = QPointF(nWidth, nItemY + ITEM_HEIGHT + ITEM_SPACE)
ItemRect = QRectF(topLeft, bottomRight)
painter.save()
t = QTransform()
t.translate(ItemRect.center().x(), ItemRect.center().y())
painter.setTransform(t)
rectTopLeft = QPointF()
rectBottomRight = QPointF()
textRect = QRectF(rectTopLeft, rectBottomRight)
font = QFont('幼圆', 10)
painter.setFont(font)
path = QPainterPath()
image = QImage()
image.loadFromData(self.pic)
pixmap = QPixmap.fromImage(image)
pixelsWide = image.width()
pixelsHigh = image.height()
#m_wf = nWidth * 2 // 3
##pixelsHigh = ITEM_HEIGHT if pixelsWide < (m_wf*8//9) else (((pixelsWide // (nWidth // 2)) + 2) * ITEM_HEIGHT*2//5)
#pixelsWide = pixelsWide if pixelsWide < (m_wf*8//9) else (m_wf*8//9)
if pixelsWide > 540:
pixelsWide = 540
pixelsHigh = int(pixelsHigh * (540 / pixelsWide))
if Orientation.Right == self.m_oritation:
painter.save()
painter.setPen(Qt.NoPen)
painter.setBrush(HeaderBgColor)
#绘制边框 头像边框
painter.drawRoundedRect(nWidth // 2 - 55, -ITEM_HEIGHT // 2,
HEAD_W_H, HEAD_W_H, 2, 2)
painter.setPen(HeaderTextColor)
#painter->drawPixmap(nWidth / 2 - 54, -ITEM_HEIGHT / 2 + 1, 48, 48, QPixmap(""));
#绘制头像
image = QImage()
image.loadFromData(self.self_head)
painter.drawPixmap(nWidth // 2 - 54, -ITEM_HEIGHT // 2 + 1,
HEAD_W_H, HEAD_W_H, QPixmap.fromImage(image))
painter.restore()
nX = (nWidth // 2) - 85 - pixelsWide
if nX < 0:
nX = -pixelsWide - 85 + nWidth // 2
painter.save()
textRect = QRectF(nX, -ITEM_HEIGHT // 2, pixelsWide + 20,
pixelsHigh)
path.addRoundedRect(textRect, 3, 3)
path.moveTo(nWidth // 2 - 65, -ITEM_HEIGHT // 2 + 12)
path.lineTo(nWidth // 2 - 55, -ITEM_HEIGHT // 2 + 18)
path.lineTo(nWidth // 2 - 65, -ITEM_HEIGHT // 2 + 21)
painter.setPen(QColor(140, 170, 202))
painter.drawPath(path)
#painter.drawPixmap(nX + 10, -ITEM_HEIGHT / 2,pixelsWide, QPixmap(''))
painter.restore()
painter.setPen(Qt.white)
textRect = QRectF(nX + 10, -ITEM_HEIGHT // 2, pixelsWide,
pixelsHigh)
#设置text颜色
painter.setPen(Qt.red)
painter.drawPixmap(nX + 10, -ITEM_HEIGHT // 2, pixelsWide,
pixelsHigh, pixmap) #,
painter.restore()
#increment nItemY item高度设置
if pixelsHigh <= HEAD_W_H:
pixelsHigh = HEAD_W_H
nItemY += pixelsHigh + ITEM_SPACE #head height + ITEMSPACING
else:
nItemY += pixelsHigh + ITEM_SPACE
#QSize(width(),height)
#self.sendItemSize.emit(self.width(),pixelsHigh + ITEM_SPACE+30)
self.sendItemSize.emit(755, pixelsHigh + ITEM_SPACE + 30)
else:
painter.save()
textRect = QRectF(-nWidth // 2 + 59, -ITEM_HEIGHT // 2,
pixelsWide + 20, pixelsHigh)
path.addRoundedRect(textRect, 3, 3)
path.moveTo(-nWidth // 2 + 59, -ITEM_HEIGHT // 2 + 12)
path.lineTo(-nWidth // 2 + 49, -ITEM_HEIGHT // 2 + 18)
path.lineTo(-nWidth // 2 + 59, -ITEM_HEIGHT // 2 + 21)
painter.setPen(QColor(140, 170, 202))
painter.drawPath(path)
painter.restore()
#绘制头像
painter.save()
painter.setPen(Qt.NoPen)
painter.setBrush(HeaderBgColor)
leftRect = QRectF(-nWidth // 2 + 5, -ITEM_HEIGHT // 2, HEAD_W_H,
HEAD_W_H)
painter.drawRect(leftRect)
painter.setPen(HeaderTextColor)
image = QImage()
image.loadFromData(self.head)
painter.drawPixmap(-nWidth // 2 + 5, -ITEM_HEIGHT // 2, HEAD_W_H,
HEAD_W_H, QPixmap.fromImage(image))
painter.restore()
painter.setPen(COLOR_BLACK)
textRect = QRectF(-nWidth // 2 + 59 + 10, -ITEM_HEIGHT // 2,
pixelsWide, pixelsHigh)
#设置text颜色
painter.setPen(Qt.red)
painter.drawPixmap(-nWidth // 2 + 59 + 10, -ITEM_HEIGHT // 2,
pixelsWide, pixelsHigh, pixmap) #,
painter.restore()
#increment nItemY item高度设置
if pixelsHigh <= HEAD_W_H:
pixelsHigh = HEAD_W_H
nItemY += pixelsHigh + ITEM_SPACE #head height + ITEMSPACING
else:
nItemY += pixelsHigh + ITEM_SPACE
#QSize(width(),height)
#self.sendItemSize.emit(self.width(),pixelsHigh + ITEM_SPACE+30)
self.sendItemSize.emit(755, pixelsHigh + ITEM_SPACE + 30)
class RectItem(BaseItem):
def __init__(self, model_item=None, prefix="", parent=None):
BaseItem.__init__(self, model_item, prefix, parent)
self._rect = None
self._resize = False
self._resize_start = None
self._resize_start_rect = None
self._upper_half_clicked = None
self._left_half_clicked = None
self._updateRect(self._dataToRect(self._model_item))
LOG.debug("Constructed rect %s for model item %s" %
(self._rect, model_item))
def __call__(self, model_item=None, parent=None):
item = RectItem(model_item, parent)
item.setPen(self.pen())
item.setBrush(self.brush())
return item
def _dataToRect(self, model_item):
if model_item is None:
return QRectF()
try:
return QRectF(float(model_item[self.prefix() + 'x']),
float(model_item[self.prefix() + 'y']),
float(model_item[self.prefix() + 'width']),
float(model_item[self.prefix() + 'height']))
except KeyError as e:
LOG.debug("RectItem: Could not find expected key in item: " +
str(e) + ". Check your config!")
self.setValid(False)
return QRectF()
def _updateRect(self, rect):
if rect == self._rect:
return
self.prepareGeometryChange()
self._rect = rect
self.setPos(rect.topLeft())
def updateModel(self):
self._rect = QRectF(self.scenePos(), self._rect.size())
self._model_item.update({
self.prefix() + 'x':
float(self._rect.topLeft().x()),
self.prefix() + 'y':
float(self._rect.topLeft().y()),
self.prefix() + 'width':
float(self._rect.width()),
self.prefix() + 'height':
float(self._rect.height()),
})
def boundingRect(self):
return QRectF(QPointF(0, 0), self._rect.size())
def paint(self, painter, option, widget=None):
BaseItem.paint(self, painter, option, widget)
pen = self.pen()
if self.isSelected():
pen.setStyle(Qt.DashLine)
painter.setPen(pen)
painter.drawRect(self.boundingRect())
def dataChange(self):
rect = self._dataToRect(self._model_item)
self._updateRect(rect)
def mousePressEvent(self, event):
#if event.modifiers() & Qt.ControlModifier != 0:
if event.button() & Qt.RightButton != 0:
self._resize = True
self._resize_start = event.scenePos()
self._resize_start_rect = QRectF(self._rect)
self._upper_half_clicked = (event.scenePos().y() <
self._resize_start_rect.center().y())
self._left_half_clicked = (event.scenePos().x() <
self._resize_start_rect.center().x())
event.accept()
else:
BaseItem.mousePressEvent(self, event)
def mouseMoveEvent(self, event):
if self._resize:
diff = event.scenePos() - self._resize_start
if self._left_half_clicked:
x = self._resize_start_rect.x() + diff.x()
w = self._resize_start_rect.width() - diff.x()
else:
x = self._resize_start_rect.x()
w = self._resize_start_rect.width() + diff.x()
if self._upper_half_clicked:
y = self._resize_start_rect.y() + diff.y()
h = self._resize_start_rect.height() - diff.y()
else:
y = self._resize_start_rect.y()
h = self._resize_start_rect.height() + diff.y()
rect = QRectF(QPointF(x, y), QSizeF(w, h)).normalized()
self._updateRect(rect)
self.updateModel()
event.accept()
else:
BaseItem.mouseMoveEvent(self, event)
def mouseReleaseEvent(self, event):
if self._resize:
self._resize = False
event.accept()
else:
BaseItem.mouseReleaseEvent(self, event)
def keyPressEvent(self, event):
BaseItem.keyPressEvent(self, event)
step = 1
if event.modifiers() & Qt.ShiftModifier:
step = 5
ds = {
Qt.Key_Left: (-step, 0),
Qt.Key_Right: (step, 0),
Qt.Key_Up: (0, -step),
Qt.Key_Down: (0, step),
}.get(event.key(), None)
if ds is not None:
if event.modifiers() & Qt.ControlModifier:
rect = self._rect.adjusted(*((0, 0) + ds))
else:
rect = self._rect.adjusted(*(ds + ds))
self._updateRect(rect)
self.updateModel()
event.accept()
def drawMagnifier(self):
# First, calculate the magnifier position due to the mouse position
watchAreaWidth = 16
watchAreaHeight = 16
watchAreaPixmap = QPixmap()
cursor_pos = self.mousePoint
watchArea = QRect(
QPoint(cursor_pos.x() - watchAreaWidth / 2,
cursor_pos.y() - watchAreaHeight / 2),
QPoint(cursor_pos.x() + watchAreaWidth / 2,
cursor_pos.y() + watchAreaHeight / 2))
if watchArea.left() < 0:
watchArea.moveLeft(0)
watchArea.moveRight(watchAreaWidth)
if self.mousePoint.x() + watchAreaWidth / 2 >= self.screenPixel.width(
):
watchArea.moveRight(self.screenPixel.width() - 1)
watchArea.moveLeft(watchArea.right() - watchAreaWidth)
if self.mousePoint.y() - watchAreaHeight / 2 < 0:
watchArea.moveTop(0)
watchArea.moveBottom(watchAreaHeight)
if self.mousePoint.y(
) + watchAreaHeight / 2 >= self.screenPixel.height():
watchArea.moveBottom(self.screenPixel.height() - 1)
watchArea.moveTop(watchArea.bottom() - watchAreaHeight)
# tricks to solve the hidpi impact on QCursor.pos()
watchArea.setTopLeft(
QPoint(watchArea.topLeft().x() * self.scale,
watchArea.topLeft().y() * self.scale))
watchArea.setBottomRight(
QPoint(watchArea.bottomRight().x() * self.scale,
watchArea.bottomRight().y() * self.scale))
watchAreaPixmap = self.screenPixel.copy(watchArea)
# second, calculate the magnifier area
magnifierAreaWidth = watchAreaWidth * 10
magnifierAreaHeight = watchAreaHeight * 10
fontAreaHeight = 40
cursorSize = 24
magnifierArea = QRectF(
QPoint(QCursor.pos().x() + cursorSize,
QCursor.pos().y() + cursorSize),
QPoint(QCursor.pos().x() + cursorSize + magnifierAreaWidth,
QCursor.pos().y() + cursorSize + magnifierAreaHeight))
if magnifierArea.right() >= self.screenPixel.width():
magnifierArea.moveLeft(QCursor.pos().x() - magnifierAreaWidth -
cursorSize / 2)
if magnifierArea.bottom() + fontAreaHeight >= self.screenPixel.height(
):
magnifierArea.moveTop(QCursor.pos().y() - magnifierAreaHeight -
cursorSize / 2 - fontAreaHeight)
# third, draw the watch area to magnifier area
watchAreaScaled = watchAreaPixmap.scaled(
QSize(magnifierAreaWidth * self.scale,
magnifierAreaHeight * self.scale))
magnifierPixmap = self.graphicsScene.addPixmap(watchAreaScaled)
magnifierPixmap.setOffset(magnifierArea.topLeft())
# then draw lines and text
self.graphicsScene.addRect(QRectF(magnifierArea),
QPen(QColor(255, 255, 255), 2))
self.graphicsScene.addLine(
QLineF(QPointF(magnifierArea.center().x(), magnifierArea.top()),
QPointF(magnifierArea.center().x(),
magnifierArea.bottom())),
QPen(QColor(0, 255, 255), 2))
self.graphicsScene.addLine(
QLineF(QPointF(magnifierArea.left(),
magnifierArea.center().y()),
QPointF(magnifierArea.right(),
magnifierArea.center().y())),
QPen(QColor(0, 255, 255), 2))
# get the rgb of mouse point
pointRgb = QColor(self.screenPixel.toImage().pixel(self.mousePoint))
# draw information
self.graphicsScene.addRect(
QRectF(
magnifierArea.bottomLeft(),
magnifierArea.bottomRight() + QPoint(0, fontAreaHeight + 30)),
Qt.black, QBrush(Qt.black))
rgbInfo = self.graphicsScene.addSimpleText(
' Rgb: ({0}, {1}, {2})'.format(pointRgb.red(), pointRgb.green(),
pointRgb.blue()))
rgbInfo.setPos(magnifierArea.bottomLeft() + QPoint(0, 5))
rgbInfo.setPen(QPen(QColor(255, 255, 255), 2))
rect = self.selectedArea.normalized()
sizeInfo = self.graphicsScene.addSimpleText(' Size: {0} x {1}'.format(
rect.width() * self.scale,
rect.height() * self.scale))
sizeInfo.setPos(magnifierArea.bottomLeft() + QPoint(0, 15) +
QPoint(0, fontAreaHeight / 2))
sizeInfo.setPen(QPen(QColor(255, 255, 255), 2))
def drawControl(self, p, opt, arect, icon, menustyle):
"""
due to overrides the "paintEvent" method, so we must repaint all menu item by self.
luckly, we have qt source code to reference.
void drawControl (ControlElement element, const QStyleOption *opt, QPainter *p, const QWidget *w=0) const
https://cep.xray.aps.anl.gov/software/qt4-x11-4.8.6-browser/df/d91/class_q_style_sheet_style.html#ab92c0e0406eae9a15bc126b67f88c110
Line 3533: element = CE_MenuItem
"""
style = self.style()
p.setPen(menustyle.getPenColor(opt))
# Line 3566: draw icon and checked sign
checkable = opt.checkType != QStyleOptionMenuItem.NotCheckable
checked = opt.checked if checkable else False
if opt.icon.isNull() is False: # has custom icon
dis = not (int(opt.state) & int(QStyle.State_Enabled))
active = int(opt.state) & int(QStyle.State_Selected)
mode = QIcon.Disabled if dis else QIcon.Normal
if active != 0 and not dis: mode = QIcon.Active
fw = style.pixelMetric(QStyle.PM_MenuPanelWidth, opt, self)
icone = style.pixelMetric(QStyle.PM_SmallIconSize, opt, self)
iconRect = QRectF(arect.x() - fw, arect.y(), self._side_image.width(), arect.height())
if checked:
pixmap = icon.pixmap(QSize(icone, icone), mode, QIcon.On)
else:
pixmap = icon.pixmap(QSize(icone, icone), mode)
pixw = pixmap.width()
pixh = pixmap.height()
pmr = QRectF(0, 0, pixw, pixh)
pmr.moveCenter(iconRect.center())
if checked: p.drawRect(QRectF(pmr.x() - 1, pmr.y() - 1, pixw + 2, pixh + 2))
p.drawPixmap(pmr.topLeft(), pixmap)
elif checkable and checked: # draw default checked sign
opt.rect = QRect(0, arect.y(), self._side_image.width(), arect.height())
opt.palette.setColor(QPalette.Text, menustyle.getPenColor(opt))
style.drawPrimitive(QStyle.PE_IndicatorMenuCheckMark, opt, p, self)
# Line 3604: draw emnu text
font = menustyle.font
if font is not None:
p.setFont(font)
else:
p.setFont(opt.font)
text_flag = Qt.AlignVCenter | Qt.TextShowMnemonic | Qt.TextDontClip | Qt.TextSingleLine
tr = QRect(arect)
s = opt.text
if '\t' in s:
ss = s[s.index('\t') + 1:]
fontwidth = opt.fontMetrics.width(ss)
tr.moveLeft(opt.rect.right() - fontwidth)
tr = QStyle.visualRect(opt.direction, opt.rect, tr)
p.drawText(tr, text_flag, ss)
tr.moveLeft(self._side_image.width() + arect.x())
tr = QStyle.visualRect(opt.direction, opt.rect, tr)
p.drawText(tr, text_flag, s)
# Line 3622: draw sub menu arrow
if opt.menuItemType == QStyleOptionMenuItem.SubMenu:
arrowW = style.pixelMetric(QStyle.PM_IndicatorWidth, opt, self)
arrowH = style.pixelMetric(QStyle.PM_IndicatorHeight, opt, self)
arrowRect = QRect(0, 0, arrowW, arrowH)
arrowRect.moveBottomRight(arect.bottomRight())
arrow = QStyle.PE_IndicatorArrowLeft if opt.direction == Qt.RightToLeft else QStyle.PE_IndicatorArrowRight
opt.rect = arrowRect
opt.palette.setColor(QPalette.ButtonText, menustyle.getPenColor(opt))
style.drawPrimitive(arrow, opt, p, self)
pass
class DeusEx(QGraphicsObject):
deusExActivateSignal = pyqtSignal(DeusExSignalData)
def __init__(self, config, type, pulseSound, endingSound):
super().__init__()
self.type = type
self.config = config
self.width = 200
self.height = 200
self.m_boundingRect = QRectF(0, 0, self.width, self.height)
self.m_painterPath = QPainterPath()
self.m_painterPath.addEllipse(self.m_boundingRect)
# radial gradient settings
self.rgcx = self.m_boundingRect.center().x()
self.rgcy = self.m_boundingRect.center().y()
self.rgMinRadius = 50
self.rgMaxRadius = 300
self.rgCurrentRadius = 50
self.rgfx = self.rgcx
self.rgfy = self.rgcy
self.rg = QRadialGradient(self.rgcx, self.rgcy, self.rgCurrentRadius, self.rgfx, self.rgfy)
if self.type is DeusExTypes.POSITIVE:
firstClr = QColor(Qt.green)
firstClr.setAlphaF(0.7)
secondClr = QColor(Qt.darkGreen)
secondClr.setAlphaF(0.7)
self.rg.setColorAt(0.0, firstClr)
self.rg.setColorAt(1.0, secondClr)
else:
firstClr = QColor(Qt.red)
firstClr.setAlphaF(0.7)
secondClr = QColor(Qt.darkRed)
secondClr.setAlphaF(0.7)
self.rg.setColorAt(0.0, firstClr)
self.rg.setColorAt(1.0, secondClr)
# pulsing sound
self.pulseSound = pulseSound
self.endingSound = endingSound
# pulsing timer
self.pulseTimer = QTimer()
self.pulseTimer.setTimerType(Qt.PreciseTimer)
self.pulseTimer.timeout.connect(self.pulse)
self.pulseTimer.start(100)
# pre activate timer
self.preActivateTimer = QTimer()
self.preActivateTimer.setTimerType(Qt.PreciseTimer)
self.preActivateTimer.timeout.connect(self.preActivate)
if self.type is DeusExTypes.POSITIVE:
self.preActivateTimer.start(10000)
else:
self.preActivateTimer.start(3000)
# activate timer
self.activateTimer = QTimer()
self.activateTimer.setTimerType(Qt.PreciseTimer)
self.activateTimer.timeout.connect(self.endingSoundFinished)
def boundingRect(self):
return self.m_boundingRect
def shape(self):
return self.m_painterPath
def paint(self, QPainter, QStyleOptionGraphicsItem, widget=None):
pen = QPen()
if self.type is DeusExTypes.POSITIVE:
pen.setColor(Qt.darkGreen)
else:
pen.setColor(Qt.darkRed)
brush = QBrush(self.rg)
QPainter.setPen(pen)
QPainter.setBrush(brush)
QPainter.drawEllipse(self.m_boundingRect)
def pulse(self):
if self.rgCurrentRadius == 50:
self.pulseSound.play()
self.rgCurrentRadius += 20
self.rg.setCenterRadius(self.rgCurrentRadius)
if self.rgCurrentRadius >= self.rgMaxRadius:
self.rgCurrentRadius = self.rgMinRadius
def preActivate(self):
firstClr = QColor(Qt.yellow)
firstClr.setAlphaF(0.7)
secondClr = QColor(Qt.darkYellow)
secondClr.setAlphaF(0.7)
self.rg.setColorAt(0.0, firstClr)
self.rg.setColorAt(1.0, secondClr)
self.pulseSound.stop()
self.pulseTimer.timeout.disconnect()
self.preActivateTimer.timeout.disconnect()
self.pulseTimer.stop()
self.preActivateTimer.stop()
# activate
self.endingSound.play()
self.activateTimer.start()
def endingSoundFinished(self):
if self.endingSound.get_state() == AL_STOPPED:
deusExSignalData = DeusExSignalData(self.type)
for obj in self.collidingItems():
if type(obj).__name__ == "Player":
deusExSignalData.markedPlayers.append(obj)
self.activateTimer.timeout.disconnect()
self.activateTimer.stop()
self.deusExActivateSignal.emit(deusExSignalData)
self.scene().removeItem(self)
del self
