def initBrushes():
"""
returns a list of brush families.
Eraser is the last item of the list.
@return:
@rtype: list of brushFamily instances
"""
brushes = []
######################
# standard round brush
######################
baseSize = 400 # 25
qpp = QPainterPath()
qpp.addEllipse(QRect(0, 0, baseSize, baseSize))
roundBrushFamily = brushFamily('Round', baseSize, qpp, presetFilename=None)
brushes.append(roundBrushFamily)
##########
# eraser
##########
qpp = QPainterPath()
qpp.addEllipse(QRect(0, 0, baseSize, baseSize))
eraserFamily = brushFamily('Eraser', baseSize, qpp)
# eraser must be added last
brushes.append(eraserFamily)
return brushes
def draw_border(self, painter):
painter.save()
painter.translate(0, self.t_height)
if in_range(self.red_offset, self.l, self.r):
# non-red zone
path = QPainterPath()
path.moveTo(self.red_offset, 0)
path.lineTo(self.l, 0)
path.lineTo(self.l, self.bar_height)
path.lineTo(self.red_offset, self.bar_height)
painter.drawPath(path)
# red zone
path = QPainterPath()
path.moveTo(self.red_offset, 0)
path.lineTo(self.r, 0)
path.lineTo(self.r, self.bar_height)
path.lineTo(self.red_offset, self.bar_height)
painter.setPen(self.red_pen)
painter.drawPath(path)
else:
painter.drawRect(QRect(
self.l,
self.l,
self.r - self.l,
self.bar_height,
))
painter.restore()
def paintEvent(self, event):
super(BubbleLabel, self).paintEvent(event)
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing) # 抗锯齿
rectPath = QPainterPath() # 圆角矩形
triPath = QPainterPath() # 底部三角形
height = self.height() - 8 # 往上偏移8
rectPath.addRoundedRect(QRectF(0, 0, self.width(), height), 5, 5)
x = self.width() / 5 * 4
triPath.moveTo(x, height) # 移动到底部横线4/5处
# 画三角形
triPath.lineTo(x + 6, height + 8)
triPath.lineTo(x + 12, height)
rectPath.addPath(triPath) # 添加三角形到之前的矩形上
# 边框画笔
painter.setPen(QPen(self.BorderColor, 1, Qt.SolidLine,
Qt.RoundCap, Qt.RoundJoin))
# 背景画刷
painter.setBrush(self.BackgroundColor)
# 绘制形状
painter.drawPath(rectPath)
# 三角形底边绘制一条线保证颜色与背景一样
painter.setPen(QPen(self.BackgroundColor, 1,
Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin))
painter.drawLine(x, height, x + 12, height)
def paintEvent(self, event):
"""
custom paint event to draw horizontal line and handles at current y level
"""
super().paintEvent(event)
painter = QPainter(self)
#painter.beginNativePainting()
#painter.setRenderHint(QPainter.Antialiasing)
x1,y1,x2,y2 = self.rect().getCoords()
#painter.setPen(QPen(Qt.gray, 1))
#painter.drawRect(self.rect())
painter.setPen(QPen(COLOR, 1))
painter.drawLine(QPoint(x1, y1+(y2-y1)/2), QPoint(x2, y1+(y2-y1)/2))
path = QPainterPath()
path.moveTo(x1, y1)
path.lineTo(x1, y1 + y2)
path.lineTo(10, y1 + y2/2)
path.lineTo(x1, y1)
painter.fillPath(path, QBrush(COLOR))
path = QPainterPath()
path.moveTo(x2+1, y1)
path.lineTo(x2+1, y1 + y2)
path.lineTo(x2 - 9, y1 + y2/2)
path.lineTo(x2+1, y1)
painter.fillPath(path, QBrush(COLOR))
#painter.endNativePainting()
painter.end()
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 loadPresets(filename, first=1):
"""
Loads brush preset from file
@param filename:
@type filename: str
@return:
@rtype: list of brushFamily instances
"""
brushes = []
patterns = []
baseSize = 400 # 25
try:
rank = first
entry = os.path.basename(filename)
if entry[-4:].lower() in ['.png', '.jpg']:
try:
qpp = QPainterPath()
qpp.addEllipse(QRect(0, 0, baseSize, baseSize))
presetBrushFamily = brushFamily('Preset ' + str(rank),
baseSize,
qpp,
presetFilename=os.getcwd() +
'\\' + BRUSHES_PATH + '\\' +
entry)
brushes.append(presetBrushFamily)
rank += 1
except IOError:
pass
elif entry[-4:].lower() in ['.abr']:
sImages, pImages = aParser.readFile(os.getcwd() + '\\' +
BRUSHES_PATH + '\\' + entry)
for im in sImages:
qpp = QPainterPath()
qpp.addEllipse(QRect(0, 0, baseSize, baseSize))
alpha = np.full_like(im, 255)
im = np.dstack((im, im, im, im)) # alpha))
qim = ndarrayToQImage(im, format=QImage.Format_ARGB32)
presetBrushFamily = brushFamily('Preset ' + str(rank),
baseSize,
qpp,
image=qim)
brushes.append(presetBrushFamily)
rank += 1
rank = first
for im in pImages:
#alpha = np.full_like(im, 255)
im = np.dstack((im, im, im, im))
qim = ndarrayToQImage(im, format=QImage.Format_ARGB32)
p = pattern('pattern ' + str(rank),
im=qim,
pxmp=QPixmap.fromImage(qim))
patterns.append(p)
rank += 1
except IOError:
pass
return brushes, patterns
def path(self):
"""Compute and return QPainterPath that is used to draw the curved line.
Internal function use this to reset their path in response to external changes.
"""
if self._source_pos is None or self._target_pos is None:
return QPainterPath()
result = QPainterPath()
result.moveTo(self._source_pos)
result.cubicTo(self._bezier_point_1(), self._bezier_point_2(),
self._target_pos)
return result
def paint(self,
painter=QPainter,
option=QStyleOptionGraphicsItem,
widget=QWidget):
corners = 5
body = self.boundingRect()
height = body.height()
width = body.width()
percentage = height / 10
painter.setRenderHint(QPainter.Antialiasing)
path = QPainterPath()
path.addRoundedRect(body, corners, corners)
pen = QPen(QColor(255, 255, 255, 100),
3) if self.hover and not self.isPressed else QPen(
Qt.black, 0.1)
pen.setJoinStyle(Qt.RoundJoin)
pen.setCosmetic(True)
painter.setPen(pen)
painter.fillPath(path, self._model["bgColor"])
painter.drawPath(path)
if not self.isPressed:
grad = QLinearGradient(0, height, 0, height - percentage)
grad.setColorAt(0, QColor(175, 175, 175, 255))
grad.setColorAt(1, QColor(175, 175, 175, 0))
path = QPainterPath()
path.addRoundedRect(body, corners, corners)
painter.setCompositionMode(QPainter.CompositionMode_Multiply)
painter.setPen(Qt.NoPen)
painter.fillPath(path, grad)
painter.drawPath(path)
grad = QLinearGradient(0, percentage, 0, 0)
grad.setColorAt(1, QColor(255, 255, 255, 255))
grad.setColorAt(0, QColor(255, 255, 255, 0))
path = QPainterPath()
path.addRoundedRect(body, corners, corners)
painter.setCompositionMode(QPainter.CompositionMode_Overlay)
painter.setPen(Qt.NoPen)
painter.fillPath(path, grad)
painter.drawPath(path)
painter.setCompositionMode(QPainter.CompositionMode_Source)
else:
path = QPainterPath()
path.addRoundedRect(body, corners, corners)
painter.setCompositionMode(QPainter.CompositionMode_Overlay)
painter.setPen(Qt.NoPen)
painter.fillPath(path, QColor(255, 255, 255))
painter.drawPath(path)
painter.setCompositionMode(QPainter.CompositionMode_Source)
super(ButtonNode, self).paint(painter, option, widget)
def draw_plus(self, painter=QPainter):
brush = QBrush()
# Highlighted
painter.setPen(Qt.NoPen)
if self._highlight:
brush.setStyle(Qt.SolidPattern)
brush.setColor(QColor(255, 0, 0))
else:
brush.setStyle(Qt.SolidPattern)
brush.setColor(QColor(224, 224, 224))
boundry = self.boundingRect()
painter.setBrush(brush)
path = QPainterPath()
widthSec = boundry.width() / 3
heightSec = boundry.height() / 3
path.moveTo(widthSec, 0)
path.lineTo(widthSec * 2, 0)
path.lineTo(widthSec * 2, heightSec)
path.lineTo(widthSec * 3, heightSec)
path.lineTo(widthSec * 3, heightSec * 2)
path.lineTo(widthSec * 2, heightSec * 2)
path.lineTo(widthSec * 2, heightSec * 3)
path.lineTo(widthSec, heightSec * 3)
path.lineTo(widthSec, heightSec * 2)
path.lineTo(0, heightSec * 2)
path.lineTo(0, heightSec)
path.lineTo(widthSec, heightSec)
path.lineTo(widthSec, 0)
painter.drawPath(path)
# background
brush.setColor(self._model["bgColor"])
painter.setBrush(brush)
offset = 4
path = QPainterPath()
widthSec = boundry.width() / 3
heightSec = boundry.height() / 3
path.moveTo(widthSec + offset, 0 + offset)
path.lineTo((widthSec * 2) - offset, 0 + offset)
path.lineTo((widthSec * 2) - offset, heightSec + offset)
path.lineTo((widthSec * 3) - offset, heightSec + offset)
path.lineTo((widthSec * 3) - offset, (heightSec * 2) - offset)
path.lineTo((widthSec * 2) - offset, (heightSec * 2) - offset)
path.lineTo((widthSec * 2) - offset, (heightSec * 3) - offset)
path.lineTo(widthSec + offset, (heightSec * 3) - offset)
path.lineTo(widthSec + offset, (heightSec * 2) - offset)
path.lineTo(0 + offset, (heightSec * 2) - offset)
path.lineTo(0 + offset, heightSec + offset)
path.lineTo(widthSec + offset, heightSec + offset)
path.lineTo(widthSec + offset, 0 + offset)
painter.drawPath(path)
def __init__(self,
item,
duration=2000,
count=5,
percentage_size=0.24,
x_shift=0):
"""Initializes animation stuff.
Args:
item (QGraphicsItem): The item on top of which the animation should play.
"""
self._item = item
self.cubes = [QGraphicsTextItem("\uf1b2", item) for i in range(count)]
self.opacity_at_value_path = QPainterPath(QPointF(0.0, 0.0))
self.opacity_at_value_path.lineTo(QPointF(0.01, 1.0))
self.opacity_at_value_path.lineTo(QPointF(0.5, 1.0))
self.opacity_at_value_path.lineTo(QPointF(1.0, 0.0))
self.time_line = QTimeLine()
self.time_line.setLoopCount(0) # loop forever
self.time_line.setFrameRange(0, 10)
self.time_line.setDuration(duration)
self.time_line.setCurveShape(QTimeLine.LinearCurve)
self.time_line.valueChanged.connect(
self._handle_time_line_value_changed)
self.time_line.stateChanged.connect(
self._handle_time_line_state_changed)
font = QFont('Font Awesome 5 Free Solid')
item_rect = item.rect()
cube_size = percentage_size * 0.875 * item_rect.height()
font.setPixelSize(cube_size)
rect = item_rect.translated(-0.5 * cube_size + x_shift, -cube_size)
end = rect.center()
ctrl = end - QPointF(0, 0.6 * rect.height())
lower, upper = 0.2, 0.8
starts = [lower + i * (upper - lower) / count for i in range(count)]
starts = [
rect.topLeft() + QPointF(start * rect.width(), 0)
for start in starts
]
self.paths = [QPainterPath(start) for start in starts]
for path in self.paths:
path.quadTo(ctrl, end)
self.offsets = [i / count for i in range(count)]
for cube in self.cubes:
cube.setFont(font)
cube.setDefaultTextColor("#003333")
cube.setTransformOriginPoint(cube.boundingRect().center())
cube.hide()
cube.setOpacity(0)
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 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 paint(self, painter, *args):
super().paint(painter, *args)
kind = self.desc.kind
painter.setPen(QPen(Qt.black, 2))
path = QPainterPath()
r = self.rect()
if kind == 'and':
path.moveTo(r.topLeft())
path.lineTo(r.center().x(), r.top())
path.quadTo(r.topRight(), QPoint(r.right(), r.height() / 2))
path.quadTo(r.bottomRight(), QPoint(r.width() / 2, r.bottom()))
path.lineTo(r.bottomLeft())
path.closeSubpath()
elif kind == 'or':
path.moveTo(r.topLeft())
path.lineTo(r.width() / 4, r.top())
path.quadTo(QPoint(r.width() / 4 * 3, r.top()),
QPoint(r.right(),
r.height() / 2))
path.quadTo(QPoint(r.width() / 4 * 3, r.bottom()),
QPoint(r.width() / 4, r.bottom()))
path.lineTo(r.bottomLeft())
path.quadTo(r.center(), r.topLeft())
painter.drawPath(path)
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 paintEvent(self, *args):
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.setBrush(Qt.black)
painter.setPen(QPen(Qt.transparent))
for block in self.blocks:
painter.drawRect(block)
if self.debug:
lines = list()
points = list()
for p1 in self.graph:
for p2 in self.graph[p1]:
lines.append(QLine(*p1, *p2))
points.append(QPoint(*p1))
points.append(QPoint(*p2))
painter.setPen(QPen(Qt.black))
painter.drawLines(lines)
painter.setPen(QPen(Qt.red, 3))
painter.drawPoints(points)
if self.path:
painter.setPen(QPen(Qt.green))
painter.setBrush(Qt.transparent)
p = QPainterPath()
p.moveTo(*self.path[0])
for point in self.path:
p.lineTo(*point)
painter.drawPath(p)
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):
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_border_background(self, painter):
"""paint_border_background(self, painter:PySide2.QtGui.QPainter)"""
painter.save()
pen = QPen()
pen.setColor(self.border_color())
pen.setWidth(self.border_width())
painter.setPen(pen)
brush = QBrush(self.background_color())
painter.setBrush(brush)
painter.setOpacity(self.opacity())
# painter.setRenderHint(QPainter.Antialiasing)
rc = self.rect()
paint_path = QPainterPath()
# adjust shadow
if self._shadow is not None:
rc.adjust(self.shadow_blur(), self.shadow_blur(),
-self.shadow_blur(), -self.shadow_blur())
# self._calc_background_path(rc, paint_path)
if self._calc_background_path(rc, paint_path):
painter.setRenderHint(QPainter.Antialiasing)
if self.border_width() > 0:
painter.drawPath(paint_path)
else:
painter.fillPath(paint_path, brush)
painter.restore()
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
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 updatePath(self):
qpp = QPainterPath()
# coordinates are relative to activeTangent object
qpp.moveTo(0, 0)
qpp.lineTo((self.controlPoint - self.contactPoint))
qpp.addEllipse(self.controlPoint - self.contactPoint, 5.0, 5.0)
self.setPath(qpp)
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 shape(self):
path = QPainterPath()
path.setFillRule(Qt.WindingFill)
path.addRect(self.rect())
for handle in self.handles:
path.addRect(handle.boundingRect())
return path
def _make_connecting_path(self, guide_path):
"""Returns a 'thick' path connecting source and destination, by following the given 'guide' path.
Args:
guide_path (QPainterPath)
Returns:
QPainterPath
"""
points, angles = self._points_and_angles_from_path(guide_path)
outgoing_points = []
incoming_points = []
for point, angle in zip(points, angles):
off = self._radius_from_point_and_angle(point, angle)
outgoing_points.append(point + off)
incoming_points.insert(0, point - off)
p0 = guide_path.pointAtPercent(0)
a0 = guide_path.angleAtPercent(0)
off0 = self._radius_from_point_and_angle(p0, a0)
curve_path = QPainterPath(p0 + off0)
self._follow_points(curve_path, outgoing_points)
curve_path.lineTo(incoming_points[0])
self._follow_points(curve_path, incoming_points)
curve_path.lineTo(p0 - off0)
curve_path.closeSubpath()
curve_path.setFillRule(Qt.WindingFill)
return curve_path.simplified()
def connection_path(p1: QPointF, p2: QPointF):
"""Returns the nice looking QPainterPath of a connection for two given points."""
path = QPainterPath()
path.moveTo(p1)
distance_x = abs(p1.x()) - abs(p2.x())
distance_y = abs(p1.y()) - abs(p2.y())
if ((p1.x() < p2.x() - 30)
or math.sqrt((distance_x**2) +
(distance_y**2)) < 100) and (p1.x() < p2.x()):
path.cubicTo(p1.x() + ((p2.x() - p1.x()) / 2), p1.y(),
p1.x() + ((p2.x() - p1.x()) / 2), p2.y(), p2.x(),
p2.y())
elif p2.x() < p1.x() - 100 and abs(distance_x) / 2 > abs(distance_y):
path.cubicTo(p1.x() + 100 + (p1.x() - p2.x()) / 10, p1.y(),
p1.x() + 100 + (p1.x() - p2.x()) / 10,
p1.y() - (distance_y / 2),
p1.x() - (distance_x / 2),
p1.y() - (distance_y / 2))
path.cubicTo(p2.x() - 100 - (p1.x() - p2.x()) / 10,
p2.y() + (distance_y / 2),
p2.x() - 100 - (p1.x() - p2.x()) / 10, p2.y(), p2.x(),
p2.y())
else:
path.cubicTo(p1.x() + 100 + (p1.x() - p2.x()) / 3, p1.y(),
p2.x() - 100 - (p1.x() - p2.x()) / 3, p2.y(), p2.x(),
p2.y())
return path
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 drawPlotGrid(cls, axeSize, gradient=None):
"""
Rerturns a QGraphicsPathItem initialized with
a square grid.
@param axeSize:
@type axeSize:
@param gradient:
@type gradient
@return:
@rtype: QGraphicsPathItem
"""
lineWidth = 1
item = QGraphicsPathItem()
if gradient is None:
item.setPen(QPen(Qt.darkGray, lineWidth, Qt.DashLine))
else:
item.setPen(QPen(gradient, lineWidth, Qt.DashLine))
qppath = QPainterPath()
qppath.moveTo(QPoint(0, 0))
qppath.lineTo(QPoint(axeSize, 0))
qppath.lineTo(QPoint(axeSize, -axeSize))
qppath.lineTo(QPoint(0, -axeSize))
qppath.closeSubpath()
qppath.lineTo(QPoint(axeSize, -axeSize))
# draw grid
for i in range(1, 5):
a = (axeSize * i) / 4
qppath.moveTo(a, -axeSize)
qppath.lineTo(a, 0)
qppath.moveTo(0, -a)
qppath.lineTo(axeSize, -a)
item.setPath(qppath)
return item
def draw_dark_minimalistic(self, painter):
path = QPainterPath()
path.moveTo(-self.width / 2, 0)
path.cubicTo(-self.width / 2, -self.height / 2,
-self.width / 2, -self.height / 2,
0, -self.height / 2)
path.cubicTo(+self.width / 2, -self.height / 2,
+self.width / 2, -self.height / 2,
+self.width / 2, 0)
path.cubicTo(+self.width / 2, +self.height / 2,
+self.width / 2, +self.height / 2,
0, +self.height / 2)
path.cubicTo(-self.width / 2, +self.height / 2,
-self.width / 2, +self.height / 2,
-self.width / 2, 0)
path.closeSubpath()
c = self.parent_node.color
body_gradient = QLinearGradient(self.boundingRect().bottomLeft(),
self.boundingRect().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 draw_NI_minimalistic(painter,
c,
w,
h,
background_color=QColor('#36383B')):
"""
:param painter: painter from paint event
:param c_s: corner size/corner radius
:param c: color
:param w: width
:param h: height
:param background_color: (default) background color
"""
c_s = 10
path = QPainterPath()
path.moveTo(-w / 2, 0)
path.lineTo(-w / 2 + c_s / 2, -h / 2 + c_s / 2)
path.lineTo(0, -h / 2)
path.lineTo(+w / 2 - c_s / 2, -h / 2 + c_s / 2)
path.lineTo(+w / 2, 0)
path.lineTo(+w / 2 - c_s / 2, +h / 2 - c_s / 2)
path.lineTo(0, +h / 2)
path.lineTo(-w / 2 + c_s / 2, +h / 2 - c_s / 2)
path.closeSubpath()
painter.setBrush(background_color)
pen = QPen(c)
pen.setWidth(2)
painter.setPen(pen)
painter.drawPath(path)
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)
