def updatePath(self):
axeSize = self.size
yZero = self.yZero
try:
X = []
for item in self.fixedPoints:
X.extend([item.B.x() + item.x(), item.C.x() + item.x()])
X = np.array(X)
Y = np.array(
[-(item.A.y() + item.y())
for item in self.fixedPoints]) + yZero
T = displacementSpline(X,
Y,
self.xCoords,
clippingInterval=[-self.scene().axeSize, 0],
period=self.period)
self.spline = [
QPointF(x, y + yZero) for x, y in zip(self.xCoords, -T)
] # scene coord.
# build path
polygon = QPolygonF(self.spline)
qpp = QPainterPath()
qpp.addPolygon(polygon)
# stroke path
stroker = QPainterPathStroker()
stroker.setWidth(self.strokeWidth)
mboundingPath = stroker.createStroke(qpp)
self.setPath(mboundingPath)
except ValueError:
pass
class Drawer(QWidget):
newPoint = Signal(QPoint)
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.path = QPainterPath()
def paintEvent(self, event):
kist = QPen()
kist.setColor(QColor('Yellow'))
kist.setWidth(2)
kist.setJoinStyle(Qt.RoundJoin)
painter = QPainter(self)
painter.setPen(kist)
painter.drawPath(self.path)
def mousePressEvent(self, event):
self.path.moveTo(event.pos())
self.update()
def mouseMoveEvent(self, event):
self.path.lineTo(event.pos())
self.newPoint.emit(event.pos())
self.update()
def sizeHint(self):
return QSize(self.size().width() * 2, self.size().height() // 3)
def group_object_pixmap(self, object_class_name):
if object_class_name in self.group_obj_pixmap_cache:
return self.group_obj_pixmap_cache[object_class_name]
object_pixmap = self.object_pixmap(object_class_name)
size = object_pixmap.size()
width, height = size.width(), size.height()
radius = width / 8
pen_width = width / 32
margin = width / 16
pen = QPen(QApplication.palette().shadow().color())
pen.setWidth(pen_width)
path = QPainterPath()
path.addRoundedRect(0, 0, width, height, radius, radius)
pixmap = QPixmap(size)
pixmap.fill(Qt.transparent)
painter = QPainter(pixmap)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.fillPath(path, QApplication.palette().window())
painter.setPen(pen)
painter.drawRoundedRect(pixmap.rect().adjusted(pen_width, pen_width, -pen_width, -pen_width), radius, radius)
painter.drawPixmap(
pixmap.rect().adjusted(margin, margin, -width / 2, -height / 2), object_pixmap, object_pixmap.rect()
)
painter.drawPixmap(
pixmap.rect().adjusted(width / 2, margin, -margin, -height / 2), object_pixmap, object_pixmap.rect()
)
painter.drawPixmap(
pixmap.rect().adjusted(width / 2, height / 2, -margin, -margin), object_pixmap, object_pixmap.rect()
)
painter.drawPixmap(
pixmap.rect().adjusted(margin, height / 2, -width / 2, -margin), object_pixmap, object_pixmap.rect()
)
painter.end()
self.group_obj_pixmap_cache[object_class_name] = pixmap
return pixmap
def _create_block_item(self):
"""
Create the block background and border.
"""
self._block_item = QPainterPath()
self._block_item.addRect(0, 0, self.width, self.height)
def paint(self, painter, *args, **kwargs):
margin = QMarginsF(3, 0, 3, 0)
box = self.boundingRect().marginsAdded(margin)
path = QPainterPath()
path.addRoundedRect(box, 5, 5)
painter.fillPath(path, QColor(*self.background_color))
super().paint(painter, *args, **kwargs)
def __init__(self,
x,
y,
color=Qt.white,
fillColor=None,
persistent=False,
rect=None,
parentItem=None):
super().__init__(parent=parentItem)
self.color = color
self.setAcceptHoverEvents(True)
self.persistent = persistent
self.rect = rect
if self.rect is not None:
self.xmin, self.xmax, self.ymin, self.ymax = rect.left(
), rect.right(), rect.top(), rect.bottom()
x = min(max(x, self.xmin), self.xmax)
y = min(max(y, self.ymin), self.ymax)
self.setPos(QPointF(x, y))
self.clicked = False
self.setPen(QPen(color, 2))
# filling brush
if fillColor is not None:
self.setBrush(QBrush(fillColor))
qpp = QPainterPath()
# coordinates are relative to activePoint
qpp.addEllipse(-4, -4, 8, 8)
self.setPath(qpp)
def _get_dst_offset(self, c1):
if not self.dst_connector:
guide_path = QPainterPath(self.src_center)
guide_path.quadTo(c1, self.dst_center)
line = self._get_joint_line(guide_path).unitVector()
return QPointF(-line.dx(), -line.dy())
return {"left": QPointF(-1, 0), "bottom": QPointF(0, 1), "right": QPointF(1, 0)}[self.dst_connector.position]
def __init__(self, size, fixedPoints=None, parentItem=None):
"""
Inits a cubicSpline with an empty set of control points and
an empty curve
@param size: initial path size
@type size: int
@param parentItem:
@type parentItem: object
"""
self.curveChanged = baseSignal_No() # TODO added 5/11/18 validate
super().__init__()
if fixedPoints is None:
fixedPoints = []
self.setParentItem(parentItem)
qpp = QPainterPath()
self.size = size
# initial curve : diagonal
qpp.lineTo(QPoint(size, -size))
# stroke curve
stroker = QPainterPathStroker()
stroker.setWidth(self.strokeWidth)
self.mboundingPath = stroker.createStroke(qpp)
self.setPath(self.mboundingPath)
self.clicked = False
#self.selected = False
self.setVisible(False)
self.fixedPoints = fixedPoints
# self.spline is the list of QPointF instances to plot (scene coordinates)
self.spline = []
# self.LUTXY is the 1D LUT : range 0..255 --> 0..255, type ndarray, dtype=int, size=256
self.LUTXY = np.arange(256)
self.channel = channelValues.RGB
self.histImg = None
# set item pen
self.setPen(QPen(QBrush(self.brushColor), self.penWidth))
def drawOverlay(self, painter: QPainter) -> None:
if not self.__showOverlay: return
radius: int = 80
painter.save()
painter.setPen(Qt.NoPen)
smallCircle: QPainterPath = QPainterPath()
bigCircle: QPainterPath = QPainterPath()
radius -= 1
smallCircle.addEllipse(-radius, -radius, radius * 2, radius * 2)
radius *= 2
bigCircle.addEllipse(-radius, -radius + 140, radius * 2, radius * 2)
# 高光的形状为小圆扣掉大圆的部分
highlight: QPainterPath = smallCircle - bigCircle
linearGradient: QLinearGradient = QLinearGradient(0, -radius / 2, 0, 0)
self.__overlayColor.setAlpha(100)
linearGradient.setColorAt(0.0, self.__overlayColor)
self.__overlayColor.setAlpha(30)
linearGradient.setColorAt(1.0, self.__overlayColor)
painter.setBrush(linearGradient)
painter.rotate(-20)
painter.drawPath(highlight)
painter.restore()
def __init__(self):
super(Edge, self).__init__()
self.setZValue(-1) # Draw edges behind nodes
self.setFlag(self.ItemIsSelectable)
self._source: Union[Output, None] = None
"""An edge is drawn from its source to its target. Node's output is edge's source.
This variable represents current source as a variable of type Output.
"""
self._target: Union[Input, None] = None
"""An edge is drawn from its source to its target. Node's input is edge's target.
This variable represents current target as a variable of type Input.
"""
self._source_pos: Union[QPointF, None] = None
"""An edge is drawn from its source to its target. Node's output is edge's source.
This variable represents current source coordinates in scene pixels.
"""
self._target_pos: Union[QPointF, None] = None
"""An edge is drawn from its source to its target. Node's input is edge's target.
This variable represents current target coordinates in scene pixels.
"""
self._path = QPainterPath()
self._pen = QPen()
self.styleChange()
self.paletteChange()
def paint(self, painter, option, widget): # pylint: disable=unused-argument
lod = option.levelOfDetailFromTransform(painter.worldTransform())
should_omit_text = lod < QGraphBlock.MINIMUM_DETAIL_LEVEL
painter.setBrush(self._config.disasm_view_node_shadow_color)
painter.setPen(self._config.disasm_view_node_shadow_color)
shadow_path = QPainterPath(self._block_item)
shadow_path.translate(self.SHADOW_OFFSET_X, self.SHADOW_OFFSET_Y)
painter.drawPath(shadow_path)
# background of the node
painter.setBrush(self._calc_backcolor(should_omit_text))
if self.infodock.is_block_selected(self.addr):
painter.setPen(
QPen(self._config.disasm_view_selected_node_border_color, 2.5))
else:
painter.setPen(
QPen(self._config.disasm_view_node_border_color, 1.5))
self._block_item_obj = painter.drawPath(self._block_item)
# content drawing is handled by qt since children are actual child widgets
# if we are too far zoomed out, do not draw the text
if self._objects_are_hidden != should_omit_text:
self._set_block_objects_visibility(not should_omit_text)
view = self.scene.parent()
if view.is_extra_render_pass:
self._objects_are_temporarily_hidden = should_omit_text
else:
self._objects_are_hidden = should_omit_text
# extra content
self.workspace.plugins.draw_block(self, painter)
def draw_NI_minimalistic(painter, c, w, h, bounding_rect):
"""
:param painter: painter from paint event
:param c: color
:param w: width
:param h: height
:param bounding_rect: NodeInstance's bounding rect
"""
path = QPainterPath()
path.moveTo(-w / 2, 0)
path.cubicTo(-w / 2, -h / 2, -w / 2, -h / 2, 0, -h / 2)
path.cubicTo(+w / 2, -h / 2, +w / 2, -h / 2, +w / 2, 0)
path.cubicTo(+w / 2, +h / 2, +w / 2, +h / 2, 0, +h / 2)
path.cubicTo(-w / 2, +h / 2, -w / 2, +h / 2, -w / 2, 0)
path.closeSubpath()
body_gradient = QLinearGradient(bounding_rect.bottomLeft(),
bounding_rect.topRight())
body_gradient.setColorAt(0, QColor(c.red(), c.green(), c.blue(), 150))
body_gradient.setColorAt(1, QColor(c.red(), c.green(), c.blue(), 80))
painter.setBrush(body_gradient)
painter.setPen(QPen(QColor(30, 43, 48)))
painter.drawPath(path)
def __init__(self, edge, parent=None):
super().__init__(parent)
self.edge = edge
self.rect = None
self._start = QPointF(*self.edge.coordinates[0])
self.coords = [self.create_point(c) for c in self.edge.coordinates]
self.end = self.coords[-1]
if self.edge.sort == EdgeSort.BACK_EDGE:
# it's a back edge
# Honey
self.color = QColor(0xf9, 0xd5, 0x77)
elif self.edge.sort == EdgeSort.TRUE_BRANCH:
# True branch
# Aqar
self.color = QColor(0x79, 0xcc, 0xcd)
elif self.edge.sort == EdgeSort.FALSE_BRANCH:
# False branch
# Tomato
self.color = QColor(0xf1, 0x66, 0x64)
else:
# Dark Gray
self.color = QColor(0x56, 0x5a, 0x5c)
self.arrow = [
QPointF(self.end.x() - 3, self.end.y()),
QPointF(self.end.x() + 3, self.end.y()),
QPointF(self.end.x(),
self.end.y() + 6)
]
#self.setCacheMode(QGraphicsItem.DeviceCoordinateCache)
path = QPainterPath(self.coords[0])
for c in self.coords[1:] + self.arrow:
path.lineTo(c)
self.path = path
def paintEvent(self, event):
painter = QPainter(self)
painter.save()
path = QPainterPath()
painter.setFont(self.font)
painter.setRenderHint(QPainter.Antialiasing)
pen = QPen(QColor(0, 0, 0, 230))
pen_width = 3
pen.setWidth(pen_width)
len = self.metrics.width(self.txt)
w = self.width()
px = (len - w) / 2
if px < 0:
px = -px
py = (self.height() - self.metrics.height()) / 2 + self.metrics.ascent()
if py < 0:
py = -py
path.addText(px + 2, py + 2, self.font, self.txt)
painter.strokePath(path, pen)
painter.drawPath(path)
painter.fillPath(path, QBrush(self.color))
painter.restore()
def __init__(self, x, y, persistent=False, rect=None, parentItem=None):
"""
Interactive control point for the scene current spline.
Persistent activePoints cannot be removed
by mouse click (default is non persistent). If rect is not None,
the moves of the point are restricted to rect.
@param x: initial x-coordinate
@type x: float
@param y: initial y-coordinate
@type y: float
@param persistent: persistent flag
@type persistent: boolean
@param parentItem:
@type parentItem: object
"""
super(activePoint, self).__init__()
self.tangent = None # link to tangent : used only by qudratic spline
self.setAcceptHoverEvents(True)
self.setParentItem(parentItem)
self.persistent = persistent
self.rect = rect
if self.rect is not None:
self.xmin, self.xmax, self.ymin, self.ymax = rect.left(
), rect.right(), rect.top(), rect.bottom()
x = min(max(x, self.xmin), self.xmax)
y = min(max(y, self.ymin), self.ymax)
self.setPos(QPointF(x, y))
self.clicked = False
self.setPen(QPen(QColor(255, 255, 255), 2))
qpp = QPainterPath()
# coordinates are relative to activePoint
qpp.addEllipse(-4, -4, 8, 8)
self.setPath(qpp)
def drawValue(self, p, baseRect, value, arcLength):
# nothing to draw
if value == self.min:
return
# for Line style
if self.barStyle == self.StyleLine:
p.setPen(
QPen(self.palette().highlight().color(), self.dataPenWidth))
p.setBrush(Qt.NoBrush)
p.drawArc(
baseRect.adjusted(self.outlinePenWidth / 2,
self.outlinePenWidth / 2,
-self.outlinePenWidth / 2,
-self.outlinePenWidth / 2),
self.nullPosition * 16, -arcLength * 16)
return
# for Pie and Donut styles
dataPath = QPainterPath()
dataPath.setFillRule(Qt.WindingFill)
# pie segment outer
dataPath.moveTo(baseRect.center())
dataPath.arcTo(baseRect, self.nullPosition, -arcLength)
dataPath.lineTo(baseRect.center())
p.setBrush(self.palette().highlight())
p.setBrush(QColor(255, 255, 255, 255 * 0.3))
# pen = QtGui.QPen(self.palette().shadow().color(), self.dataPenWidth)
pen = QPen(self.palette().shadow().color(), -1)
p.setPen(pen)
p.drawPath(dataPath)
def paintEvent(self, event: QPaintEvent):
super().paintEvent(event)
if self._viewport_anchoring_scheduled:
self._anchor_viewport()
self._viewport_anchoring_scheduled = False
painter = QPainter(self.viewport())
painter.setRenderHint(QPainter.Antialiasing)
painter.setBrush(QColor(123, 184, 234))
painter.setPen(QPen(Qt.white, 0.5))
scale_text = f'{self._cur_scale * 100:.0f}%'
scale_text_bounding_rect = self._scale_font_metrics.boundingRect(
scale_text)
viewport_rect = self.viewport().rect()
# Align the scale text to (Qt.AlignHCenter | Qt.AlignBottom)
pad = 2
self._scale_text_rect = QRect(viewport_rect.width() / 2 - scale_text_bounding_rect.width() / 2,
viewport_rect.height() - scale_text_bounding_rect.height() - 6,
scale_text_bounding_rect.width(), scale_text_bounding_rect.height())\
.adjusted(-pad, -pad, pad, pad) # add pads to update when scrolling without artifacts
# Use QPainterPath to draw text with outline
path = QPainterPath()
path.addText(self._scale_text_rect.bottomLeft(), self._scale_font,
scale_text)
painter.drawPath(path)
def __init__(self, edge, disasm_view, infodock, parent=None):
super().__init__(parent)
self.edge = edge
self.disasm_view = disasm_view
self.infodock = infodock
self.rect = None
self._start = QPointF(*self.edge.coordinates[0])
self.coords = [self.create_point(c) for c in self.edge.coordinates]
self.end = self.coords[-1]
self.color = EDGE_COLORS.get(self.edge.sort,
EDGE_COLORS[EdgeSort.DIRECT_JUMP])
self.arrow = [
QPointF(self.end.x() - 3, self.end.y()),
QPointF(self.end.x() + 3, self.end.y()),
QPointF(self.end.x(),
self.end.y() + 6)
]
self.style = EDGE_STYLES.get(self.edge.sort,
EDGE_STYLES[EdgeSort.DIRECT_JUMP])
#self.setCacheMode(QGraphicsItem.DeviceCoordinateCache)
path = QPainterPath(self.coords[0])
for c in self.coords[1:] + self.arrow:
path.lineTo(c)
self.path = path
self._hovered = False
self.setAcceptHoverEvents(True)
def paint(self, painter, option, widget):
path = QPainterPath()
path.addRoundedRect(self.rect, 5, 5)
painter.setBrush(QColor(255, 255, 255))
painter.drawPath(path)
painter.drawText(self.text_rect, self.text)
def update(self):
qpp = QPainterPath()
trans = QPointF(-4, -4)
# coordinates are relative to activeTriangle
for p in [self.A, self.B, self.C]:
qpp.addEllipse(p + trans, 4, 4)
self.setPath(qpp)
super().update()
def test_text(self, p, opd):
font = QFont()
path = QPainterPath()
path.addText(0, 0, font, "T")
p.drawPath(path)
lines = opd.getOutlines()
assert len(lines) == 1
def _generate_path(coord):
path = QPainterPath()
path.moveTo(*coord[0])
path.lineTo(*coord[1])
path.lineTo(*coord[2])
path.lineTo(*coord[3])
path.closeSubpath()
return path
def shape(self):
frame_corner_radius = self.style().pixelMetric(
Style.NodeFrameCornerRadius)
path = QPainterPath()
path.addRoundedRect(QRectF(QPointF(0, 0), self.size()),
frame_corner_radius, frame_corner_radius)
return path
def _draw_wire(self, painter, line):
p = QPen(Qt.black, 8, Qt.PenStyle.SolidLine, Qt.PenCapStyle.RoundCap)
path = QPainterPath(line.p1())
path.lineTo(line.p2())
stroker = QPainterPathStroker(p)
stroke = stroker.createStroke(path)
painter.setPen(QPen(Qt.black, 2))
painter.fillPath(stroke, Qt.white)
painter.drawPath(stroke)
def updatePath(self, calculate=True):
"""
Calculates (if calculate=true) and displays the spline.
Called by activePoint and activeTangent mouse event
@param calculate:
@type calculate: bool
"""
# calculate the array of slopes
d = [
item.controlPoint - item.contactPoint
for item in self.fixedTangents
]
d1 = -np.array(list(map(lambda a: a.y(), d)))
d2 = np.array(list(map(lambda a: a.x(), d)))
d = d1 / d2
# add boundary points if needed
X = [item.x() for item in self.fixedPoints]
Y = [item.y() for item in self.fixedPoints]
X0, X1 = X[0], X[-1]
Y0, Y1 = Y[0], Y[-1]
t = (Y1 - Y0) / (X1 - X0)
Y2 = Y0 - X0 * t
Y3 = Y0 + (self.size - X0) * t
d = d.tolist()
if X[0] > 0.0:
X.insert(0, 0.0)
Y.insert(0, Y2)
d.insert(0, t)
if X[-1] < self.size:
X.append(self.size)
Y.append(Y3)
d.append(t)
d = np.array(d)
try:
if calculate:
T = interpolationQuadSpline(
np.array(X) / self.size, -np.array(Y) / self.size,
d) * self.size
self.spline = [
QPointF(x, y)
for x, y in zip(np.arange(256) * (self.size / 255.0), -T)
]
for P in self.spline:
if P.x() < X0:
P.setY(Y0)
elif P.x() > X1:
P.setY(Y1)
polygon = QPolygonF(self.spline)
qpp = QPainterPath()
qpp.addPolygon(polygon)
# stroke path
stroker = QPainterPathStroker()
stroker.setWidth(self.strokeWidth)
mboundingPath = stroker.createStroke(qpp)
self.setPath(mboundingPath)
except Exception as e:
print(str(e))
def paint(self, painter, *args, **kwargs):
if self.hovered:
margin = QMarginsF(7, 5, 7, 5)
else:
margin = QMarginsF(3, 0, 3, 0)
box = self.boundingRect().marginsAdded(margin)
path = QPainterPath()
path.addRoundedRect(box, 5, 5)
painter.fillPath(path, self.background_color)
super().paint(painter, *args, **kwargs)
def addArrow(self, p1, p2, color=BLACK):
p5.stroke(color)
self.addLine(p1, p2)
to_int = (int(p1[0]), int(p1[1]), int(p2[0]), int(p2[1]))
if to_int in ARROW_CACHE:
arrow = ARROW_CACHE[to_int]
else:
p1 = QPoint(*p1)
p2 = QPoint(*p2)
path = QPainterPath()
path.moveTo(p1)
path.lineTo(p2)
line = QLineF(p1, p2)
end = p2
pathlen = path.length()
leng = min(10, pathlen / 4.0)
arrowbase = path.pointAtPercent(path.percentAtLength(pathlen - leng))
l1 = QLineF(arrowbase, end)
l2 = QLineF(arrowbase, end)
l1.setAngle(line.angle() - 150)
l2.setAngle(line.angle() + 150)
l1.setLength(l1.length() / 2.0)
l2.setLength(l2.length() / 2.0)
arrow = (arrowbase.toTuple(), l1.p2().toTuple(), end.toTuple(), l2.p2().toTuple())
ARROW_CACHE[to_int] = arrow
p5.fill(color)
p5.quad(*arrow)
def shape(self):
"""
Returns the shape of this item as a QPainterPath in local coordinates.
The shape could be used for many things, like collision detection.
:return: Returns the shape of this item as a QPainterPath in local coordinates.
:rtype: QPainterPath
"""
path = QPainterPath()
path.addRect(self.boundingRect())
return path
def _make_ellipse_path(self):
"""Returns an ellipse path for the link's base.
Returns:
QPainterPath
"""
ellipse_path = QPainterPath()
rect = QRectF(0, 0, 1.6 * self.magic_number, 1.6 * self.magic_number)
rect.moveCenter(self.src_center)
ellipse_path.addEllipse(rect)
return ellipse_path
def _draw_chromosone(painter, chromosone, total_triangles, size=(250, 250)):
brush = _create_brush(0, 0, 0, 0)
painter_path = QPainterPath()
for i in range(total_triangles):
_draw_triangle(brush,
painter_path,
painter,
chromosone,
offset=i,
size=size)
painter_path.clear()
def paintEvent(self, event):
rect = QRect(10, 20, 80, 60)
path = QPainterPath()
path.moveTo(20, 80)
path.lineTo(20, 30)
path.cubicTo(80, 0, 50, 50, 80, 80)
startAngle = 30 * 16
arcLength = 120 * 16
painter = QPainter(self)
painter.setPen(self.pen)
painter.setBrush(self.brush)
if self.antialiased:
painter.setRenderHint(QPainter.Antialiasing)
for x in range(0, self.width(), 100):
for y in range(0, self.height(), 100):
painter.save()
painter.translate(x, y)
if self.transformed:
painter.translate(50, 50)
painter.rotate(60.0)
painter.scale(0.6, 0.9)
painter.translate(-50, -50)
if self.shape == RenderArea.Line:
painter.drawLine(rect.bottomLeft(), rect.topRight())
elif self.shape == RenderArea.Points:
painter.drawPoints(RenderArea.points)
elif self.shape == RenderArea.Polyline:
painter.drawPolyline(RenderArea.points)
elif self.shape == RenderArea.Polygon:
painter.drawPolygon(RenderArea.points)
elif self.shape == RenderArea.Rect:
painter.drawRect(rect)
elif self.shape == RenderArea.RoundedRect:
painter.drawRoundedRect(rect, 25, 25, Qt.RelativeSize)
elif self.shape == RenderArea.Ellipse:
painter.drawEllipse(rect)
elif self.shape == RenderArea.Arc:
painter.drawArc(rect, startAngle, arcLength)
elif self.shape == RenderArea.Chord:
painter.drawChord(rect, startAngle, arcLength)
elif self.shape == RenderArea.Pie:
painter.drawPie(rect, startAngle, arcLength)
elif self.shape == RenderArea.Path:
painter.drawPath(path)
elif self.shape == RenderArea.Text:
painter.drawText(rect, Qt.AlignCenter,
"PySide 2\nQt %s" % qVersion())
elif self.shape == RenderArea.Pixmap:
painter.drawPixmap(10, 10, self.pixmap)
painter.restore()
painter.setPen(self.palette().dark().color())
painter.setBrush(Qt.NoBrush)
painter.drawRect(QRect(0, 0, self.width() - 1, self.height() - 1))
def paint(self, painter, option, widget):
path = QPainterPath()
path.addRoundedRect(self._rect, 5, 5)
anchor = self.mapFromParent(self._chart.mapToPosition(self._anchor))
if not self._rect.contains(anchor) and not self._anchor.isNull():
point1 = QPointF()
point2 = QPointF()
# establish the position of the anchor point in relation to _rect
above = anchor.y() <= self._rect.top()
aboveCenter = (anchor.y() > self._rect.top() and
anchor.y() <= self._rect.center().y())
belowCenter = (anchor.y() > self._rect.center().y() and
anchor.y() <= self._rect.bottom())
below = anchor.y() > self._rect.bottom()
onLeft = anchor.x() <= self._rect.left()
leftOfCenter = (anchor.x() > self._rect.left() and
anchor.x() <= self._rect.center().x())
rightOfCenter = (anchor.x() > self._rect.center().x() and
anchor.x() <= self._rect.right())
onRight = anchor.x() > self._rect.right()
# get the nearest _rect corner.
x = (onRight + rightOfCenter) * self._rect.width()
y = (below + belowCenter) * self._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 *
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 *
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._textRect, self._text)
