def drawTitle(self, painter: QPainter) -> None:
painter.save()
painter.setPen(Qt.NoPen)
painter.setBrush(self.__tempColor)
offset: int = self.__borderWidth - self.__borderWidth // 3
rect: QRect = QRect(offset, offset, self.width() - offset * 2, self.__titleHeight)
painter.drawRect(rect)
# 绘制标题文字
if self.__isEnable:
painter.setPen(self.__alarmTextColor if self.__isAlarm else self.__titleColor)
else:
painter.setPen(self.__titleDisableColor)
painter.setFont(self.__titleFont)
# 文字区域要重新计算
offset = self.__borderWidth * 3
textRect: QRect = QRect(offset, 0, self.width() - offset * 2, self.__titleHeight)
align: Qt.Alignment = Qt.Alignment
if self.__titleAlignment == PanelItem.Alignment.Alignment_Left:
align = Qt.AlignLeft | Qt.AlignVCenter
elif self.__titleAlignment == PanelItem.Alignment.Alignment_Center:
align = Qt.AlignHCenter | Qt.AlignVCenter
elif self.__titleAlignment == PanelItem.Alignment.Alignment_Right:
align = Qt.AlignRight | Qt.AlignVCenter
painter.drawText(textRect, align, self.__titleText)
painter.restore()
def paintEvent(
self, event
): # c нуля перезаписываем paintEvent, который есть в родителе
painter = QPainter(self)
reset_brush = painter.brush()
for figure in self.__figures:
if not isinstance(figure, Figure):
continue
if isinstance(figure, Rectangle):
painter.setBrush(QBrush(Qt.red))
painter.drawRect(
figure.x, figure.y, figure.width, figure.height
) # не нужны круглые скобки, так как это свойства (property)
continue
if isinstance(figure, Ellipse):
painter.setBrush(QBrush(Qt.green))
painter.drawEllipse(figure.x, figure.y, figure.width,
figure.height)
continue
if isinstance(figure, CloseFigure):
painter.setBrush(QBrush(Qt.blue))
points = [] # точки, которые будем передавать в drawPolygon
# d - это список. Каждый поинт - отдельный словарь
for point in figure.d:
points.append(QPoint(point['x'], point['y']))
painter.drawPolygon(points)
continue
def paintEvent(self, event: QPaintEvent):
p = QPainter(self)
p.setBrush(QtCore.Qt.blue)
p.drawRect(10, 10, self.width() - 20, self.height() - 20)
p.setBrush(QtCore.Qt.yellow)
p.drawEllipse(20, 20, self.width() - 40, self.height() - 40)
p.save()
p.translate(self.width() / 2,
self.height() / 2) # permet de centrer l'aiguille
p.save()
p.save()
p.rotate(270 + (360 / 60) * self.sec)
penSec = QPen(QtCore.Qt.black, 1)
p.setPen(penSec)
p.drawLine(0, 0, (self.width() - 40) / 3, 0)
p.restore()
p.rotate(270 + (360 / 60) * self.min)
penMin = QPen(QtCore.Qt.black, 3)
p.setPen(penMin)
p.drawLine(0, 0, (self.width() - 40) / 3, 0)
p.restore()
p.rotate(
270 + (360 / 12) * (self.hour) + ((360 / 60) * (self.min)) / 30
) # formule a trouver pour avoir une aiguille qui tourne progressivement
penHour = QPen(QtCore.Qt.black, 5)
p.setPen(penHour)
p.drawLine(0, 0, (self.width() - 40) / 5, 0)
p.restore()
p.setBrush(QtCore.Qt.magenta)
p.drawEllipse((self.width() / 2) - 20, (self.height() / 2) - 20, 40,
40)
def paintEvent(self, event: QPaintEvent):
p = QPainter(self)
p.setBrush(QtCore.Qt.blue)
taille = min(self.width(), self.height())
p.drawRect(10, 10, taille - 20, taille - 20)
p.setBrush(QtCore.Qt.yellow)
p.drawEllipse(20, 20, taille - 40, taille - 40)
p.save()
p.translate(taille / 2, taille / 2)
p.rotate(135 + (self.valeur * 270 / 100))
pen = QPen(QtCore.Qt.black, 10)
p.setPen(pen)
p.drawLine(0, 0, (taille - 40) / 3, 0)
p.restore()
pen = QPen(QtCore.Qt.black, 5)
p.setPen(pen)
p.setBrush(QtCore.Qt.red)
p.drawEllipse((taille / 2) - 20, (taille / 2) - 20, 40, 40)
def paintEvent(self, event):
p = QPainter(self)
p.setRenderHint(QPainter.Antialiasing)
r = event.rect()
if self.is_revealed:
if self.is_start:
p.drawPixmap(r, QPixmap(IMG_START))
elif self.is_mine:
p.drawPixmap(r, QPixmap(IMG_BOMB))
elif self.adjacent_n > 0:
pen = QPen(NUM_COLORS[self.adjacent_n])
p.setPen(pen)
f = p.font()
f.setBold(True)
p.setFont(f)
p.drawText(r, Qt.AlignHCenter | Qt.AlignVCenter, str(self.adjacent_n))
else:
p.fillRect(r, QBrush(Qt.lightGray))
pen = QPen(Qt.gray)
pen.setWidth(1)
p.setPen(pen)
p.drawRect(r)
if self.is_flagged:
p.drawPixmap(r, QPixmap(IMG_FLAG))
def paintEvent(self, event:QPaintEvent):
p = QPainter(self)
p.setBrush(Qt.blue)
p.drawRect(10,10,self.width()-20, self.height()-20)
p.setBrush(Qt.yellow)
p.drawEllipse(20,20,self.width()-40, self.height()-40)
p.save()
p.translate(self.width()/2,self.height()/2)
p.save()
p.rotate((-90 + self.heure*30)+(self.minute)/2)
pen = QPen(Qt.green,10)
p.setPen(pen)
p.drawLine(0,0,(self.width()-40)/5,0)
p.restore()
p.rotate(-90 + self.minute*6)
pen = QPen(Qt.black, 10)
p.setPen(pen)
p.drawLine(0, 0, (self.width() - 40) / 3, 0)
p.restore()
p.setBrush(Qt.red)
p.drawEllipse((self.width()/2)-20,(self.height()/2)-20,40, 40)
def paintEvent(self, event: QPaintEvent):
super().paintEvent(event)
if self.needed_paint_rect_list:
painter = QPainter(self)
for rect, color in self.needed_paint_rect_list:
painter.setPen(color)
painter.drawRect(QRect(*rect))
def drawOverlay(self, painter: QPainter) -> None:
# 如果没有启用绘制遮住颜色或者当前不可用则不用绘制
if not self.__showOverlay or not self.isEnabled():
return
painter.save()
# 根据当前百分比计算高度
width: int = self.__bgRect.width() - self.__borderWidth
height: int = self.__bgRect.height() - self.__borderWidth
height = int(height - (self.__percent / 100) * height)
if self.__outMode:
overlayRect = QRect(self.__borderWidth,
self.__borderWidth + self.__percentHeight // 2,
width, height)
else:
overlayRect = QRect(self.__borderWidth, self.__borderWidth, width,
height)
painter.setPen(Qt.NoPen)
painter.setBrush(self.__overlayColor)
painter.drawRect(overlayRect)
painter.restore()
def paintEvent(self, *args):
painter = QPainter(self)
painter.setRenderHint(QPainter.HighQualityAntialiasing)
r = self.rect()
painter.fillRect(r, Qt.white)
for element in self.elements:
painter.translate(element.bounding_box.topLeft())
element.paint(painter)
painter.translate(-element.bounding_box.topLeft())
for wire in self.wires:
self._draw_wire(painter, wire)
painter.setPen(QPen(Qt.red, 1, Qt.DashLine))
painter.setBrush(Qt.transparent)
for element in self.selected_elements:
bb = element.bounding_box
bb = bb.marginsAdded(QMargins(2, 2, 1, 1))
painter.drawRect(bb)
if self.wiring_assistant:
painter.setPen(QPen(Qt.red, 1, Qt.PenStyle.DotLine))
for line in self.guidelines:
painter.drawLine(line)
painter.setPen(QPen(Qt.red, 1, Qt.PenStyle.SolidLine))
for p in self.guidepoints:
painter.drawEllipse(p.x() - 4, p.y() - 4, 8, 8)
if self.closest_point is not None:
p = self.closest_point
painter.drawEllipse(p.x() - 4, p.y() - 4, 8, 8)
def redraw(self):
"""
Re-draws the buttons. May be called as initialization method too.
"""
# Pixmap that contains the painter and the DR
canvas = QPixmap("assets/" + self.digirule.get_img_name())
self.setPixmap(canvas)
painter = QPainter(self.pixmap(
)) # Create a painter in which buttons and LEDs are drawn
translate_matrix = QMatrix()
offset_scale = self.digirule.get_scale_offset()
translate_matrix.scale(offset_scale[0], offset_scale[1])
painter.setMatrix(translate_matrix)
# Drawing
pen = QPen()
pen.setWidth(self.digirule.get_buttons_width())
pen.setColor(QColor(0, 0, 0, 0)) # Buttons color
painter.setPen(pen)
# Buttons
for btn in self.digirule.get_buttons_positions_dic():
painter.drawPoint(QPoint(btn[0], btn[1]))
pen.setWidth(2)
painter.setPen(pen)
for btn in self.digirule.get_special_buttons_rects_dic():
# Draw rectangle given the top-left and bottom-right corners coordinates
painter.drawRect(self._build_rect(btn))
def paintEvent(self, event):
super(PixmapWidget, self).paintEvent(event)
if not self.pixmap or self.pixmap.isNull():
return
p = QPainter(self)
source = QRect(0, 0, self.pixmap.width(), self.pixmap.height())
sw = float(source.width())
sh = float(source.height())
tw = float(self.width())+1
th = float(self.height())+1
tx = 0
ty = 0
if sw/tw > sh/th:
ntw = tw
nth = sh/sw*tw
ty = (th-nth)/2
else:
nth = th
ntw = sw/sh*th
tx = (tw-ntw)/2
target = QRect(tx, ty, ntw, nth)
p.setBrush(self.bgBrush)
p.setPen(self.bgPen)
p.drawRect(self.rect())
p.drawPixmap(target, self.pixmap, source)
def _draw_objects(self, painter: QPainter, level: Level):
for level_object in level.get_all_objects():
level_object.render()
if level_object.description.lower() in SPECIAL_BACKGROUND_OBJECTS:
width = LEVEL_MAX_LENGTH
height = GROUND - level_object.y_position
blocks_to_draw = [level_object.blocks[0]] * width * height
for index, block_index in enumerate(blocks_to_draw):
x = level_object.x_position + index % width
y = level_object.y_position + index // width
level_object._draw_block(painter, block_index, x, y, self.block_length, False)
else:
level_object.draw(painter, self.block_length, self.transparency)
if level_object.selected:
painter.save()
painter.setPen(QPen(QColor(0x00, 0x00, 0x00, 0x80), width=1))
painter.drawRect(level_object.get_rect(self.block_length))
painter.restore()
def paintEvent(self, event):
"""
Redraw application.
"""
super(TileSelector, self).paintEvent(event)
painter = QPainter(self)
painter.setPen(QColor(127, 127, 127))
painter.drawPixmap(0, 0,
self.pixmap.size().width() * self.scale,
self.pixmap.size().height() * self.scale,
self.pixmap)
for y in range(0, self.pixmap.size().height(), self.tile_size[1]):
for x in range(0, self.pixmap.size().width(), self.tile_size[0]):
painter.drawRect(x * self.scale, y * self.scale,
self.tile_size[0] * self.scale,
self.tile_size[1] * self.scale)
x, y = self.get_tile_map_coords(self.main.tile)
painter.setPen(QColor(200, 0, 0))
painter.drawRect(x * self.scale, y * self.scale,
self.tile_size[0] * self.scale,
self.tile_size[1] * self.scale)
painter.end()
def drawElts(self,elt_list,colorElt,colotTxt):
for elt in elt_list :
l_pp = self.getRealFromUiCoord(elt.getX(),elt.getY())
eltP = QPainter()
eltP.begin(self)
eltP.setBrush(QBrush(QColor(colorElt)))
myPen = QPen()
myPen.setBrush(QBrush(QColor(colotTxt)))
if 'rect' in elt.getID() :
l_pw = elt.getWidth()/self.scaleFactor
l_pl = elt.getLength()/self.scaleFactor
eltP.drawRect(l_pp.getX()-(l_pw/2),l_pp.getY()-(l_pl/2),l_pw,l_pl)
eltP.setPen(myPen)
eltP.drawText(l_pp.getX()-(l_pw/4),l_pp.getY(),l_pw,l_pl,1,elt.getID())
elif 'circle' in elt.getID() :
l_pr = elt.getRayon()/self.scaleFactor
eltP.drawEllipse(l_pp.getX()-(l_pr/2),l_pp.getY()-(l_pr/2),l_pr,l_pr)
eltP.setPen(myPen)
eltP.drawText(l_pp.getX()-l_pr/3,l_pp.getY(),l_pr,l_pr,1,elt.getID())
else :
pass
eltP.end()
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: QtGui.QPainter,
option: QtWidgets.QStyleOptionGraphicsItem,
widget: QtWidgets.QWidget = None,
):
view = self.scene().views()[0]
view_width = view.mapToScene(0, 0, self.width,
1).boundingRect().width()
width, unit = self.getWidthAndUnit(view_width)
# Current scale
text = f"{width * self.units[self.unit] / self.units[unit]:.3g} {unit}"
width = width * view.transform().m11()
fm = QtGui.QFontMetrics(self.font, painter.device())
path = QtGui.QPainterPath()
path.addText(
self.width / 2.0 - fm.boundingRect(text).width() / 2.0,
fm.ascent(),
self.font,
text,
)
painter.strokePath(path, QtGui.QPen(QtCore.Qt.black, 2.0))
painter.fillPath(path, QtGui.QBrush(self.color,
QtCore.Qt.SolidPattern))
# Draw the bar
rect = QtCore.QRectF(self.width / 2.0 - width / 2.0, fm.height(),
width, self.height)
painter.setPen(QtGui.QPen(QtCore.Qt.black, 1.0))
painter.setBrush(QtGui.QBrush(self.color, QtCore.Qt.SolidPattern))
painter.drawRect(rect)
def update(self, new_vals):
self.values = new_vals
painter = QPainter(self.label.pixmap())
painter.setRenderHint(QPainter.Antialiasing)
painter.setPen(QPen('#333333'))
painter.setBrush(QColor('#333333'))
painter.drawRect(self.label.rect())
pen = QPen(QColor(255, 255, 255))
pen.setWidth(1)
painter.setPen(pen)
painter.setBrush(QBrush(Qt.white))
x_old = -1
y_old = -1
for i in range(len(self.values)):
v = self.values[i]
x = i * (self.label.width() / len(self.values))
y = self.label.height() - self.label.height() * v
if self.connect_lines_check_box.isChecked() and i > 0:
painter.drawLine(x_old, y_old, x, y)
else:
painter.drawEllipse(x - 1, y - 1, 2, 2)
x_old = x
y_old = y
self.repaint()
def paintEvent(self, event: QPaintEvent):
painter = QPainter(self)
bg_color = bg_color_for_object_set(self.object_set, 0)
painter.setBrush(QBrush(bg_color))
painter.drawRect(QRect(QPoint(0, 0), self.size()))
pattern_table = PatternTable(self.object_set)
palette = load_palette(self.object_set, 0)
tsa_data = ROM.get_tsa_data(self.object_set)
horizontal = self.sprites_horiz
block_length = Block.WIDTH * self.zoom
for i in range(self.sprites):
block = Block(i, palette, pattern_table, tsa_data)
x = (i % horizontal) * block_length
y = (i // horizontal) * block_length
block.draw(painter, x, y, block_length)
return
def paintEvent(self, event):
rect = QRect(0, 0, self.w - 1, self.h - 1)
p = QPainter(self)
p.setPen(QPen(Qt.black))
p.setBrush(self.color)
if self.type == 1:
p.drawRect(0, 0, self.w - 1, self.h - 1)
p.drawText(
rect, Qt.AlignCenter, self.text
) # 이게 더 좋은데? 어떤 방식이지? => # w.setGeometry(self.geometry()) 차이점이 무엇이지?
elif self.type == 2:
p.drawEllipse(0, 0, self.w - 1, self.h - 1)
p.drawText(rect, Qt.AlignCenter, self.text)
elif self.type == 3:
p.drawEllipse(0, 0, self.w - 1, self.h - 1)
p.drawText(rect, Qt.AlignCenter, self.text)
elif self.type == 4:
points = [
QPoint(self.w / 2, 0),
QPoint(0, self.h / 2),
QPoint(self.w / 2, self.h),
QPoint(self.w, self.h / 2)
]
poly = QPolygon(points)
p.drawPolygon(poly)
self.update() # self.update()
def paintEvent(self, event):
painter = QPainter(self)
reset_brush = painter.brush()
for figure in self.__figures:
if not isinstance(figure, Figure):
continue
if isinstance(figure, Rectangle):
painter.setBrush(QBrush(Qt.red))
painter.drawRect(figure.x, figure.y, figure.width,
figure.height)
continue
if isinstance(figure, Ellipse): # ждёт прямоугольник
painter.setBrush(QBrush(Qt.green))
painter.drawEllipse(figure.x, figure.y, figure.width,
figure.height)
continue
if isinstance(figure, CloseFigure):
painter.setBrush(QBrush(Qt.blue))
points = []
for point in figure:
points.append(QPoint(point['x'], point['y']))
painter.drawPolygon(points)
continue
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: QPainter, model: ShipModel = None):
assert self.is_set, 'Painter is not set'
# Draw ship
if model.is_alive:
_ship = self._ship_alive
else:
_ship = self._ship_dead
_pixmap = _ship.transformed(model.transform,
mode=Qt.SmoothTransformation)
_center_ship = self.transform(model.x - _pixmap.width() / 2,
model.y + _pixmap.height() / 2,
is_point=True)
if 0 <= _center_ship.x() <= self.parent.width(
) and 0 <= _center_ship.y() <= self.parent.height():
painter.drawPixmap(_center_ship, _pixmap)
# Draw life bar
_center_bar = self.transform(model.x - self._life_bar_xy[0],
model.y + self._life_bar_xy[1],
is_point=True)
painter.setPen(QPen(QColor(255, 0, 0), 0, Qt.NoPen))
painter.setBrush(QBrush(QColor(255, 0, 0)))
painter.drawRect(_center_bar.x(), _center_bar.y(),
self._life_bar_width, 5)
painter.setBrush(QBrush(QColor(0, 255, 0)))
painter.drawRect(_center_bar.x(), _center_bar.y(),
int(self._life_bar_width * model.life), 5)
painter.setPen(QPen(QColor(*model.color), 5, Qt.SolidLine))
_center_title = self.transform(model.x - 100,
model.y + 70,
is_point=True)
painter.setFont(
QFont('Open Sans', weight=QFont.Normal, pointSize=8))
painter.drawText(
QRect(_center_title.x(), _center_title.y(), 200, 25),
Qt.AlignHCenter | Qt.AlignTop, '<{}>'.format(model.name))
painter.setBrush(QBrush(QColor(*model.color)))
_center_point = self.transform(model.x, model.y, is_point=True)
painter.drawPoint(_center_point)
else:
_xy = QPoint(_center_ship)
if _center_ship.x() < 0:
_xy.setX(0)
if self.parent.width() < _center_ship.x():
_xy.setX(self.parent.width())
if _center_ship.y() < 0:
_xy.setY(0)
if self.parent.height() < _center_ship.y():
_xy.setY(self.parent.height())
painter.setPen(QPen(QColor(0, 0, 0), 30, Qt.SolidLine,
Qt.RoundCap))
painter.drawPoint(_xy)
painter.setPen(
QPen(QColor(*model.color), 25, Qt.SolidLine, Qt.RoundCap))
painter.drawPoint(_xy)
def paintEvent(self, event):
s = self.size()
qp = QPainter()
qp.begin(self)
qp.setRenderHint(QPainter.Antialiasing, True)
qp.setPen(self.penColor)
qp.setBrush(self.fillColor)
qp.drawRect(0, 0, s.width(), s.height())
if self.drawDrag:
pen = QPen(Qt.white, 5)
pen.setCapStyle(Qt.RoundCap)
qp.setPen(pen)
qp.setBrush(self.fillColor)
outerWidth = s.width() - 60
outerHeight = s.height() - 60
ow = int(s.width() / 2 - outerWidth / 2)
oh = int(s.height() / 2 - outerHeight / 2)
qp.drawRoundedRect(ow, oh, outerWidth, outerHeight, 5, 5)
qp.setBrush(Qt.white)
thickness = 12
length = 50
roundness = thickness / 2
vS = int(s.width() / 2 - thickness / 2)
vE = int(s.height() / 2 - length / 2)
qp.drawRoundedRect(vS, vE, thickness, length, roundness, roundness)
hS = int(s.width() / 2 - length / 2)
hE = int(s.height() / 2 - thickness / 2)
qp.drawRoundedRect(hS, hE, length, thickness, roundness, roundness)
qp.end()
def paint(self, painter: QPainter, option, widget):
pen = QPen(self.color, self.penWidth)
if self.isSelected():
pen.setStyle(Qt.DashLine)
pen.setCosmetic(True)
painter.setPen(pen)
painter.drawRect(self.rect())
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 paintEvent(self, event):
painter = QPainter(self)
painter.fillRect(self.rect(), QBrush(self._color_srgb))
painter.setCompositionMode(QPainter.RasterOp_SourceXorDestination)
pen = QPen(QBrush(Qt.white), 2., Qt.SolidLine, Qt.SquareCap,
Qt.MiterJoin)
painter.setPen(pen)
painter.drawRect(self.rect().adjusted(1, 1, -1, -1))
def paintEvent (self, event:QPaintEvent):
p = QPainter(self)
p.setBrush(QtCore.Qt.blue)
p.drawRect (10, 10, self.width()-20, self.height()-20)
p.setBrush(QtCore.Qt.yellow)
p.drawEllipse(20,20,self.width()-40, self.height()-40)
p.setBrush(QtCore.Qt.green)
p.drawEllipse(30,30,self.width()-60, self.height()-60 )
def paintEvent(self, event:QPaintEvent):
p = QPainter(self)
p.setBrush(QtCore.Qt.darkBlue)
p.drawRect(10,10,self.width()-20, self.height()-20)
p.setBrush(QtCore.Qt.white)
p.drawEllipse(20,20,self.width()-40, self.height()-40)
p.save()
p.translate(self.width()/1.4, self.height()/1.4)
p.rotate(270+self.valeurMSec*0.36)
pen = QPen(QtCore.Qt.black, 2, QtCore.Qt.SolidLine, QtCore.Qt.RoundCap)
p.setPen(pen)
p.drawLine(0, 0, (self.width()-40)/6, 0)
p.restore()
p.save()
p.translate(self.width()/2, self.height()/2)
p.rotate(270+self.valeurSec*6)
pen = QPen(QtCore.Qt.black, 6, QtCore.Qt.DashDotDotLine, QtCore.Qt.RoundCap)
p.setPen(pen)
p.drawLine(0, 0, (self.width()-40)/3, 0)
p.restore()
p.save()
p.translate(self.width() / 2, self.height() / 2)
p.rotate(270 + self.valeurMin * 6)
pen = QPen(QtCore.Qt.green, 10, QtCore.Qt.SolidLine, QtCore.Qt.RoundCap)
p.setPen(pen)
p.drawLine(0, 0, (self.width() - 40) / 3, 0)
p.restore()
p.save()
p.translate(self.width() / 2, self.height() / 2)
p.rotate(270 + self.valeurHeu * 30)
pen = QPen(QtCore.Qt.red, 10, QtCore.Qt.SolidLine, QtCore.Qt.RoundCap)
p.setPen(pen)
p.drawLine(0, 0, (self.width() - 200) / 3, 0)
p.restore()
p.setBrush(QtCore.Qt.red)
p.drawEllipse((self.width()/2)-20, (self.height()/2)-20, 40, 40)
def drawBg(self, painter: QPainter) -> None:
painter.save()
painter.setPen(Qt.NoPen)
bgGradient: QLinearGradient = QLinearGradient(QPoint(0, 0), QPoint(0, self.height()))
bgGradient.setColorAt(0.0, self.__bgColorStart)
bgGradient.setColorAt(1.0, self.__bgColorEnd)
painter.setBrush(bgGradient)
painter.drawRect(self.rect())
painter.restore()
def paintEvent(self, event):
super().paintEvent(event)
p = QPainter(self)
p.fillRect(QRect(0, 0, self.PageWidth, self.PageHeight), Qt.white)
p.setFont(QFont("微软雅黑", pointSize=10))
p.setPen(Qt.black)
p.drawRect(self.PageHorizontalMargin, self.PageVerticalMargin,
self.PageContentWidth, self.PageContentHeight)
p.drawText(QPoint(0, self.PageVerticalMargin), str(self.PageNumber))
def mouseReleaseEvent(self, event):
if (Qt.LeftButton & self.drawing):
self.lastPoint = event.pos()
print(self.startPoint)
painter = QPainter()
painter.setPen(
QPen(self.brushColor, self.brushSize, Qt.SolidLine,
Qt.RoundCap, Qt.RoundJoin))
painter.drawRect(QtCore.QRect(self.startPoint, self.lastPoint))
self.update()
def drawSnake(self, qp: QtGui.QPainter):
qp.setPen(QtGui.QColor(255, 255, 255))
qp.setBrush(SNAKECOLOR)
for i in self.snakeArray:
qp.drawRect(
(i[0]) * self.snakeSize,
(i[1]) * self.snakeSize,
self.snakeSize,
self.snakeSize
)
def paint(self, painter: QPainter, styleOption: QStyleOptionGraphicsItem, widget: QWidget=None):
pen = QPen()
pen.setWidthF(0.05)
pen.setColor(Qt.darkGray)
painter.setPen(pen)
brush = QBrush()
brush.setColor(self.color)
brush.setStyle(Qt.SolidPattern)
painter.setBrush(brush)
topLeft = QPointF(0, 0)
bottomRight = QPointF(1, 1)
rectangle = QRectF(topLeft, bottomRight)
rectangle.translate(-0.5, -0.5)
painter.drawRect(rectangle)
def paintEvent(self, event):
painter = QPainter(self)
painter.fillRect(self.rect(), Qt.black)
if self.pixmap.isNull():
painter.setPen(Qt.white)
painter.drawText(self.rect(), Qt.AlignCenter,
"Rendering initial image, please wait...")
return
if self.curScale == self.pixmapScale:
painter.drawPixmap(self.pixmapOffset, self.pixmap)
else:
scaleFactor = self.pixmapScale / self.curScale
newWidth = int(self.pixmap.width() * scaleFactor)
newHeight = int(self.pixmap.height() * scaleFactor)
newX = self.pixmapOffset.x() + (self.pixmap.width() - newWidth) / 2
newY = self.pixmapOffset.y() + (self.pixmap.height() - newHeight) / 2
painter.save()
painter.translate(newX, newY)
painter.scale(scaleFactor, scaleFactor)
exposed, _ = painter.matrix().inverted()
exposed = exposed.mapRect(self.rect()).adjusted(-1, -1, 1, 1)
painter.drawPixmap(exposed, self.pixmap, exposed)
painter.restore()
text = "Use mouse wheel or the '+' and '-' keys to zoom. Press and " \
"hold left mouse button to scroll."
metrics = painter.fontMetrics()
textWidth = metrics.width(text)
painter.setPen(Qt.NoPen)
painter.setBrush(QColor(0, 0, 0, 127))
painter.drawRect((self.width() - textWidth) / 2 - 5, 0, textWidth + 10,
metrics.lineSpacing() + 5)
painter.setPen(Qt.white)
painter.drawText((self.width() - textWidth) / 2,
metrics.leading() + metrics.ascent(), text)
