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 paintEvent(self, paintEvent: QPaintEvent):
painter = QPainter(self)
painter.setBackgroundMode(Qt.TransparentMode)
painter.setRenderHint(QPainter.Antialiasing)
brush = QBrush()
brush.setStyle(Qt.SolidPattern)
pen = QPen()
pen.setJoinStyle(Qt.RoundJoin)
pen.setCapStyle(Qt.RoundCap)
center = QPoint(self.width() // 2, self.height() // 2)
radius = 0.45 * min(self.width(), self.height())
pen.setColor(self.palette().color(self.color[0]))
brush.setColor(self.palette().color(self.color[1]))
if self.highlight is True:
pen.setColor(self.palette().color(QPalette.Highlight))
pen.setWidth(round(0.15 * radius))
painter.setBrush(brush)
painter.setPen(pen)
painter.drawEllipse(center, radius, radius)
if self.checked is True:
brush.setColor(self.palette().color(QPalette.Background))
pen.setColor(self.palette().color(QPalette.Background))
painter.setPen(pen)
painter.setBrush(brush)
painter.drawEllipse(center, 0.40 * radius, 0.40 * radius)
del painter, brush, pen
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 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 createDropTextPixmap(self):
pixmap = QPixmap(481, 300)
pixmap.fill(QColor("#333333"))
painter = QPainter(pixmap)
font = QFont("Arial")
font.setPixelSize(28)
font.setBold(True)
fm = QFontMetrics(font)
painter.setFont(font)
painter.setPen(QPen(QColor("#888888"), 1))
text = "Drop the tileset image here"
x = (pixmap.width()-fm.width(text))/2
y = (pixmap.height()+fm.height())/2
painter.drawText(x, y, text)
del painter
return pixmap
def paintEvent(self, event):
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing, self.antialiased)
painter.translate(self.width() / 2, self.height() / 2)
for diameter in range(0, 256, 9):
delta = abs((self.frameNo % 128) - diameter / 2)
alpha = 255 - (delta * delta) / 4 - diameter
if alpha > 0:
painter.setPen(QPen(QColor(0, diameter / 2, 127, alpha), 3))
if self.floatBased:
painter.drawEllipse(QRectF(-diameter / 2.0,
-diameter / 2.0, diameter, diameter))
else:
painter.drawEllipse(QRect(-diameter / 2,
-diameter / 2, diameter, diameter))
def lineComponent(self):
linePainter = QPainter(self)
linePainter.setRenderHint(QPainter.Antialiasing)
penLine = QPen()
penLine.setStyle(self.rpb_lineStyle)
penLine.setWidth(self.lineWidth)
penLine.setBrush(
QColor(self.lineColor[0], self.lineColor[1], self.lineColor[2]))
penLine.setCapStyle(self.rpb_lineCap)
penLine.setJoinStyle(Qt.RoundJoin)
linePainter.setPen(penLine)
linePainter.drawArc(self.positionX + self.posFactor,
self.positionY + self.posFactor,
self.rpb_Size - self.sizeFactor,
self.rpb_Size - self.sizeFactor,
self.startPosition, self.rpb_value)
linePainter.end()
def paintEvent(self, event):
super(QtBubbleLabel, self).paintEvent(event)
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing) # 抗锯齿
rectPath = QPainterPath() # 圆角矩形
height = self.height() - 8 # 往上偏移8
rectPath.addRoundedRect(QRectF(0, 0, self.width(), height), 5, 5)
x = self.width() / 5 * 4
# 边框画笔
painter.setPen(
QPen(self.BorderColor, 1, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin))
# 背景画刷
painter.setBrush(self.BackgroundColor)
# 绘制形状
painter.drawPath(rectPath)
def eventFilter(self, watched: PySide2.QtCore.QObject,
event: PySide2.QtCore.QEvent):
if watched is self.scroll_area_content and type(event) is QPaintEvent:
normal_font = PySide2.QtGui.QFont('MS Shell Dlg 2', 14)
underlined_font = PySide2.QtGui.QFont('MS Shell Dlg 2', 14)
underlined_font.setUnderline(True)
normal_pen = QPen(PySide2.QtGui.QColor(0, 0, 0))
dotted_pen = QPen(normal_pen)
dotted_pen.setStyle(PySide2.QtCore.Qt.DashDotDotLine)
p = QPainter()
p.begin(self.scroll_area_content)
p.setPen(normal_pen)
p.setFont(normal_font)
p.drawLine(250, 75, 500, 75)
p.drawLine(375, 25, 375, 250)
p.drawLine(200, 250, 550, 250)
p.drawLine(200, 250, 200, 400)
p.drawLine(550, 250, 550, 325)
p.drawLine(175, 400, 225, 400)
p.drawText(312, 50, "T")
p.drawText(437, 50, "F")
p.drawText(400, 170, "A")
p.drawText(150, 350, "A")
p.setFont(underlined_font)
p.drawText(400, 120, "A|!A&(B|!C)")
p.drawText(400, 220, "!A&(B|!C)")
p.drawText(225, 300, "!A")
p.drawText(575, 300, "B|!C")
p.setPen(dotted_pen)
p.drawLine(550, 325, 550, 480)
p.drawLine(550, 325, 725, 325)
p.end()
self.scroll_area_content.setMinimumSize(800, 550)
return False
def paintEvent(self, event: QPaintEvent) -> None:
path = QPainterPath()
path.moveTo(20, 80)
path.lineTo(20, 30)
path.cubicTo(80, 0, 50, 50, 80, 80)
painter = QPainter(self)
painter.setPen(self.pen)
painter.setBrush(self.brush)
painter.setRenderHint(QPainter.Antialiasing, True)
x_inc = int(self.width() /
(len(self.sb20.chainrings()) + len(self.sb20.cogs()) + 3))
w = int(2 * x_inc / 3)
x = x_inc
h_max = self.height() * 0.9
y_0 = self.height() * 0.05
factor = h_max / self.sb20.chainrings()[-1]
for chainring in self.sb20.chainrings():
h = chainring * factor
r = QRect(x, int(y_0 + (h_max - h) / 2), w, int(h))
if self.sb20.service_connected(
) and chainring == self.sb20.chainring_size():
painter.setBrush(Qt.SolidPattern)
else:
painter.setBrush(Qt.NoBrush)
painter.drawRoundedRect(r, 25, 25, Qt.RelativeSize)
x += x_inc
x = self.width() - (len(self.sb20.cogs()) + 1) * x_inc
factor = h_max / self.sb20.cogs()[0]
for cog in self.sb20.cogs():
h = cog * factor
r = QRect(x, int(y_0 + (h_max - h) / 2), w, int(h))
if self.sb20.service_connected() and cog == self.sb20.cog_size():
painter.setBrush(Qt.SolidPattern)
else:
painter.setBrush(Qt.NoBrush)
painter.drawRoundedRect(r, 25, 25, Qt.RelativeSize)
x += x_inc
painter.setRenderHint(QPainter.Antialiasing, False)
painter.setPen(self.palette().dark().color())
painter.setBrush(Qt.NoBrush)
painter.drawRect(QRect(0, 0, self.width() - 1, self.height() - 1))
def drawLines(self, qp: QPainter):
pen = QPen(Qt.black, 2, Qt.SolidLine)
qp.setPen(pen)
# Draw player
self._game_controller.get_user_cube().draw_cube(qp)
# Box of the room
qp.drawLine(0, 0, self.size().width(), 0)
qp.drawLine(self.size().width(), 0,
self.size().width(),
self.size().height())
qp.drawLine(self.size().width(),
self.size().height(), 0,
self.size().height())
qp.drawLine(0, self.size().height(), 0, 0)
# Draw bad and room
# My room
qp.drawLine(0, 200, 100, 200)
qp.drawLine(140, 200, 200, 200)
qp.drawLine(200, 200, 200, 0)
# Bad
qp.drawLine(0, 50, 100, 50)
qp.drawLine(100, 50, 100, 0)
# Draw schoolbag
qp.drawLine(200, 100, 150, 100)
qp.drawLine(150, 100, 150, 150)
qp.drawLine(150, 150, 200, 150)
# Draw toilet
qp.drawLine(200, 200, self.size().width() - 100, 200)
qp.drawLine(self.size().width() - 50, 200, self.size().width(), 200)
# Draw kitchen
qp.drawLine(0, 300, 200, 300)
qp.drawLine(200, 300, 200, self.size().height() - 150)
qp.drawLine(200, self.size().height() - 100, 200, self.size().height())
# Draw exist
qp.drawLine(self.size().width() - 100,
self.size().height(),
self.size().width() - 100,
self.size().height() - 50)
qp.drawLine(self.size().width() - 50,
self.size().height(),
self.size().width() - 50,
self.size().height() - 50)
def paintEvent(self, event):
"""
Redraw application.
"""
super(TileEd, self).paintEvent(event)
painter = QPainter(self)
painter.setPen(QColor(127, 127, 127))
# Only update the region that need updating
x1 = int(event.rect().x() // self.scale // self.tile_size[0]) - 1
y1 = int(event.rect().y() // self.scale // self.tile_size[1]) - 1
x2 = int(
event.rect().width() // self.scale // self.tile_size[0]) + x1 + 3
y2 = int(
event.rect().height() // self.scale // self.tile_size[1]) + y1 + 3
if x1 < 0:
x1 = 0
if y1 < 0:
y1 = 0
if x2 > self.size[0]:
x2 = self.size[0]
if y2 > self.size[1]:
y2 = self.size[1]
for y in range(y1, y2):
for x in range(x1, x2):
tile = self.get_tile(x, y)
posx, posy = self.get_tile_map_coords(tile)
painter.drawPixmap(x * self.tile_size[0] * self.scale,
y * self.tile_size[1] * self.scale,
self.tile_size[0] * self.scale,
self.tile_size[1] * self.scale, self.pixmap,
posx, posy, self.tile_size[0],
self.tile_size[1])
if self.show_grid:
painter.drawRect(x * self.tile_size[0] * self.scale,
y * self.tile_size[1] * self.scale,
self.tile_size[0] * self.scale,
self.tile_size[1] * self.scale)
painter.end()
def drawBorder(self, painter: QPainter) -> None:
if self.__borderWidth <= 0: return
painter.save()
pen: QPen = QPen()
pen.setWidth(self.__borderWidth)
pen.setColor(self.__tempColor)
painter.setPen(pen)
painter.setBrush(Qt.NoBrush)
rect: QRect = QRect(self.__borderWidth // 2,
self.__borderWidth // 2,
self.width() - self.__borderWidth,
self.height() - self.__borderWidth)
painter.drawRoundedRect(rect, self.__borderRadius, self.__borderRadius)
painter.restore()
def _draw_grid(self, painter: QPainter, level: Level):
panel_width, panel_height = level.get_rect(self.block_length).size().toTuple()
painter.setPen(self.grid_pen)
for x in range(0, panel_width, self.block_length):
painter.drawLine(x, 0, x, panel_height)
for y in range(0, panel_height, self.block_length):
painter.drawLine(0, y, panel_width, y)
painter.setPen(self.screen_pen)
if level.is_vertical:
for y in range(0, panel_height, self.block_length * SCREEN_HEIGHT):
painter.drawLine(0, y, panel_width, y)
else:
for x in range(0, panel_width, self.block_length * SCREEN_WIDTH):
painter.drawLine(x, 0, x, panel_height)
def drawValue(self, painter: QPainter) -> None:
if not self.__showValue: return
radius: int = 100
painter.save()
painter.setPen(self.__textColor)
font: QFont = QFont()
font.setPixelSize(radius - 50 if self.__showPointer else radius - 15)
font.setBold(True)
painter.setFont(font)
textRect: QRectF = QRectF(-radius, -radius, radius * 2, radius * 2)
value = round(self.__value, self.__precision)
strValue: str = str(
int(value)) if self.__precision is 0 else str(value)
painter.drawText(textRect, Qt.AlignCenter, strValue)
painter.restore()
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)#
p.rotate(135+self.valeur*2.7)
pen = QPen(QtCore.Qt.black,10)
p.setPen(pen)
p.drawLine(0,0,(self.width()-40)/4, 0)
p.restore()
p.setBrush(QtCore.Qt.red)
p.drawEllipse((self.width()/2)-20,(self.height()/2)-20,40,40)
def show_points(self, points):
self.points = points
painter = QPainter(self.label.pixmap())
painter.setRenderHint(QPainter.Antialiasing)
painter.setPen(QPen('#333333'))
painter.setBrush(QColor('#333333'))
painter.drawRect(self.rect())
pen = QPen(QColor(255, 255, 255))
painter.setPen(pen)
painter.setBrush(QBrush(Qt.white))
for p in self.points:
painter.drawEllipse(p['x'], p['y'], 4, 4)
self.repaint()
def drawValue(self, painter: QPainter) -> None:
painter.save()
painter.setPen(Qt.NoPen)
# 定义了画刷则取画刷,可以形成渐变效果
painter.setBrush(
QBrush(self.__valueColor if self.__valueBrush ==
Qt.NoBrush else self.__valueBrush))
# 计算当前值对应的百分比
step: float = self.__value / (self.__maxValue - self.__minValue)
progress: int = int((self.width() - self.__padding * 2) * step)
rect: QRect = QRect(self.__padding, (self.height() // 3) * 2, progress,
int(self.height() / 3))
painter.drawRoundedRect(rect, self.__radius, self.__radius)
painter.restore()
def drawPointerCircle(self, painter: QPainter) -> None:
if not self.__showPointer: return
radius: int = 15
offset: int = self.__radiusCircle - 60
painter.save()
painter.setPen(Qt.NoPen)
painter.rotate(self.__startAngle)
degRotate: float = (360.0 - self.__startAngle - self.__endAngle) / (
self.__maxValue - self.__minValue) * (self.__value -
self.__minValue)
painter.rotate(degRotate)
painter.setBrush(self.__progressColor)
painter.drawEllipse(-radius, radius + offset, radius * 2, radius * 2)
painter.restore()
def paintEvent(self, paintEvent: QPaintEvent):
pen = QPen()
pen.setJoinStyle(Qt.RoundJoin)
pen.setCapStyle(Qt.RoundCap)
painter = QPainter(self)
painter.translate(self.paintOffset)
painter.setBackgroundMode(Qt.TransparentMode)
painter.setRenderHint(QPainter.Antialiasing)
if self.nodes is not None:
painted = set()
def paintNode(node):
nonlocal painter, painted
if node in painted:
return
painted.add(node)
for link in node.links:
if link not in painted:
painter.drawLine(node.point, link.point)
paintNode(link)
color = self.palette().color(QPalette.Dark)
pen.setColor(color)
pen.setWidth(0.50 * self.paintStep)
painter.setPen(pen)
for node in self.nodes.values():
if paintEvent.region().contains(node.point):
paintNode(node)
if self.startNode is not None:
color = self.palette().color(QPalette.Dark)
pen.setColor(color)
pen.setWidth(0.75 * self.paintStep)
painter.setPen(pen)
if paintEvent.region().contains(self.startNode.point):
painter.drawPoint(self.startNode.point)
if self.finishNode is not None and paintEvent.region().contains(self.finishNode.point):
color = self.palette().color(QPalette.Dark).darker(120)
pen.setColor(color)
pen.setWidth(0.75 * self.paintStep)
painter.setPen(pen)
painter.drawPoint(self.finishNode.point)
if self.player is not None:
color = self.palette().color(QPalette.Highlight)
color.setAlpha(196)
pen.setColor(color)
pen.setWidth(0.90 * self.paintStep)
painter.setPen(pen)
painter.drawPoint(self.player)
del painter, pen
def drawBaseImage(self, backgroundFile, titleText, titleFont, fontSize, alignment,\
xOffset, yOffset, textColor, visColor):
if backgroundFile == '':
im = Image.new("RGB", (1280, 720), "black")
else:
im = Image.open(backgroundFile)
if self._image == None or not self.lastBackgroundImage == backgroundFile:
self.lastBackgroundImage = backgroundFile
# resize if necessary
if not im.size == (1280, 720):
im = im.resize((1280, 720), Image.ANTIALIAS)
self._image = ImageQt(im)
self._image1 = QtGui.QImage(self._image)
painter = QPainter(self._image1)
font = titleFont
font.setPixelSize(fontSize)
painter.setFont(font)
painter.setPen(QColor(*textColor))
yPosition = yOffset
fm = QtGui.QFontMetrics(font)
if alignment == 0: #Left
xPosition = xOffset
if alignment == 1: #Middle
xPosition = xOffset - fm.width(titleText) / 2
if alignment == 2: #Right
xPosition = xOffset - fm.width(titleText)
painter.drawText(xPosition, yPosition, titleText)
painter.end()
buffer = QtCore.QBuffer()
buffer.open(QtCore.QIODevice.ReadWrite)
self._image1.save(buffer, "PNG")
strio = io.BytesIO()
strio.write(buffer.data())
buffer.close()
strio.seek(0)
return Image.open(strio)
def paint(self, painter: QPainter, option: QStyleOptionGraphicsItem,
widget: QWidget) -> None:
"""
Paint the graphics of the action wrapper including action name, number, and ports.
:param painter: This draws the widget.
:type painter: QPainter
:param option: Option for the style of graphic.
:type option: QStyleOptionGraphicsItem
:param widget: Index for the painted graphic.
:type widget: QWidget
:return: None
:rtype: NoneType
"""
pen = QPen()
pen.setColor(self.lineColor)
pen.setWidth(MoveButton.PEN_WIDTH)
painter.setPen(pen)
painter.setBrush(self.bgColor)
x = -MoveButton.WIDTH / 2
y = -MoveButton.HEIGHT / 2
painter.drawRect(x, y, MoveButton.WIDTH, MoveButton.HEIGHT)
# calculate arrow points as if it were facing down, then flip if necessary.
vertexX = 0
vertexY = MoveButton.HEIGHT / 4
leftX = -MoveButton.WIDTH / 4
leftY = -MoveButton.HEIGHT / 4
rightX = MoveButton.WIDTH / 4
rightY = -MoveButton.HEIGHT / 4
if self.direction == MoveButton.Direction.Up:
vertexX *= -1
vertexY *= -1
leftX *= -1
leftY *= -1
rightX *= -1
rightY *= -1
painter.drawLine(vertexX, vertexY, rightX, rightY)
painter.drawLine(vertexX, vertexY, leftX, leftY)
def paint(self, painter: QtGui.QPainter,
option: QtWidgets.QStyleOptionViewItem,
index: QtCore.QModelIndex) -> None:
self._painter = painter
painter.save()
self.initStyleOption(option, index)
# construct new style option object with different colurs, then pass that to super
newOption = QtWidgets.QStyleOptionViewItem(option)
# draw outline and background
backgroundBrush = self.backgroundBrush(painter, newOption, index)
outlinePen = self.outlinePen(painter, newOption, index)
if backgroundBrush or outlinePen:
newOption.Alternate = False # no override from alternate row colours
newOption.None_ = True # strange glyphs beyond all knowledge
painter.setBrush(backgroundBrush)
painter.setPen(outlinePen)
painter.drawRoundedRect(newOption.rect, 2, 2)
# # set pen for text
#painter.setPen(self.textPen(painter, newOption, index))
# I'm not sure what the interaction is between the painter
# and the palette style below for text
# # reset pen for text
# textColour = self.textColour(painter, newOption, index)
# if textColour is None:
# textColour = option.palette.text().color()
# #print("textColour", textColour)
# newOption.palette.setColor(
# QtGui.QPalette.Text,
# QtGui.QColor(textColour),
# )
painter.setPen(self.textPen(painter, newOption, index))
#painter.setBrush(QtCore.Qt.NoBrush)
#painter.drawText(newOption.rect, newOption.text)
super(EasyDelegate, self).paint(painter, newOption, index)
painter.restore()
def draw_cursor_rect(self, pos: Tuple[int, int], brush, addr):
painter = QPainter(self.cursors_pixmap)
cursor_rect = QRect(self.byte_rect)
h = cursor_rect.height()
i, j = pos
cursor_rect.moveTopLeft(QPoint(i * self.byte_advance, j * h))
painter.setPen(Qt.NoPen)
painter.setBrush(brush)
painter.drawRect(cursor_rect)
painter.setFont(self.font)
txt = self.bytes_field[addr][0]
painter.setPen(PEN_BCK)
painter.drawText(cursor_rect, Qt.AlignCenter, f'{txt}')
painter.end()
def paintEvent(self, e):
painter = QPainter(self)
painter.setPen(QPen(QColor(145, 18, 9), 10))
if self.__connectingMode:
layerPoint = QPoint(
self.__connectingLayer.x() +
self.__connectingLayer.parentWidget().x() + 20,
self.__connectingLayer.y() +
self.__connectingLayer.parentWidget().y() + 20)
painter.drawLine(layerPoint, self.mapFromGlobal(QCursor.pos()))
self.update()
if self.__lines:
for line in self.__lines:
point1 = QPoint(line[0].x() + line[0].parentWidget().x() + 20,
line[0].y() + line[0].parentWidget().y() + 20)
point2 = QPoint(line[1].x() + line[1].parentWidget().x() + 20,
line[1].y() + line[1].parentWidget().y() + 20)
self.update()
painter.drawLine(point1, point2)
def paint(self, painter: QPainter, option: QStyleOptionGraphicsItem, widget: Optional[QWidget] = ...):
painter.setPen(QPen(Qt.NoPen))
painter.setBrush(Qt.darkGray)
painter.drawEllipse(-7, -7, 20, 20)
gradient = QRadialGradient(self._m_centerPos.x(), self._m_centerPos.y(), 10)
if self.isSelected():
gradient.setCenter(3, 3)
gradient.setFocalPoint(3, 3)
gradient.setColorAt(1, QColor(Qt.yellow).lighter(120))
gradient.setColorAt(0, QColor(Qt.darkYellow).lighter(120))
else:
gradient.setColorAt(0, Qt.yellow)
gradient.setColorAt(1, Qt.darkYellow)
painter.setBrush(gradient)
painter.setPen(QPen(Qt.black, 0))
painter.drawEllipse(-10, -10, 20, 20)
def paintEvent(self, event):
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.fillRect(event.rect(), QBrush(QColor(255, 255, 255, 127)))
painter.setPen(QPen(Qt.NoPen))
for i in range(6):
if (self.counter / 5) % 6 == i:
painter.setBrush(QBrush(QColor(127 + (self.counter % 5)*32, 127, 127)))
else:
painter.setBrush(QBrush(QColor(127, 127, 127)))
painter.drawEllipse(
self.width()/2 + 15 * math.cos(2 * math.pi * i / 6.0) - 10,
self.height()/2 + 15 * math.sin(2 * math.pi * i / 6.0) - 10,
20, 20)
painter.end()
def paintEvent(self, _: QPaintEvent) -> None:
"""Qt Paint Event: ensures the title-bar text is elided properly and stays centered"""
painter = QPainter()
painter.begin(self)
painter.setPen(self.__font_pen)
# bold font for macOS window titles
font = self.font()
if sys.platform in ["darwin", "linux"]:
font.setBold(True)
font_metrics = QFontMetrics(font)
# calculate text properties
text_width: int = self.width(
) - self.__button_bar_width - self.__margin
text: str = font_metrics.elidedText(self.__original_text,
Qt.ElideRight, text_width)
# calculate height
br: QRect = font_metrics.boundingRect(text)
if br.height() > 0:
self.__br_height = br.height()
py = self.__ofs_y - self.__br_height / 2.0
br_width = br.width()
# calculate width
px = (self.width() - br_width - WIDTH_PADDING_PX) / 2.0
if px < self.__button_bar_width:
if self.__window_buttons_position == WINDOW_BUTTONS_RIGHT:
if text != self.__original_text:
px = self.__margin
else:
px = px - (self.__button_bar_width - px)
else:
px = self.__button_bar_width
# draw title
rect = QRectF(px, py, br_width + WIDTH_PADDING_PX, self.__br_height)
painter.setFont(font)
if DEBUG:
painter.setBrush(QBrush(QColor('#ff0000')))
painter.drawRect(rect)
painter.drawText(rect, Qt.AlignLeft, text)
def paintEvent(self, event):
painter = QPainter(self)
if self.qimage:
painter.drawImage(QtCore.QRect(0, 0, self.width(), self.height()),
self.qimage)
else:
painter.setBrush(QtGui.QColor(255, 255, 255, 255))
painter.drawRect(0, 0, self.browser_buffer.buffer_width,
self.browser_buffer.buffer_height)
if self.browser_buffer.loading_flag:
painter.setPen(QtGui.QColor(10, 138, 255, 255))
painter.setBrush(QtGui.QColor(10, 138, 255, 255))
painter.drawRect(
0, 0, self.browser_buffer.buffer_width *
self.browser_buffer.loading_percent / 100, 1)
painter.end()
def paint(self, painter: QPainter, option: QStyleOptionViewItem,
index: QModelIndex):
# Change table item foreground (pen color) to red color if it's highlighted
highlighted_palette = False
if option.state & QStyle.State_Selected:
if option.state & QStyle.State_Active:
painter.fillRect(option.rect, option.palette.highlight())
highlighted_palette = True
elif not (option.state & QStyle.State_HasFocus):
painter.fillRect(option.rect, option.palette.background())
if index.data(TableItemDataRole.HIGHLIGHT):
painter.setPen(
QColor(255, 128, 128) if highlighted_palette else Qt.red)
else:
painter.setPen(Qt.black)
painter.drawText(option.rect, Qt.AlignCenter, index.data())
def drawCurrentText_JD(self, painter: QPainter) -> None:
width: int = self.width() // self.__maxStep
height: int = self.height() // 2
initX: int = 0
initY: int = height
painter.save()
font: QFont = QFont()
font.setPixelSize(height / 3)
painter.setFont(font)
painter.setPen(self.__currentBackground)
painter.setBrush(Qt.NoBrush)
for i in range(self.__currentStep):
textRect: QRect = QRect(initX, initY, width, height)
painter.drawText(textRect, Qt.AlignCenter, self.__topInfo[i])
initX += width
painter.restore()
def paintEvent(self, event: QPaintEvent):
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.eraseRect(event.rect())
painter.setBrush(QBrush(self._bg))
painter.drawRect(event.rect())
if self.mode == 'revealed':
self.setFrameStyle(QFrame.Panel | QFrame.Plain)
self.setLineWidth(0)
self.setMidLineWidth(0)
if self.content in self.content_colors.keys():
font = QFontDatabase.systemFont(QFontDatabase.FixedFont)
font.setPixelSize(int(self.width() * 5 / 6))
painter.setPen(self.content_colors[self.content])
painter.setFont(font)
flags = Qt.AlignCenter | Qt.TextJustificationForced
painter.drawText(event.rect(), flags, self.content)
if self.content == 'bomb':
loc = 'exploded_bomb' if self.was_clicked_bomb else 'bomb'
painter.drawImage(event.rect(),
QImage(self.image_locations[loc]))
if self.mode == 'hidden':
self.setFrameStyle(QFrame.Panel | QFrame.Raised)
self.setLineWidth(3)
self.setMidLineWidth(2)
if self.mode == 'false_bomb':
painter.drawImage(event.rect(),
QImage(self.image_locations['false_bomb']))
if self.mode == 'flag':
self.setFrameStyle(QFrame.Panel | QFrame.Raised)
self.setLineWidth(3)
self.setMidLineWidth(2)
painter.drawImage(event.rect(),
QImage(self.image_locations['flag']))
super(CellWidget, self).paintEvent(event)
def paintEvent(self, event):
super().paintEvent(event)
painter = QPainter(self)
painter.beginNativePainting()
painter.setRenderHint(QPainter.Antialiasing)
painter.setRenderHint(QPainter.SmoothPixmapTransform)
painter.setPen(QPen(Qt.green, 1, Qt.DotLine))
painter.drawRect(self.rubberband.rect())
painter.setPen(QPen(Qt.green, 1))
x_begin = self.rubberband.x()
x_half = self.rubberband.x() + self.rubberband.width() / 2
x_full = self.rubberband.x() + self.rubberband.width()
y_begin = self.rubberband.y()
y_half = self.rubberband.y() + self.rubberband.height() / 2
y_full = self.rubberband.y() + self.rubberband.height()
points = [QPoint(x_half, y_begin), QPoint(x_half, y_full)]
painter.drawLines(points)
painter.endNativePainting()
painter.end()
def drawBorder(self, painter: QPainter = None) -> None:
painter.save()
width: int = self.width()
height: int = self.height()
offset: int = self.__borderWidth
pen: QPen = QPen()
pen.setWidth(offset)
pen.setColor(self.__borderColor)
pen.setCapStyle(Qt.RoundCap)
pen.setJoinStyle(Qt.MiterJoin)
painter.setPen(pen)
painter.setBrush(Qt.NoBrush)
painter.drawRect(offset // 2, offset // 2, width - offset,
height - offset)
painter.restore()
def paintEvent(self, event):
# Set checked depending on state
self.image.setFileName(ThemeManager.CHECKED_PATH if self.
enabled else ThemeManager.UNCHECKED_PATH)
# Init painter and draw image at correct location
painter = QPainter(self)
pixmap = QPixmap.fromImageReader(self.image)
painter.setRenderHint(QPainter.HighQualityAntialiasing, True)
painter.drawPixmap(0, (self.height() - pixmap.height()) / 2, pixmap)
# Style font and draw text at correct location
painter.setFont(self.font)
pen = QPen()
pen.setColor(ThemeManager.LABEL_QC if any([self.hovered, self.enabled])
else ThemeManager.LABEL_LOW_OPACITY_QC)
painter.setPen(pen)
painter.drawText(pixmap.width() + self.padding,
self.height() / 2 + self.nameHeight / 4, self.name)
def paintEvent(self, event):
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing, self.antialiased)
painter.translate(self.width() / 2, self.height() / 2)
for diameter in range(0, 256, 9):
delta = abs((self.frameNo % 128) - diameter / 2)
alpha = 255 - (delta * delta) / 4 - diameter
if alpha > 0:
painter.setPen(QPen(QColor(0, diameter / 2, 127, alpha), 3))
if self.floatBased:
painter.drawEllipse(
QRectF(-diameter / 2.0, -diameter / 2.0, diameter,
diameter))
else:
painter.drawEllipse(
QRect(-diameter / 2, -diameter / 2, diameter,
diameter))
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)
def paintEvent(self, event):
painter = QPainter(self)
painter.setPen(Qt.NoPen)
self.penFromEnum = painter.pen()
painter.setPen(int(Qt.NoPen))
self.penFromInteger = painter.pen()
