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): 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 __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 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 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): 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 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 _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 __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 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)
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 paint(self, painter): painter.setPen(QPen(self.sky_color)) painter.setBrush(QBrush(self.sky_color)) painter.drawRect(0, 0, self.width, self.height) hwidth = self.width / 2 hheight = self.height / 2 for star in self.stars: x = hwidth + star.pos.x() * star.pos.z() * hwidth * 2 y = hheight + star.pos.y() * star.pos.z() * hheight * 2 prev_x = hwidth + star.pos.x() * star.prev_z * hwidth * 2 prev_y = hheight + star.pos.y() * star.prev_z * hheight * 2 size = 3.0 * star.pos.z() c = star.pos.z() * star.max_star_white star_color = QColor(c, c, c) painter.setPen(QPen(star_color)) painter.setBrush(QBrush(star_color)) painter.drawEllipse(x - size / 2, y - size / 2, size, size) painter.drawLine(x, y, prev_x, prev_y) painter_path = QPainterPath() painter_path.moveTo(QPoint(x, y)) for prev_i_z in star.prev_zs: prev_i_x = hwidth + star.pos.x() * prev_i_z * hwidth * 2 prev_i_y = hheight + star.pos.y() * prev_i_z * hheight * 2 painter_path.lineTo(QPoint(prev_i_x, prev_i_y)) c = star.pos.z() * star.max_tail_white trail_color = QColor(c, c, c) painter.setPen(QPen(trail_color)) painter.drawPath(painter_path)
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 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): point1 = QPointF() point2 = QPointF() # establish the position of the anchor point in relation to m_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 m_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 = qAbs(anchor.x() - x) > qAbs(anchor.y() - y) x1 = x + leftOfCenter * 10 - rightOfCenter * 20 + cornerCase * ( not vertical) * (onLeft * 10 - onRight * 20) y1 = y + aboveCenter * 10 - belowCenter * 20 + cornerCase * vertical * ( above * 10 - below * 20) x2 = x + leftOfCenter * 20 - rightOfCenter * 10 + cornerCase * ( not vertical) * (onLeft * 20 - onRight * 10) y2 = y + aboveCenter * 20 - belowCenter * 10 + cornerCase * vertical * ( above * 20 - below * 10) point1.setX(x1) point1.setY(y1) 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.text_rect, self.text)
def test_simple_path(self, p, opd): path = QPainterPath() path.moveTo(0, 0) path.lineTo(10, 20) p.drawPath(path) assert opd.getOutlines() == [ ((0.0, 0.0, 0.0, 1.0), 0.1, [(0.0, 0.0), (1.0, 2.0)]), ]
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 test_transformed_path(self, p, opd): p.scale(10, 10) path = QPainterPath() path.moveTo(0, 0) path.lineTo(1, 2) p.drawPath(path) assert opd.getOutlines() == [ ((0.0, 0.0, 0.0, 1.0), 1.0, [(0.0, 0.0), (1.0, 2.0)]), ]
def test_no_pen(self, p, opd): pen = QPen() pen.setStyle(Qt.PenStyle.NoPen) p.setPen(pen) path = QPainterPath() path.moveTo(0, 0) path.lineTo(10, 20) p.drawPath(path) assert opd.getOutlines() == []
def test_no_brush(self, p, opd): brush = QBrush() brush.setStyle(Qt.BrushStyle.NoBrush) pen = QPen() pen.setBrush(brush) p.setPen(pen) path = QPainterPath() path.moveTo(0, 0) path.lineTo(10, 20) p.drawPath(path)
def test_singular_transformed_path(self, p, opd): p.scale(10, 0) path = QPainterPath() path.moveTo(0, 0) path.lineTo(1, 2) p.drawPath(path) out = opd.getOutlines() assert len(out) == 1 colour, width, lines = out[0] assert colour == (0.0, 0.0, 0.0, 1.0) assert lines == [(0.0, 0.0), (1.0, 0.0)]
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)
def build_path(self, points, scale=1): path = QPainterPath() if len(points) > 0: p0 = self.projectPointToCanvas(points[0], scale) path.moveTo(p0) for p in points[1:]: cp = self.projectPointToCanvas(p, scale) path.lineTo(cp) path.lineTo(p0) return path
def paint(self, painter, option, widget): painter.setPen(self.pen) painter.setRenderHint(QPainter.Antialiasing) path = QPainterPath() for i in range(len(self.data)): (x, y) = self.to_point(self.data[i][0], self.data[i][1]) if i == 0: path.moveTo(0, y) continue path.lineTo(x, y) painter.drawPath(path)
def paint(self, painter): painter.setPen(QPen(Qt.black, 2)) painter.setBrush(Qt.white) path = QPainterPath() s = self.SIZE path.moveTo(QPoint()) path.lineTo(QPoint(s.width() - 5, s.height() / 2)) path.lineTo(QPoint(0, s.height())) path.closeSubpath() painter.drawPath(path) painter.drawEllipse(QPoint(s.width() - 2, s.height() / 2), 3, 3)
def drawGrid(self): step = 4 qpp = QPainterPath() for i in range(self.size): for j in range(self.size): node = self.gridNodes[i][j] if i % step == 0 and j % step == 0: if i > 0: qpp.moveTo(node.gridPos()) qpp.lineTo(self.gridNodes[i-step][j].gridPos()) if j > 0: qpp.moveTo(node.gridPos()) qpp.lineTo(self.gridNodes[i][j-step].gridPos()) if not node.isSelected(): continue # mark initial position qpp.moveTo(node.gridPos()) qpp.lineTo(node.initialPos) qpp.addEllipse(node.initialPos, 5, 5) # mark visible neighbors for n in node.neighbors(): if n.isVisible(): qpp.moveTo(n.gridPos()) qpp.lineTo(node.gridPos()) self.setPath(qpp)
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 paint(self, painter): painther_path = QPainterPath() first = True top, bottom = self.light.get_top_bottom_worldspace() painther_path.moveTo(top.toPoint()) for ray in self.rays: painther_path.lineTo((ray.pos + ray.dir * ray.length).toPoint()) painther_path.lineTo(bottom.toPoint()) painter.fillPath(painther_path, QColor(220, 220, 160)) for ray in self.rays: if DEBUG: painter.setPen(QPen()) ray.paint(painter)
def __paintStop(self, painter, start, color): path = QPainterPath() path.moveTo(start - self.__arrow_size / 2.0 + self.__arrow_space / 2.0, 0) path.lineTo(start + self.__item_width, 0) path.lineTo(start + self.__item_width, self.__item_height) path.lineTo(start - self.__arrow_size / 2.0 + self.__arrow_space / 2.0, self.__item_height) path.lineTo(start + self.__arrow_size / 2.0 + self.__arrow_space / 2.0, self.__item_height / 2.0) path.lineTo(start - self.__arrow_size / 2.0 + self.__arrow_space / 2.0, 0) painter.fillPath(path, QBrush(color)) painter.strokePath(path, self.__pen_line)
def test_simple_dashes(self, p, opd): pen = QPen() pen.setDashPattern([2, 1]) pen.setWidth(5) p.setPen(pen) path = QPainterPath() path.moveTo(0, 0) path.lineTo(30, 0) p.drawPath(path) assert opd.getOutlines() == [ ((0.0, 0.0, 0.0, 1.0), 0.5, [(0.0, 0.0), (1.0, 0.0)]), ((0.0, 0.0, 0.0, 1.0), 0.5, [(1.5, 0.0), (2.5, 0.0)]), ]
def paint(self, painter): chunk_x = float(self.rect.width()) / self.resolution.width() chunk_y = float(self.rect.height()) / self.resolution.height() painter_path = QPainterPath() for i, pos in enumerate(self.path): x = pos.x() * chunk_x y = pos.y() * chunk_y p = QPoint(x, y) if i == 0: painter_path.moveTo(p) else: painter_path.lineTo(p) painter.drawPath(painter_path)
def paint(self, painter, *args): super().paint(painter, *args) painter.setPen(QPen(Qt.black, 2)) painter.setBrush(Qt.white) path = QPainterPath() r = self.rect() path.moveTo(r.topLeft()) path.lineTo(r.topRight() + QPointF(-5, r.height() / 2)) path.lineTo(r.bottomLeft()) path.closeSubpath() painter.drawPath(path) painter.drawEllipse(QPointF(r.right() - 5, r.height() / 2), 5, 5)