def paintEvent(self, a0: QtGui.QPaintEvent):
painter = QPainter(self)
pen = painter.pen()
pen.setColor(Qt.black)
pen.setWidth(2)
painter.setPen(pen)
board_x, board_y, board_width, board_height = self.boardSize
for i in range(8):
lx = board_x + i * 80
painter.drawLine(lx, board_y, lx, board_y + board_height)
for j in range(7):
ly = board_y + j * 80
painter.drawLine(board_x, ly, board_x + board_width, ly)
brush = painter.brush()
brush.setColor(Qt.green)
brush.setStyle(Qt.SolidPattern)
painter.setBrush(brush)
if 0 <= self.mousePos <= 6:
tr_y = board_y - 20
tr_x = board_x + self.mousePos * 80 + 40
painter.drawPolygon(QPoint(tr_x - 20, tr_y - 20), QPoint(tr_x, tr_y), QPoint(tr_x + 20, tr_y - 20))
for col in range(7):
for row in range(5, -1, -1):
piece = self.controller.gameModel[row][col]
if piece == -1:
break
if piece == 0:
brush.setColor(QColor("#db0000"))
else:
brush.setColor(QColor("#00468b"))
painter.setBrush(brush)
painter.drawEllipse(QPoint(board_x + col * 80 + 40, board_y + row * 80 + 40), 35, 35)
class GeometryDrawer:
def __init__(self):
self.painter = QPainter()
self.draw_line_chain = GentleIncreaseLineDrawer()
self.draw_line_chain.set_next( SteepIncreaseLineDrawer() ).set_next( GentleDecreaseLineDrawer() ) \
.set_next( SteepDecreaseLineDrawer() )
def draw_point(self, point: QPoint, radius: int):
for i in range(-radius, radius + 1):
for j in range(-radius, radius + 1):
self.painter.drawPoint(point.x() + i, point.y() + j)
def draw_line(self, p1: QPoint, p2: QPoint):
if p1.x() <= p2.x():
self.draw_line_chain.draw_line(p1, p2, self.painter)
else:
self.draw_line_chain.draw_line(p2, p1, self.painter)
def draw_icon(self, icon_path: str, central_point: QPoint):
icon = QImage(icon_path)
self.painter.drawImage(central_point.x() - icon.width() / 2,
central_point.y() - icon.height() / 2, icon)
def fill_polygon(self, polygon_path: QPainterPath):
self.painter.fillPath(polygon_path, self.painter.brush())
def begin(self, device: QPaintDevice):
self.painter.begin(device)
def end(self):
self.painter.end()
def pen(self) -> QColor:
return self.painter.pen()
def brush(self) -> QBrush:
return self.painter.brush()
def set_brush(self, color: QColor):
self.painter.setBrush(color)
def set_pen(self, color: QColor):
self.painter.setPen(color)
def set_filling(self,
painter: QPainter,
color: QColor = None,
style: QStyle = None):
brush_style = style if style is not None else painter.brush().style()
if color is not None:
brush = QBrush(color, brush_style)
else:
brush = QBrush(Qt.NoBrush)
painter.setBrush(brush)
def paint_line_numbers(self, line_numbers, event):
"""Paint the line numbers
For every visible block in the document draw it's corresponding line
number in the line numbers widget.
"""
font_metrics = self.document_contents.fontMetrics()
painter = QPainter(line_numbers)
painter.fillRect(event.rect(), self.document_contents.palette().base())
block = self.document_contents.firstVisibleBlock()
line_number = block.blockNumber()
height = font_metrics.height()
width = line_numbers.width()
while block.isValid():
# blocks are numbered from zero
line_number += 1
content_offset = self.document_contents.contentOffset()
# Get the top coordinate of the current block
# to know where to paint the line number for it
block_top = (self.document_contents
.blockBoundingGeometry(block)
.translated(content_offset)
.top())
if not block.isVisible() or block_top >= event.rect().bottom():
break
# If block has a breakpoint,
# draw a green rectangle by the line number
# if the block number matches the current line number
# make it red, as it is then a breakpoint hit
if self.document_contents.block_has_breakpoint(block):
brush = painter.brush()
brush.setStyle(Qt.SolidPattern)
if self.document_contents.block_is_current(block):
brush.setColor(Qt.red)
else:
brush.setColor(Qt.darkGreen)
painter.setBrush(brush)
rect = QRect(0, block_top+2, 7, 7)
painter.drawRect(rect)
# Convert the line number to string so we can paint it
text = str(line_number)
painter.drawText(0, block_top, width, height, Qt.AlignRight, text)
block = block.next()
painter.end()
def paint_line_numbers(self, line_numbers, event):
"""Paint the line numbers
For every visible block in the document draw it's corresponding line
number in the line numbers widget.
"""
font_metrics = self.document_contents.fontMetrics()
painter = QPainter(line_numbers)
painter.fillRect(event.rect(), self.document_contents.palette().base())
block = self.document_contents.firstVisibleBlock()
line_number = block.blockNumber()
height = font_metrics.height()
width = line_numbers.width()
while block.isValid():
# blocks are numbered from zero
line_number += 1
content_offset = self.document_contents.contentOffset()
# Get the top coordinate of the current block
# to know where to paint the line number for it
block_top = (self.document_contents.blockBoundingGeometry(
block).translated(content_offset).top())
if not block.isVisible() or block_top >= event.rect().bottom():
break
# If block has a breakpoint,
# draw a green rectangle by the line number
# if the block number matches the current line number
# make it red, as it is then a breakpoint hit
if self.document_contents.block_has_breakpoint(block):
brush = painter.brush()
brush.setStyle(Qt.SolidPattern)
if self.document_contents.block_is_current(block):
brush.setColor(Qt.red)
else:
brush.setColor(Qt.darkGreen)
painter.setBrush(brush)
rect = QRect(0, block_top + 2, 7, 7)
painter.drawRect(rect)
# Convert the line number to string so we can paint it
text = str(line_number)
painter.drawText(0, block_top, width, height, Qt.AlignRight, text)
block = block.next()
painter.end()
def paintEvent(self, a0: QtGui.QPaintEvent):
puzzleSize = 3
painter = QPainter(self)
pen = painter.pen()
pen.setColor(QColor("#8D5822"))
pen.setWidth(7)
painter.setPen(pen)
brush = painter.brush()
brush.setColor(QColor("#EEC085"))
brush.setStyle(Qt.SolidPattern)
painter.setBrush(brush)
font = painter.font()
font.setFamily("consolas")
font.setBold(True)
font.setPointSize(180 // puzzleSize) # 60-3 45-4
painter.setFont(font)
board_x, board_y, board_width, board_height = self.boardSize
painter.drawRect(board_x, board_y, board_width, board_height)
board_div = 600 // puzzleSize
for i in range(puzzleSize - 1):
painter.drawLine(board_div * (i + 1) + board_x, board_y,
board_div * (i + 1) + board_x,
board_y + board_height)
painter.drawLine(board_x,
board_div * (i + 1) + board_y,
board_x + board_width,
board_div * (i + 1) + board_y)
for i in range(3):
for j in range(3):
p = self.controller.model.get(j, i)
if p == 0:
continue
if p == 1:
pen.setColor(QColor("#db0000"))
painter.setPen(pen)
painter.drawLine(board_x + board_div * i + 50,
board_y + board_div * j + 50,
board_x + board_div * i + 150,
board_y + board_div * j + 150)
painter.drawLine(board_x + board_div * i + 50,
board_y + board_div * j + 150,
board_x + board_div * i + 150,
board_y + board_div * j + 50)
elif p == -1:
pen.setColor(QColor("#00468b"))
painter.setPen(pen)
painter.drawEllipse(
QPoint(board_x + board_div * i + 100,
board_y + board_div * j + 100), 60, 60)
def drawTiles(painter, rect, tileSize=6, color=None, backgroundColor=None):
sz = 2 * tileSize
tiledPixmap = QPixmap(sz, sz)
pixmapPainter = QPainter(tiledPixmap)
pixmapPainter.setPen(Qt.NoPen)
pixmapPainter.setBrush(Qt.Dense4Pattern)
brush = pixmapPainter.brush()
brush.setColor(color)
pixmapPainter.setBrush(brush)
pixmapPainter.setBackground(QBrush(backgroundColor))
pixmapPainter.setBackgroundMode(Qt.OpaqueMode)
pixmapPainter.scale(tileSize, tileSize)
pixmapPainter.drawRect(tiledPixmap.rect())
pixmapPainter.end()
painter.drawTiledPixmap(rect, tiledPixmap)
def _drawLimitPolygon(painter: QPainter, chart, points):
"""отрисовка полигона для области допуска"""
# logger.debug(f"{PumpGraph._drawLimitPolygon.__doc__} {chart.name}")
if not points.size:
return
old_pen = painter.pen()
old_brush = painter.brush()
polygon = QPolygonF()
for point in points:
polygon.append(QPointF(point[0], point[1]))
painter.setPen(LIMIT_PEN)
painter.setBrush(LIMIT_PEN.color())
painter.drawPolygon(polygon, Qt.OddEvenFill)
painter.setBrush(old_brush)
painter.setPen(old_pen)
def _drawChartsKnotsAndCurves(self, painter: QPainter):
"""отрисовка узлов и кривых"""
# logger.debug(f"{self._drawChartsKnotsAndCurves.__doc__} ->")
for chart, data in self._charts_data.items():
if not data['knots'].size or not chart.visibility:
continue
pen = painter.pen()
brush = painter.brush()
painter.setPen(chart.pen)
painter.setBrush(chart.pen.color())
if ChartOptions.Knots in chart.options:
# logger.debug(f"отрисовка узлов для {chart.name}")
PumpGraph._drawKnots(painter, data['knots'])
painter.setBrush(brush)
# logger.debug(f"отрисовка кривой для {chart.name}")
PumpGraph._drawCurve(painter, data['curve'])
painter.setPen(pen)
def paintEvent(self, ev):
painter = QPainter(self)
# calc bar offset
y_offset = (self.height() - self._barHeight()) // 2
## prevent negative offset
y_offset = 0 if y_offset < 0 else y_offset
# frame around fraction indicator
painter.setBrush(self.palette().dark())
painter.save()
## no fill color
b = painter.brush()
b.setStyle(Qt.NoBrush)
painter.setBrush(b)
painter.drawRect(QRect(QPoint(0, y_offset), QSize(self._barWidth(), self._barHeight())))
painter.restore()
# fraction indicator
painter.drawRect(QRect(QPoint(0, y_offset), QSize(self._barWidth() * self._fraction, self._barHeight())))
def _draw(self, qp: QPainter):
if self._aco is not None:
self._label_path_length_value.setText(str(self._aco.min_path))
self._label_iteration_value.setText(str(self._aco.iterations))
else:
self._label_path_length_value.setText(MIN_PATH_LABEL_DEFAULT)
self._label_iteration_value.setText(ITERATIONS_LABEL_DEFAULT)
if self._communicator.draw_place.good:
brush = qp.brush()
for line in self._communicator.draw_place.lines:
qp.setPen(line[2])
qp.drawLine(line[0].x * PIXEL_SIZE + PIXEL_SIZE // 2,
line[0].y * PIXEL_SIZE + PIXEL_SIZE // 2,
line[1].x * PIXEL_SIZE + PIXEL_SIZE // 2,
line[1].y * PIXEL_SIZE + PIXEL_SIZE // 2)
qp.setPen(PATH_COLOR)
for line in self._communicator.draw_place.path:
qp.drawLine(line[0].x * PIXEL_SIZE + PIXEL_SIZE // 2,
line[0].y * PIXEL_SIZE + PIXEL_SIZE // 2,
line[1].x * PIXEL_SIZE + PIXEL_SIZE // 2,
line[1].y * PIXEL_SIZE + PIXEL_SIZE // 2)
qp.setPen(NODE_COLOR)
qp.setBrush(QBrush(NODE_COLOR))
for node in self._communicator.draw_place.nodes:
qp.drawRect(node.x * PIXEL_SIZE,
node.y * PIXEL_SIZE,
PIXEL_SIZE,
PIXEL_SIZE)
qp.setPen(START_COLOR)
qp.setBrush(QBrush(START_COLOR))
qp.drawRect(self._communicator.draw_place.start.x * PIXEL_SIZE,
self._communicator.draw_place.start.y * PIXEL_SIZE,
PIXEL_SIZE,
PIXEL_SIZE)
qp.setBrush(brush)
def paintEvent(self, ev):
painter = QPainter(self)
# calc bar offset
y_offset = (self.height() - self._barHeight()) // 2
## prevent negative offset
y_offset = 0 if y_offset < 0 else y_offset
# frame around fraction indicator
painter.setBrush(self.palette().dark())
painter.save()
## no fill color
b = painter.brush()
b.setStyle(Qt.NoBrush)
painter.setBrush(b)
painter.drawRect(
QRect(QPoint(0, y_offset),
QSize(self._barWidth(), self._barHeight())))
painter.restore()
# fraction indicator
painter.drawRect(
QRect(QPoint(0, y_offset),
QSize(self._barWidth() * self._fraction, self._barHeight())))
def paintEvent(self, event):
# based on
# http://qt.gitorious.org/qt/qt/blobs/master/src/gui/widgets/qslider.cpp
painter = QPainter(self)
style = self.style()
opt = QStyleOptionSlider()
self.initStyleOption(opt)
groove_rect = style.subControlRect(style.CC_Slider, opt,
QStyle.SC_SliderGroove, self)
handle_rect = style.subControlRect(style.CC_Slider, opt,
QStyle.SC_SliderHandle, self)
slider_space = style.pixelMetric(style.PM_SliderSpaceAvailable, opt)
range_x = style.sliderPositionFromValue(self.minimum(), self.maximum(),
self.value(), slider_space)
range_height = 4
groove_rect = QRectF(groove_rect.x(),
handle_rect.center().y() - (range_height / 2),
groove_rect.width(), range_height)
range_rect = QRectF(groove_rect.x(),
handle_rect.center().y() - (range_height / 2),
range_x, range_height)
if style.metaObject().className() != 'QMacStyle':
# Paint groove for Fusion and Windows styles
cur_brush = painter.brush()
cur_pen = painter.pen()
painter.setBrush(QBrush(QColor(169, 169, 169)))
painter.setPen(Qt.NoPen)
# painter.drawRect(groove_rect)
painter.drawRoundedRect(groove_rect,
groove_rect.height() / 2,
groove_rect.height() / 2)
painter.setBrush(cur_brush)
painter.setPen(cur_pen)
cur_brush = painter.brush()
cur_pen = painter.pen()
painter.setBrush(QBrush(QColor(18, 141, 148)))
painter.setPen(Qt.NoPen)
painter.drawRect(range_rect)
painter.setBrush(cur_brush)
painter.setPen(cur_pen)
opt = QStyleOptionSlider()
self.initStyleOption(opt)
opt.subControls = QStyle.SC_SliderHandle
if self.tickPosition() != self.NoTicks:
opt.subControls |= QStyle.SC_SliderTickmarks
if self.isSliderDown():
opt.state |= QStyle.State_Sunken
else:
opt.state |= QStyle.State_Active
opt.activeSubControls = QStyle.SC_None
opt.sliderPosition = self.value()
opt.sliderValue = self.value()
style.drawComplexControl(QStyle.CC_Slider, opt, painter, self)
def paintEvent(self, event):
# print('Paint!!!')
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing, True)
xr = self.data_range['x']
yr = self.data_range['y']
w = self.width()
h = self.height()
w2h_desired_ratio = (xr[1] - xr[0]) / (yr[1] - yr[0])
# self.aspect_ratio = WIDTH/HEIGHT
# print('DESIRED', w2h_desired_ratio )
# print('CURRENT', w/h )
if w / h < w2h_desired_ratio:
# h = w / w2h_desired_ratio
scale = w / (xr[1] - xr[0])
else:
# w = h * w2h_desired_ratio
scale = h / (yr[1] - yr[0])
# print('FIXED', w/h )
# print('FIXED', w/h, 'w={},h={},scale={}'.format(w,h,scale) )
tform = QTransform()
tform.translate(self.width() / 2.0, self.height() / 2.0)
tform.scale(1.0, -1.0)
painter.setTransform(tform)
for color in self.edgeList:
c = QColor(color[0], color[1], color[2])
painter.setPen(c)
for edge in self.edgeList[color]:
ln = QLineF(scale * edge.x1(), scale * edge.y1(),
scale * edge.x2(), scale * edge.y2())
painter.drawLine(ln)
for color in self.edgeList:
c = QColor(color[0], color[1], color[2])
painter.setPen(c)
for edge in self.edgeList[color]:
# arrow_scale = .015
arrow_scale = 5.0
unit_edge = (edge.x2() - edge.x1(), edge.y2() - edge.y1())
unit_edge_mag = math.sqrt((edge.x2() - edge.x1())**2 +
(edge.y2() - edge.y1())**2)
unit_edge = (unit_edge[0] / unit_edge_mag,
unit_edge[1] / unit_edge_mag)
unit_edge_perp = (-unit_edge[1], unit_edge[0])
temp_tform = QTransform()
temp_tform.translate(self.width() / 2.0, self.height() / 2.0)
temp_tform.scale(1.0, -1.0)
temp_tform.translate(scale * edge.x2(), scale * edge.y2())
temp_tform.scale(1.0, -1.0)
painter.setTransform(temp_tform)
# painter.drawText( RECT, label[1], align )
tri_pts = []
tri_pts.append(QPointF(0, 0))
tri_pts.append(
QPointF(
-arrow_scale * (2 * unit_edge[0] + unit_edge_perp[0]),
arrow_scale * (2 * unit_edge[1] + unit_edge_perp[1])))
tri_pts.append(
QPointF(
-arrow_scale * (2 * unit_edge[0] - unit_edge_perp[0]),
arrow_scale * (2 * unit_edge[1] - unit_edge_perp[1])))
tri = QPolygonF(tri_pts)
b = painter.brush()
painter.setBrush(c)
painter.drawPolygon(tri)
painter.setBrush(b)
painter.setTransform(tform)
font = QFont("Monospace")
font.setStyleHint(QFont.TypeWriter)
R = 1.0E3
CITY_SIZE = 2.0 # DIAMETER
RECT = QRectF(-R, -R, 2.0 * R, 2.0 * R)
align = QTextOption(Qt.Alignment(Qt.AlignHCenter | Qt.AlignVCenter))
for color in self.labelList:
c = QColor(color[0], color[1], color[2])
painter.setPen(c)
for label in self.labelList[color]:
temp_tform = QTransform()
temp_tform.translate(self.width() / 2.0, self.height() / 2.0)
temp_tform.scale(1.0, -1.0)
pt = label[0]
xoff = label[2]
temp_tform.translate(scale * pt.x() + xoff, scale * pt.y())
temp_tform.scale(1.0, -1.0)
painter.setTransform(temp_tform)
painter.drawText(RECT, label[1], align)
painter.setTransform(tform)
for color in self.pointList:
c = QColor(color[0], color[1], color[2])
painter.setPen(c)
b = painter.brush()
painter.setBrush(c)
for point in self.pointList[color]:
# pt = QPointF(w*point.x(), h*point.y())
pt = QPointF(scale * point.x(), scale * point.y())
painter.drawEllipse(pt, CITY_SIZE, CITY_SIZE)
painter.setBrush(b)
def draw_node(self, qp: QPainter, node_info: NodeItemOld):
background_color = node_info.get_background_color()
border_color = node_info.get_border_color()
border_width = node_info.get_border_width()
node_rect = node_info.get_node_rect()
pen = QPen(border_color)
pen.setWidth(border_width)
brush = QBrush()
brush.setColor(background_color)
brush.setStyle(1)
old_pen = qp.pen()
old_brush = qp.brush()
qp.setPen(pen)
qp.setBrush(brush)
qp.fillRect(node_rect, brush)
qp.drawRect(node_rect)
n_arg = len(node_info.node.arguments)
for i in range(n_arg):
rect = node_info.get_handle_rect(i, n_arg, -1)
text_rect = node_info.get_handle_text_rect(i, n_arg, -1)
pen = QPen(QColor(0, 0, 0))
brush = QBrush(QColor(255, 255, 255), 1)
if self.selected_handler_id is not None:
if self.selected_handler_id[0] == 0:
handler_node = self.selected_handler_id[2]
if handler_node == node_info:
if self.selected_handler_id[1] == i:
pen.setWidth(node_info.border_width_selected)
qp.setPen(pen)
qp.setBrush(brush)
qp.drawEllipse(rect)
qp.drawText(text_rect, node_info.text_height, "x")
pen = old_pen
n_res = len(node_info.node.results)
for i in range(n_res):
rect = node_info.get_handle_rect(i, n_res, 1)
text_rect = node_info.get_handle_text_rect(i, n_res, 1)
pen = QPen(QColor(0, 0, 0))
brush = QBrush(QColor(255, 255, 255), 1)
if self.selected_handler_id is not None:
if self.selected_handler_id[0] == 1:
handler_node = self.selected_handler_id[2]
if handler_node == node_info:
if self.selected_handler_id[1] == i:
pen.setWidth(node_info.border_width_selected)
qp.setPen(pen)
qp.setBrush(brush)
qp.drawEllipse(rect)
qp.drawText(text_rect, node_info.text_height, "a")
qp.setPen(old_pen)
qp.setBrush(old_brush)
def paint(self, painter: QPainter, option: QStyleOptionGraphicsItem,
widget: Optional[PyQt5.QtWidgets.QWidget] = ...):
painter.setPen(QPen(self.current_color, 1.0))
brush = QBrush(self.current_highlight_color)
pen = QPen(brush, 4)
painter.setPen(pen)
if self.highlighted:
painter.fillRect(self.boundingRect(), QBrush(self.current_highlight_color))
if self.frame_color is not None and self.mode != StickMode.Edit and self.mode != StickMode.EditDelete:
painter.setPen(QPen(self.frame_color, 4))
painter.drawRect(self.boundingRect())
pen = QPen(QColor(0, 255, 0, 255))
pen.setWidth(1.0)
pen.setColor(QColor(255, 0, 255, 255))
pen.setStyle(Qt.DotLine)
painter.setPen(pen)
off = 10
painter.drawLine(self.line.p1() - QPointF(0, off), self.line.p1() + QPointF(0, off))
painter.drawLine(self.line.p1() - QPointF(off, 0), self.line.p1() + QPointF(off, 0))
painter.drawLine(self.line.p2() - QPointF(0, off), self.line.p2() + QPointF(0, off))
painter.drawLine(self.line.p2() - QPointF(off, 0), self.line.p2() + QPointF(off, 0))
pen.setStyle(Qt.SolidLine)
pen.setColor(QColor(0, 255, 0, 255))
painter.setPen(pen)
if self.mode != StickMode.EditDelete:
pen.setWidth(2.0)
br = painter.brush()
painter.setPen(pen)
painter.drawEllipse(self.line.p1(), 10, 10)
painter.drawEllipse(self.line.p2(), 10, 10)
painter.setBrush(br)
if self.mode == StickMode.Measurement and self.proposed_snow_height >= 0:
point = QPointF(self.boundingRect().x(), -self.proposed_snow_height + self.line.p2().y())
pen = QPen(QColor(200, 100, 0, 255), 3.0)
painter.setPen(pen)
painter.drawLine(point,
point + QPointF(self.boundingRect().width(), 0.0))
if self.measured_height >= 0:
vec = (self.stick.top - self.stick.bottom) / np.linalg.norm(self.stick.top - self.stick.bottom)
dist_along_stick = self.measured_height / np.dot(np.array([0.0, -1.0]), vec)
point = self.line.p2() + dist_along_stick * QPointF(vec[0], vec[1])
point = QPointF(self.boundingRect().x(), point.y())
pen = QPen(QColor(0, 100, 200, 255), 3.0)
painter.setPen(pen)
painter.drawLine(point,
point + QPointF(self.boundingRect().width(), 0.0))
else:
painter.drawLine(self.line.p1(), self.line.p2())
if self.selected:
pen.setColor(QColor(255, 125, 0, 255))
pen.setStyle(Qt.DashLine)
painter.setPen(pen)
painter.drawRect(self.boundingRect().marginsAdded(QMarginsF(5, 5, 5, 5)))
if self.show_measurements:
painter.fillRect(self.stick_label_text.boundingRect().translated(self.stick_label_text.pos()),
QBrush(QColor(0, 0, 0, 120)))
def paint_line_numbers(self, event):
"""Paint the line numbers
For every visible block in the document draw it's corresponding line
number in the line numbers widget.
"""
painter = QPainter(self.line_numbers)
painter.fillRect(event.rect(), Qt.lightGray)
block = self.firstVisibleBlock()
block_number = block.blockNumber()
content_offset = self.contentOffset()
number_width = (self.line_numbers.width() -
self.line_numbers.padding_right)
number_height = self.fontMetrics().height()
breakpoint_size = 8
breakpoint_y_offset = number_height / 2 - breakpoint_size / 2
while block.isValid():
# Get the top coordinate of the current block
# to know where to paint the line number for it
block_top = (self.blockBoundingGeometry(block).translated(
content_offset).top())
if not block.isVisible() or block_top > event.rect().bottom():
break
line_number = block_number + 1
painter.setPen(Qt.black)
painter.drawText(0, block_top, number_width, number_height,
Qt.AlignRight, str(line_number))
# FIXME: Replace later with a corresponding method call from the
# breakpoints module
block_has_breakpoint = False
document_path = self.document_model.path
for breakpoint in pugdebug.Pugdebug.breakpoints:
if (breakpoint['local_filename'] == document_path
and int(breakpoint['lineno']) == line_number):
block_has_breakpoint = True
break
# If block has a breakpoint,
# draw a green rectangle by the line number
# if the line number matches the current line number
# make it red, as it is then a breakpoint hit
if block_has_breakpoint:
brush = painter.brush()
brush.setStyle(Qt.SolidPattern)
if line_number == self.current_line:
brush.setColor(Qt.red)
else:
brush.setColor(Qt.darkGreen)
painter.setBrush(brush)
painter.drawRect(
QRect(0, block_top + breakpoint_y_offset, breakpoint_size,
breakpoint_size))
block = block.next()
block_number += 1
painter.end()
def paint(self, painter: QPainter, option: QStyleOptionGraphicsItem, widget: QWidget=None):
fillColor = self.color.darker(150) if (option.state & QStyle.State_Selected) else self.color
if option.state & QStyle.State_MouseOver:
fillColor = fillColor.lighter(125)
lod = option.levelOfDetailFromTransform(painter.worldTransform())
if lod < 0.2:
if lod < 0.125:
painter.fillRect(QRectF(0, 0, 110, 70), fillColor)
return
b = painter.brush()
painter.setBrush(fillColor)
painter.drawRect(13, 13, 97, 57)
painter.setBrush(b)
return
oldPen = painter.pen()
pen = oldPen
width = 0
if option.state & QStyle.State_Selected:
width += 2
pen.setWidth(width)
b = painter.brush()
f = 120 if option.state & QStyle.State_Sunken else 100
painter.setBrush(QBrush(fillColor.darker(f)))
painter.drawRect(QRect(14, 14, 79, 39))
painter.setBrush(b)
if lod >= 1:
painter.setPen(QPen(Qt.gray, 1))
painter.drawLine(15, 54, 94, 54)
painter.drawLine(94, 53, 94, 15)
painter.setPen(QPen(Qt.black, 0))
if lod >= 2:
font = QFont("Times", 10)
font.setStyleStrategy(QFont.ForceOutline)
painter.setFont(font)
painter.save()
painter.scale(0.1, 0.1)
painter.drawText(170, 180, "Model: VSC-2000 (Very Small Chip) at {}x{}".format(self.x, self.y))
painter.drawText(170, 200, "Serial number: DLWR-WEER-123L-ZZ33-SDSJ")
painter.drawText(170, 220, "Manufacturer: Chip Manufacturer")
lines = []
if lod >= 0.5:
for i in np.arange(0, 10, 1 if lod > 0.5 else 2):
lines.append(QLineF(18 + 7 * i, 13, 18 + 7 * i, 5))
lines.append(QLineF(18 + 7 * i, 54, 18 + 7 * i, 62))
for i in np.arange(0, 6, 1 if lod > 0.5 else 2):
lines.append(QLineF(5,18 + 5 * i, 13, 18 + 5 * i))
lines.append(QLineF(94, 18 + 5 * i, 102, 18 + 5 * i))
if lod >= 0.4:
lineData = [
QLineF(25, 35, 35, 35),
QLineF(35, 30, 35, 40),
QLineF(35, 30, 45, 35),
QLineF(35, 40, 45, 35),
QLineF(45, 30, 45, 40),
QLineF(45, 35, 55, 35),
]
lines.extend(lineData)
painter.drawLines(lines)
if len(self.stuff) > 1:
p = painter.pen()
painter.setPen(QPen(Qt.red, 1, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin))
painter.setBrush(Qt.NoBrush)
path = QPainterPath()
path.moveTo(self.stuff[0])
for i in np.arange(len(self.stuff)):
path.lineTo(self.stuff[i])
painter.drawPath(path)
painter.setPen(p)
