def __init__(self, line_or_point, follows=None):
super(GuideLine, self).__init__(follows)
if isinstance(line_or_point, QtCore.QLineF):
self.line = line_or_point
elif follows is not None:
self.line = QtCore.QLineF(self.prevGuide.endPos(), line_or_point)
else:
self.line = QtCore.QLineF(QtCore.QPointF(0, 0), line_or_point)
def paint(self, painter, option, widget=None):
if self.start_node.collidesWithItem(self.end_node):
return
start_node = self.start_node
end_node = self.end_node
color = self.arrow_color
pen = self.pen()
pen.setColor(self.arrow_color)
arrow_size = 20.0
painter.setPen(pen)
painter.setBrush(self.arrow_color)
end_rectangle = end_node.sceneBoundingRect()
start_center = start_node.sceneBoundingRect().center()
end_center = end_rectangle.center()
center_line = QtCore.QLineF(start_center, end_center)
end_polygon = QtGui.QPolygonF(end_rectangle)
p1 = end_polygon.at(0)
intersect_point = QtCore.QPointF()
for p2 in end_polygon:
poly_line = QtCore.QLineF(p1, p2)
intersect_type, intersect_point = poly_line.intersect(center_line)
if intersect_type == QtCore.QLineF.BoundedIntersection:
break
p1 = p2
self.setLine(QtCore.QLineF(intersect_point, start_center))
line = self.line()
angle = math.acos(line.dx() / line.length())
if line.dy() >= 0:
angle = (math.pi * 2.0) - angle
arrow_p1 = line.p1() + QtCore.QPointF(
math.sin(angle + math.pi / 3.0) * arrow_size,
math.cos(angle + math.pi / 3.0) * arrow_size)
arrow_p2 = line.p1() + QtCore.QPointF(
math.sin(angle + math.pi - math.pi / 3.0) * arrow_size,
math.cos(angle + math.pi - math.pi / 3.0) * arrow_size)
self.arrow_head.clear()
for point in [line.p1(), arrow_p1, arrow_p2]:
self.arrow_head.append(point)
painter.drawLine(line)
painter.drawPolygon(self.arrow_head)
if self.isSelected():
painter.setPen(QtGui.QPen(color, 1, QtCore.Qt.DashLine))
line = QtCore.QLineF(line)
line.translate(0, 4.0)
painter.drawLine(line)
line.translate(0, -8.0)
painter.drawLine(line)
def paint(self, painter, option, widget=None):
if (self.myStartItem.collidesWithItem(self.myEndItem)):
return
myStartItem = self.myStartItem
myEndItem = self.myEndItem
myColor = self.myColor
myPen = self.pen()
myPen.setColor(self.myColor)
arrowSize = 20.0
painter.setPen(myPen)
painter.setBrush(self.myColor)
centerLine = QtCore.QLineF(myStartItem.pos(), myEndItem.pos())
endPolygon = myEndItem.polygon()
p1 = endPolygon.at(0) + myEndItem.pos()
intersectPoint = QtCore.QPointF()
for i in endPolygon:
p2 = i + myEndItem.pos()
polyLine = QtCore.QLineF(p1, p2)
intersectType, intersectPoint = polyLine.intersect(centerLine)
if intersectType == QtCore.QLineF.BoundedIntersection:
break
p1 = p2
self.setLine(QtCore.QLineF(intersectPoint, myStartItem.pos()))
line = self.line()
angle = math.acos(line.dx() / line.length())
if line.dy() >= 0:
angle = (math.pi * 2.0) - angle
arrowP1 = line.p1() + QtCore.QPointF(
math.sin(angle + math.pi / 3.0) * arrowSize,
math.cos(angle + math.pi / 3) * arrowSize)
arrowP2 = line.p1() + QtCore.QPointF(
math.sin(angle + math.pi - math.pi / 3.0) * arrowSize,
math.cos(angle + math.pi - math.pi / 3.0) * arrowSize)
self.arrowHead.clear()
for point in [line.p1(), arrowP1, arrowP2]:
self.arrowHead.append(point)
painter.drawLine(line)
painter.drawPolygon(self.arrowHead)
if self.isSelected():
painter.setPen(QtGui.QPen(myColor, 1, QtCore.Qt.DashLine))
myLine = QtCore.QLineF(line)
myLine.translate(0, 4.0)
painter.drawLine(myLine)
myLine.translate(0, -8.0)
painter.drawLine(myLine)
def paintEvent(self, ev):
painter = QtGui.QPainter(self)
painter.drawPixmap(self.outrect, self.bgpix, self.bgrect)
painter.setPen(QtCore.Qt.blue)
for i in range(self.ylen):
painter.drawLine(
QtCore.QLineF(0, self.ch * i, self.outrect.width(),
self.ch * i))
for j in range(self.xlen):
painter.drawLine(
QtCore.QLineF(self.cw * j, 0, self.cw * j,
self.outrect.height()))
painter.end()
def drawBackground(self, painter, rect):
background_brush = QtGui.QBrush(QtGui.QColor(255, 255, 255),
QtCore.Qt.SolidPattern)
painter.fillRect(rect, background_brush)
lines = []
for y in range(self.size + 1):
lines.append(
QtCore.QLineF(0, y * self.scale, self.size * self.scale,
y * self.scale))
for x in range(self.size + 1):
lines.append(
QtCore.QLineF(x * self.scale, 0, x * self.scale,
self.size * self.scale))
painter.drawLines(lines)
def _draw_grid(self, painter, rect, pen, grid_size):
lines = []
left = int(rect.left()) - (int(rect.left()) % grid_size)
top = int(rect.top()) - (int(rect.top()) % grid_size)
x = left
while x < rect.right():
x += grid_size
lines.append(QtCore.QLineF(x, rect.top(), x, rect.bottom()))
y = top
while y < rect.bottom():
y += grid_size
lines.append(QtCore.QLineF(rect.left(), y, rect.right(), y))
painter.setPen(pen)
painter.drawLines(lines)
def drawBackground(self, painter, rect):
painter.fillRect(rect, self._background_color)
left = int(rect.left()) - (int(rect.left()) % self._grid_size_fine)
top = int(rect.top()) - (int(rect.top()) % self._grid_size_fine)
# Draw horizontal fine lines
gridLines = []
painter.setPen(self._grid_pen_s)
y = float(top)
while y < float(rect.bottom()):
gridLines.append(QtCore.QLineF(rect.left(), y, rect.right(), y))
y += self._grid_size_fine
painter.drawLines(gridLines)
# Draw vertical fine lines
gridLines = []
painter.setPen(self._grid_pen_s)
x = float(left)
while x < float(rect.right()):
gridLines.append(QtCore.QLineF(x, rect.top(), x, rect.bottom()))
x += self._grid_size_fine
painter.drawLines(gridLines)
# Draw thick grid
left = int(rect.left()) - (int(rect.left()) % self._grid_size_course)
top = int(rect.top()) - (int(rect.top()) % self._grid_size_course)
# Draw vertical thick lines
gridLines = []
painter.setPen(self._grid_pen_l)
x = left
while x < rect.right():
gridLines.append(QtCore.QLineF(x, rect.top(), x, rect.bottom()))
x += self._grid_size_course
painter.drawLines(gridLines)
# Draw horizontal thick lines
gridLines = []
painter.setPen(self._grid_pen_l)
y = top
while y < rect.bottom():
gridLines.append(QtCore.QLineF(rect.left(), y, rect.right(), y))
y += self._grid_size_course
painter.drawLines(gridLines)
return super(View, self).drawBackground(painter, rect)
def mouseMoveEvent(self, mouseEvent):
if self.myMode == self.InsertLine and self.line:
newLine = QtCore.QLineF(self.line.line().p1(),
mouseEvent.scenePos())
self.line.setLine(newLine)
elif self.myMode == self.MoveItem:
super(DiagramScene, self).mouseMoveEvent(mouseEvent)
def setupGuides(self):
x = 0
y = 20
self.qtGuide1 = GuideCircle(QtCore.QRectF(x, y, 260, 260), -36, 342)
GuideLine(QtCore.QPointF(x + 240, y + 268), self.qtGuide1)
GuideLine(QtCore.QPointF(x + 265, y + 246), self.qtGuide1)
GuideLine(QtCore.QPointF(x + 158, y + 134), self.qtGuide1)
GuideLine(QtCore.QPointF(x + 184, y + 109), self.qtGuide1)
GuideLine(QtCore.QPointF(x + 160, y + 82), self.qtGuide1)
GuideLine(QtCore.QPointF(x + 77, y + 163), self.qtGuide1)
GuideLine(QtCore.QPointF(x + 100, y + 190), self.qtGuide1)
GuideLine(QtCore.QPointF(x + 132, y + 159), self.qtGuide1)
GuideLine(QtCore.QPointF(x + 188, y + 211), self.qtGuide1)
GuideCircle(QtCore.QRectF(x + 30, y + 30, 200, 200), -30, 336, GuideCircle.CW, self.qtGuide1)
GuideLine(QtCore.QPointF(x + 238, y + 201), self.qtGuide1)
y = 30
self.qtGuide2 = GuideCircle(QtCore.QRectF(x + 30, y + 30, 200, 200), 135, 270, GuideCircle.CCW)
GuideLine(QtCore.QPointF(x + 222, y + 38), self.qtGuide2)
GuideCircle(QtCore.QRectF(x, y, 260, 260), 135, 270, GuideCircle.CW, self.qtGuide2)
GuideLine(QtCore.QPointF(x + 59, y + 59), self.qtGuide2)
x = 115
y = 10
self.qtGuide3 = GuideLine(QtCore.QLineF(x, y, x + 30, y))
GuideLine(QtCore.QPointF(x + 30, y + 170), self.qtGuide3)
GuideLine(QtCore.QPointF(x, y + 170), self.qtGuide3)
GuideLine(QtCore.QPointF(x, y), self.qtGuide3)
self.qtGuide1.setFence(QtCore.QRectF(0, 0, 800, 600))
self.qtGuide2.setFence(QtCore.QRectF(0, 0, 800, 600))
self.qtGuide3.setFence(QtCore.QRectF(0, 0, 800, 600))
def paint(self, painter, options, widget):
brush = painter.brush()
brush.setStyle(QtCore.Qt.SolidPattern)
brush.setColor(QtGui.QColor(80, 80, 80, 255))
painter.setBrush(brush)
pen = painter.pen()
pen.setStyle(QtCore.Qt.SolidLine)
pen.setWidth(3)
pen.setColor(QtGui.QColor(0, 0, 0, 255))
if self.isSelected():
pen.setWidth(5)
pen.setColor(QtGui.QColor(70, 250, 230, 255))
painter.setPen(pen)
rect = self.rect()
painter.drawRoundedRect(rect, self.xRadius, self.yRadius)
iconSize = 16
pen.setColor(QtGui.QColor(0, 0, 0, 100))
pen.setWidth(2)
painter.setPen(pen)
painter.drawLine(
QtCore.QLineF(rect.left() + 6,
rect.top() + 20,
rect.right() - 6,
rect.top() + 20))
pen.setColor(QtGui.QColor(220, 220, 220, 255))
painter.setPen(pen)
painter.drawText(rect.left() + 25, rect.top() + 15, self.name)
painter.drawPixmap(self.rotateIconRect(), self._rotateIcon,
self._rotateIcon.rect())
painter.drawPixmap(rect.left() + 4,
rect.top() + 3, iconSize, iconSize, self._guideIcon)
def paint(self, painter, option, widget):
if not self.source() or not self.dest():
return
# Draw the line itself.
line = QtCore.QLineF(self.sourcePoint, self.destPoint)
if line.length() == 0.0:
return
painter.setPen(QtGui.QPen(QtCore.Qt.black, 1, QtCore.Qt.SolidLine, QtCore.Qt.RoundCap, QtCore.Qt.RoundJoin))
painter.drawLine(line)
# Draw the arrows if there's enough room.
angle = math.acos(line.dx() / line.length())
if line.dy() >= 0:
angle = Edge.TwoPi - angle
sourceArrowP1 = self.sourcePoint + QtCore.QPointF(math.sin(angle + Edge.Pi / 3) * self.arrowSize,
math.cos(angle + Edge.Pi / 3) * self.arrowSize)
sourceArrowP2 = self.sourcePoint + QtCore.QPointF(math.sin(angle + Edge.Pi - Edge.Pi / 3) * self.arrowSize,
math.cos(angle + Edge.Pi - Edge.Pi / 3) * self.arrowSize)
destArrowP1 = self.destPoint + QtCore.QPointF(math.sin(angle - Edge.Pi / 3) * self.arrowSize,
math.cos(angle - Edge.Pi / 3) * self.arrowSize)
destArrowP2 = self.destPoint + QtCore.QPointF(math.sin(angle - Edge.Pi + Edge.Pi / 3) * self.arrowSize,
math.cos(angle - Edge.Pi + Edge.Pi / 3) * self.arrowSize)
painter.setBrush(QtCore.Qt.black)
painter.drawPolygon(QtGui.QPolygonF([line.p1(), sourceArrowP1, sourceArrowP2]))
painter.drawPolygon(QtGui.QPolygonF([line.p2(), destArrowP1, destArrowP2]))
def __init__(
self,
image: ScaledImageItem,
data: np.ndarray,
pen: QtGui.QPen = None,
font: QtGui.QFont = None,
parent: QtWidgets.QGraphicsItem = None,
):
super().__init__(image, parent)
if pen is None:
pen = QtGui.QPen(QtCore.Qt.white, 2.0, QtCore.Qt.DotLine)
pen.setCosmetic(True)
pen.setCapStyle(QtCore.Qt.RoundCap)
if font is None:
font = QtGui.QFont()
self.image_data = data
self.sliced: Optional[np.ndarray] = None
self.pen = pen
self.font = font
self.line = QtCore.QLineF()
self.poly = QtGui.QPolygonF()
self.action_copy_to_clipboard = qAction(
"insert-text",
"Copy To Clipboard",
"Copy slice values to the clipboard.",
self.actionCopyToClipboard,
)
def __init__(
self,
image: ScaledImageItem,
pen: QtGui.QPen = None,
font: QtGui.QFont = None,
unit: str = "μm",
parent: QtWidgets.QGraphicsItem = None,
):
super().__init__(image, None, parent)
if pen is None:
pen = QtGui.QPen(QtCore.Qt.white, 2.0)
pen.setCosmetic(True)
pen.setStyle(QtCore.Qt.DashLine)
pen.setCapStyle(QtCore.Qt.RoundCap)
if font is None:
font = QtGui.QFont()
self.pen = pen
self.font = font
self.text = ""
self.unit = unit
self.line = QtCore.QLineF()
def move(self, item, dest, moveSpeed):
walkLine = QtCore.QLineF(item.getGuidedPos(), dest)
if moveSpeed >= 0 and walkLine.length() > moveSpeed:
# The item is too far away from it's destination point so we move
# it towards it instead.
dx = walkLine.dx()
dy = walkLine.dy()
if abs(dx) > abs(dy):
# Walk along x-axis.
if dx != 0:
d = moveSpeed * dy / abs(dx)
if dx > 0:
s = moveSpeed
else:
s = -moveSpeed
dest.setX(item.getGuidedPos().x() + s)
dest.setY(item.getGuidedPos().y() + d)
else:
# Walk along y-axis.
if dy != 0:
d = moveSpeed * dx / abs(dy)
if dy > 0:
s = moveSpeed
else:
s = -moveSpeed
dest.setX(item.getGuidedPos().x() + d)
dest.setY(item.getGuidedPos().y() + s)
item.setGuidedPos(dest)
def mousePressEvent(self, mouseEvent):
if (mouseEvent.button() != QtCore.Qt.LeftButton):
return
if self.myMode == self.InsertItem:
item = DiagramItem(self.myItemType, self.myItemMenu)
item.setBrush(self.myItemColor)
self.addItem(item)
item.setPos(mouseEvent.scenePos())
self.itemInserted.emit(item)
elif self.myMode == self.InsertLine:
self.line = QtWidgets.QGraphicsLineItem(QtCore.QLineF(mouseEvent.scenePos(),
mouseEvent.scenePos()))
self.line.setPen(QtGui.QPen(self.myLineColor, 2))
self.addItem(self.line)
elif self.myMode == self.InsertText:
textItem = DiagramTextItem()
textItem.setFont(self.myFont)
textItem.setTextInteractionFlags(QtCore.Qt.TextEditorInteraction)
textItem.setZValue(1000.0)
textItem.lostFocus.connect(self.editorLostFocus)
textItem.selectedChange.connect(self.itemSelected)
self.addItem(textItem)
textItem.setDefaultTextColor(self.myTextColor)
textItem.setPos(mouseEvent.scenePos())
self.textInserted.emit(textItem)
super(DiagramScene, self).mousePressEvent(mouseEvent)
def update(self):
super().update()
start_pos = self.start.mapToScene(self.start.boundingRect().center())
end_pos = self.end.mapToScene(self.end.boundingRect().center())
self.setPos(start_pos)
start = QtCore.QPointF(0, 0)
end = end_pos-start_pos
line = QtCore.QLineF(start, end)
normal = line.unitVector().normalVector() # normal for width
normal = 2 * QtCore.QPointF(
normal.x2()-normal.x1(),
normal.y2()-normal.y1())
shape = QtGui.QPainterPath()
rect = QtGui.QPolygonF([
start-normal,
start+normal,
end+normal,
end-normal])
shape.addPolygon(rect)
shape.closeSubpath()
self._line = line
self._shape = shape
def fromDict(d):
"""
Initializes object from a dict (ideally, a dict previously created with `toDict`)
"""
# Extract data
name = d["Name"]
args = d["Args"]
penColor = d["PenColor"]
penWidth = d["PenWidth"]
countData = d["CountData"]
# Setup pen
pen = QtGui.QPen(penColor) # Does this color need to be a QColor?
pen.setWidth(penWidth)
if name == "Rect":
geom = QtCore.QRectF(*args)
elif name == "Ellipse":
geom = QtCore.QRectF(*args)
elif name == "Line":
geom = QtCore.QLineF(*args)
else:
raise ValueError(f"Unrecognized geometry name: {name}")
return DrawingData(name, geom, pen, CountData.fromDict(countData))
def adjust(self):
self.selection_polygon = QtGui.QPolygonF()
if not self.source() or not self.target():
return
self.line = QtCore.QLineF(
self.mapFromItem(self.source(),
self.source().center()),
self.mapFromItem(self.target(),
self.target().center()))
length = self.line.length()
if length == 0:
return
self.prepareGeometryChange()
self.source_point = self.line.p1()
self.target_point = self.line.p2()
selection_offset = 20
rad_angle = self.line.angle() * math.pi / 180
dx = selection_offset * math.sin(rad_angle)
dy = selection_offset * math.cos(rad_angle)
offset1 = QtCore.QPointF(dx, dy)
offset2 = QtCore.QPointF(-dx, -dy)
self.selection_polygon.append(self.line.p1() + offset1)
self.selection_polygon.append(self.line.p1() + offset2)
self.selection_polygon.append(self.line.p2() + offset2)
self.selection_polygon.append(self.line.p2() + offset1)
self.selection_shape = QtGui.QPainterPath()
self.selection_shape.addPolygon(self.selection_polygon)
def __init__(self, a, b):
super(Linea, self).__init__()
# Inicializacion de los elementos que aparecen en la clase
self.a = a
self.b = b
XPuntoMedio = (self.a.xPos + self.b.xPos) / 2
YPuntoMedio = (self.a.yPos + self.b.yPos) / 2
co1x = self.a.xPos # Coordenada 'x' del humano 1.
co1y = self.a.yPos # Coordenada 'y' del humano 1.
co1_2x = self.b.xPos # Coordenada 'x' del humano 2.
co1_2y = self.b.yPos # Coordenada 'y' del humano 2.
s1 = co1x - co1_2x
s2 = co1y - co1_2y
d = math.sqrt(s1 * s1 +
s2 * s2) # Distancia existente entre las dos coordenadas
self.length = d # Asignacion de la distantcia.
self.text = QtGui.QStaticText(f"{self.length/100:.2f}" + ' m') # Texto
self.puntoMedio = QtCore.QPointF(
XPuntoMedio, YPuntoMedio) # Asignación punto medio.
self.BoundingRect = QtCore.QRectF(-10, -10, 20, 20)
punto1 = QtCore.QPointF(co1x, co1y) # Asignación punto1.
punto2 = QtCore.QPointF(co1_2x, co1_2y) # Asignacion punto2
self.lineaNueva = QtCore.QLineF(
punto1, punto2) # Asignacion linea de union de los humanos
def draw(target, canvas_size, spacing, scale):
painter = QtGui.QPainter(target)
lines = []
for x in range(spacing, canvas_size.width(), spacing):
lines.append(QtCore.QLineF(x*scale, 0, x*scale, canvas_size.height()*scale))
for y in range(spacing, canvas_size.height(), spacing):
lines.append(QtCore.QLineF(0, y*scale, canvas_size.width()*scale, y*scale))
pen = QtGui.QPen()
pen.setWidth(0)
pen.setColor(QtGui.QColor(128, 128, 128, 128))
painter.setPen(pen)
painter.drawLines(lines)
painter.end()
def drawBackground(self, painter, rect):
if not self._gridOn:
super(ForgeNodeScene, self).drawBackground(painter, rect)
return
painter.setWorldMatrixEnabled(True)
left = int(rect.left()) - (int(rect.left()) % self._gridMinor)
top = int(rect.top()) - (int(rect.top()) % self._gridMinor)
minorLinesY = []
majorLinesY = []
for y in xrange(left, int(rect.right()), self._gridMinor):
if y % self._gridMajor == 0:
majorLinesY.append(
QtCore.QLineF(y, rect.top(), y, rect.bottom()))
else:
minorLinesY.append(
QtCore.QLineF(y, rect.top(), y, rect.bottom()))
minorLinesX = []
majorLinesX = []
for x in xrange(top, int(rect.bottom()), self._gridMinor):
if x % self._gridMajor == 0:
majorLinesX.append(
QtCore.QLineF(rect.left(), x, rect.right(), x))
else:
minorLinesX.append(
QtCore.QLineF(rect.left(), x, rect.right(), x))
coordPen = QtGui.QPen()
coordPen.setStyle(QtCore.Qt.SolidLine)
coordPen.setWidth(2)
coordPen.setColor(GRID_COLOR_ACCENT)
painter.setPen(coordPen)
painter.drawLines(majorLinesY)
painter.drawLines(majorLinesX)
coordPen.setWidth(1)
coordPen.setColor(GRID_COLOR)
painter.setPen(coordPen)
painter.drawLines(minorLinesY)
painter.drawLines(minorLinesX)
def draw(target, spacing):
painter = QtGui.QPainter(target)
cr = target.contentsRect()
canvas_size = target.window().canvas_size
scale = target.window().effective_canvas_scale()
lines = []
for x in range(spacing, canvas_size.width(), spacing):
lines.append(QtCore.QLineF(x*scale, 0, x*scale, canvas_size.height()*scale))
for y in range(spacing, canvas_size.height(), spacing):
lines.append(QtCore.QLineF(0, y*scale, canvas_size.width()*scale, y*scale))
pen = QtGui.QPen()
pen.setWidth(0)
pen.setColor(QtGui.QColor(0, 0, 0, 128))
painter.setPen(pen)
painter.drawLines(lines)
def __init__(self):
QtWidgets.QGraphicsView.__init__(self)
self.setWindowTitle("QGraphicsView")
scene = QtWidgets.QGraphicsScene(self)
scene.setSceneRect(0, 0, 160, 120)
self.setScene(scene)
line = QtCore.QLineF(10, 10, 100, 100)
node = QtWidgets.QGraphicsLineItem(line)
scene.addItem(node)
def distanceToRect(pos: QtCore.QPoint, rect: QtCore.QRect):
"""
Finds the distance from a given point to the rectangle.
"""
# Intersection point on rectangle
intersection = nearestPosOnRect(pos, rect)
# Line from original point to intersection
line = QtCore.QLineF(pos, intersection)
return line.length()
def _update_line(self):
"""Resolve start and end point from current source and target position
:return:s: A Qt line object
:rtype: :class:`QtCore.QLineF`
"""
start = QtCore.QPointF(0, 0)
end = self._target_slot.center - self._source_slot.center
self._line = QtCore.QLineF(start, end)
def _update_line(self):
"""Re-implement function that updates edge line definition
"""
start = QtCore.QPoint(0, 0)
if self._source_slot.family & NodeSlot.OUTPUT:
end = self._mouse_pos - self._source_slot.center
else:
end = self._source_slot.center - self._mouse_pos
self._line = QtCore.QLineF(start, end)
def draw_path(self, start_port, end_port, cursor_pos=None):
"""
Draws the path between ports.
Args:
start_port (PortItem): port used to draw the starting point.
end_port (PortItem): port used to draw the end point.
cursor_pos (QtCore.QPointF): cursor position if specified this
will be the draw end point.
"""
if not start_port:
return
offset = (start_port.boundingRect().width() / 2)
pos1 = start_port.scenePos()
pos1.setX(pos1.x() + offset)
pos1.setY(pos1.y() + offset)
if cursor_pos:
pos2 = cursor_pos
elif end_port:
offset = start_port.boundingRect().width() / 2
pos2 = end_port.scenePos()
pos2.setX(pos2.x() + offset)
pos2.setY(pos2.y() + offset)
else:
return
line = QtCore.QLineF(pos1, pos2)
path = QtGui.QPainterPath()
path.moveTo(line.x1(), line.y1())
if self.viewer_pipe_layout() == PIPE_LAYOUT_STRAIGHT:
path.lineTo(pos2)
self.setPath(path)
return
ctr_offset_x1, ctr_offset_x2 = pos1.x(), pos2.x()
tangent = ctr_offset_x1 - ctr_offset_x2
tangent = (tangent * -1) if tangent < 0 else tangent
max_width = start_port.node.boundingRect().width() / 2
tangent = max_width if tangent > max_width else tangent
if start_port.port_type == IN_PORT:
ctr_offset_x1 -= tangent
ctr_offset_x2 += tangent
elif start_port.port_type == OUT_PORT:
ctr_offset_x1 += tangent
ctr_offset_x2 -= tangent
ctr_point1 = QtCore.QPointF(ctr_offset_x1, pos1.y())
ctr_point2 = QtCore.QPointF(ctr_offset_x2, pos2.y())
path.cubicTo(ctr_point1, ctr_point2, pos2)
self.setPath(path)
def mousePressEvent(self, event):
item = self.scene().itemAt(self.mapToScene(event.pos()), QtGui.QTransform())
if event.button() == QtCore.Qt.RightButton:
event.ignore()
elif item and item.type() == StepPort.Type:
centre = item.boundingRect().center()
self._connectSourceNode = item
self._connectLine = ArrowLine(QtCore.QLineF(item.mapToScene(centre),
self.mapToScene(event.pos())))
self.scene().addItem(self._connectLine)
else:
QtWidgets.QGraphicsView.mousePressEvent(self, event)
self._selectionStartPos = event.pos()
def boundingRect(self) -> QtCore.QRectF:
view = next(iter(self.scene().views()))
angle = self.line.angle()
fm = QtGui.QFontMetrics(self.font)
text = fm.boundingRect(self.text)
text = view.mapToScene(text).boundingRect()
# Corners above the text height
n1 = QtCore.QLineF(self.line.p2(), self.line.p1()).normalVector()
n2 = QtCore.QLineF(self.line.p1(), self.line.p2()).normalVector()
if 90 < angle < 270:
n1.setLength(text.height())
n2.setLength(-text.height())
else:
n1.setLength(-text.height())
n2.setLength(text.height())
poly = QtGui.QPolygonF([self.line.p1(), n1.p2(), n2.p2(), self.line.p2()])
w = view.mapToScene(QtCore.QRect(0, 0, 5, 1)).boundingRect().width()
return poly.boundingRect().marginsAdded(QtCore.QMarginsF(w, w, w, w))
def animate(self):
if not self.targetPos.isNull():
displacement = QtCore.QLineF(self.pos, self.targetPos)
newPosition = displacement.pointAt(0.25)
if displacement.length() <= 1.0:
self.pos = self.targetPos
self.targetPos = QtCore.QPointF()
else:
self.pos = newPosition
return True
return False
