def paintEvent(self, a0: QPaintEvent) -> None:
super().paintEvent(a0)
painter = QPainter(self)
painter.save()
painter.setRenderHint(QPainter.Antialiasing)
rect = QRectF(self.margin, self.margin,
self.width() - self.margin * 2,
self.height() - 2 * self.margin)
painter.setBrush(Qt.white)
painter.setPen(Qt.white)
painter.drawEllipse(rect)
painter.restore()
painter.save()
painter.setRenderHint(QPainter.Antialiasing)
pen = QPen()
pen.setWidth(2)
painter.setPen(pen)
mid_point = QPointF(a0.rect().width() / 2, a0.rect().height() / 2)
radius = min(a0.rect().height(), a0.rect().width()) / 3
rays_num = 10
for i in range(rays_num):
point = QPointF(
math.sin(math.pi / (rays_num / 2) * i) * radius,
math.cos(math.pi / (rays_num / 2) * i) * radius)
painter.drawLine(mid_point + (point * 0.4), mid_point + point)
painter.restore()
def paintEvent(self, event):
painter = QPainter(self)
painter.setClipRegion(event.region())
if (
self.testPaintAttribute(self.BackingStore)
and self.__data.backingStore is not None
):
bs = self.__data.backingStore
if QT_MAJOR_VERSION >= 5:
pixelRatio = bs.devicePixelRatio()
else:
pixelRatio = 1.0
if bs.size() != self.size() * pixelRatio:
bs = QwtPainter.backingStore(self, self.size())
if self.testAttribute(Qt.WA_StyledBackground):
p = QPainter(bs)
qwtFillBackground(p, self)
self.drawCanvas(p, True)
else:
p = QPainter()
if self.__data.borderRadius <= 0.0:
# print('**DEBUG: QwtPlotCanvas.paintEvent')
QwtPainter.fillPixmap(self, bs)
p.begin(bs)
self.drawCanvas(p, False)
else:
p.begin(bs)
qwtFillBackground(p, self)
self.drawCanvas(p, True)
if self.frameWidth() > 0:
self.drawBorder(p)
p.end()
painter.drawPixmap(0, 0, self.__data.backingStore)
else:
if self.testAttribute(Qt.WA_StyledBackground):
if self.testAttribute(Qt.WA_OpaquePaintEvent):
qwtFillBackground(painter, self)
self.drawCanvas(painter, True)
else:
self.drawCanvas(painter, False)
else:
if self.testAttribute(Qt.WA_OpaquePaintEvent):
if self.autoFillBackground():
qwtFillBackground(painter, self)
qwtDrawBackground(painter, self)
else:
if self.borderRadius() > 0.0:
clipPath = QPainterPath()
clipPath.addRect(self.rect())
clipPath = clipPath.subtracted(self.borderPath(self.rect()))
painter.save()
painter.setClipPath(clipPath, Qt.IntersectClip)
qwtFillBackground(painter, self)
qwtDrawBackground(painter, self)
painter.restore()
self.drawCanvas(painter, False)
if self.frameWidth() > 0:
self.drawBorder(painter)
if self.hasFocus() and self.focusIndicator() == self.CanvasFocusIndicator:
self.drawFocusIndicator(painter)
def paintEvent(self, a0: QPaintEvent) -> None:
super().paintEvent(a0)
painter = QPainter(self)
painter.save()
painter.setRenderHint(QPainter.Antialiasing)
rect = QRectF(self.margin, self.margin,
self.width() - self.margin * 2,
self.height() - 2 * self.margin)
painter.setBrush(Qt.white)
painter.setPen(Qt.white)
painter.drawRect(rect)
painter.restore()
painter.save()
painter.setRenderHint(QPainter.Antialiasing)
pen = QPen()
pen.setWidth(3)
painter.setPen(pen)
path = QPainterPath()
height, width = rect.height() + self.margin, rect.width() + self.margin
path.moveTo(self.margin, height)
path.cubicTo(height * 0.5, width * 0.9, height * 0.9, width * 0.5,
height, self.margin)
painter.drawPath(path)
painter.restore()
def paintEvent(self, event: QPaintEvent):
painter = QPainter(self)
painter.save()
painter.setRenderHint(QPainter.Antialiasing)
size = min(self.width(), self.height())
rect = QRect(0, 0, size, size)
painter.setBrush(self.background_color)
painter.setPen(self.background_color)
painter.drawEllipse(rect)
painter.setBrush(self.main_color)
painter.setPen(self.main_color)
factor = self.nominator / self.denominator
radius = size / 2
if factor > 0.5:
painter.drawChord(rect, 0, 16 * 360 * 0.5)
painter.drawChord(rect, 16 * 180, 16 * 360 * (factor - 0.5))
zero_point = QPointF(0, radius)
else:
painter.drawChord(rect, 0, 16 * 360 * factor)
zero_point = QPointF(size, radius)
mid_point = QPointF(radius, radius)
point = mid_point + QPointF(
math.cos(math.pi * (factor * 2)) * radius, -math.sin(math.pi * (factor * 2)) * radius
)
polygon = QPolygonF()
polygon += mid_point
polygon += zero_point
polygon += point
painter.drawPolygon(polygon)
painter.restore()
def paintEvent(self, a0: QPaintEvent) -> None:
super().paintEvent(a0)
painter = QPainter(self)
painter.save()
painter.setRenderHint(QPainter.Antialiasing)
pen2 = QPen()
rect = QRectF(self.margin,
self.height() / 2,
self.width() - self.margin * 2,
self.height() / 2 - self.margin)
rect2 = QRectF(3 * self.margin, 2 * self.margin,
self.width() - self.margin * 6, self.height())
pen2.setWidth(6)
painter.setPen(pen2)
painter.drawArc(rect2, 0, 180 * 16)
pen2.setWidth(3)
pen2.setColor(Qt.white)
painter.setPen(pen2)
painter.drawArc(rect2, 0, 180 * 16)
painter.fillRect(rect, Qt.white)
pen2.setWidth(2)
pen2.setColor(Qt.black)
painter.setPen(pen2)
painter.drawRect(rect)
painter.restore()
def paintEvent(self, event: QPaintEvent):
painter = QPainter(self)
painter.drawImage(self.rect(), self.image)
if self.show_frame:
painter.save()
pen = QPen()
pen.setWidth(2)
pen.setColor(QColor("black"))
painter.setPen(pen)
rect = QRect(1, 1, self.width() - 2, self.height() - 2)
painter.drawRect(rect)
pen.setColor(QColor("white"))
painter.setPen(pen)
rect = QRect(3, 3, self.width() - 6, self.height() - 6)
painter.drawRect(rect)
painter.restore()
if self.show_arrow:
painter.save()
triangle = QPolygonF()
dist = 4
point1 = QPoint(self.width() - self.triangle_width, 0)
size = QSize(20, self.height() // 2)
rect = QRect(point1, size)
painter.fillRect(rect, QColor("white"))
triangle.append(point1 + QPoint(dist, dist))
triangle.append(point1 + QPoint(size.width() - dist, dist))
triangle.append(point1 + QPoint(size.width() // 2,
size.height() - dist))
painter.setBrush(Qt.black)
painter.drawPolygon(triangle, Qt.WindingFill)
painter.restore()
def paintEvent(self, QPaintEvent):
self.updatePosition()
painter = QPainter(self)
painter.fillRect(self.rect(), Qt.transparent)
painter.setRenderHint(QPainter.Antialiasing, True)
if self._currentCounter >= self._numberOfLines:
self._currentCounter = 0
painter.setPen(Qt.NoPen)
for i in range(self._numberOfLines):
painter.save()
painter.translate(self._innerRadius + self._lineLength,
self._innerRadius + self._lineLength)
rotateAngle = float(360 * i) / float(self._numberOfLines)
painter.rotate(rotateAngle)
painter.translate(self._innerRadius, 0)
distance = self.lineCountDistanceFromPrimary(
i, self._currentCounter, self._numberOfLines)
color = self.currentLineColor(distance, self._numberOfLines,
self._trailFadePercentage,
self._minimumTrailOpacity,
self._color)
painter.setBrush(color)
painter.drawRoundedRect(
QRectF(0, -self._lineWidth / 2, self._lineLength,
self._lineWidth), self._roundness, self._roundness,
Qt.RelativeSize)
painter.restore()
def paint(self, painter: QPainter, option: QStyleOptionViewItem, index: QModelIndex):
"""Renders the delegate using the given painter and style option for the item specified by index.
:param painter: A QPainter object to draw
:param option: Options to describe what should be drawn
:param index: _description_
"""
if not index.isValid():
return
# Initialize the style options. This is not very Pythonic as it uses C++
# references under the hood so opt is affected by the second call
opt = QStyleOptionViewItem(option)
self.initStyleOption(opt, index)
# Standard setup, paint, restore operation
painter.save()
try:
painter.setClipRect(opt.rect)
foreground_colour, background_colour = index.data(Qt.ForegroundRole), index.data(Qt.BackgroundRole)
if foreground_colour is not None:
painter.setPen(foreground_colour)
if background_colour is not None:
painter.fillRect(option.rect, background_colour)
padding = self._padding
opt.rect = option.rect.adjusted(padding, padding, -padding, -padding)
painter.drawText(opt.rect, int(Qt.AlignLeft | Qt.AlignVCenter),
opt.fontMetrics.elidedText(opt.text, Qt.ElideRight, opt.rect.width()))
finally:
painter.restore()
def paintEvent(self, event):
painter = QPainter(self)
if not self.contentsRect().contains(event.rect()):
painter.save()
painter.setClipRegion(event.region() & self.frameRect())
self.drawFrame(painter)
painter.restore()
painter.setClipRegion(event.region() & self.contentsRect())
self.drawContents(painter)
def paintEvent(self, a0: QPaintEvent) -> None:
super().paintEvent(a0)
painter = QPainter(self)
painter.save()
painter.setPen(QColor("white"))
painter.setBrush(QColor("white"))
painter.drawRect(self.rect() - self.margin)
icon: QIcon = qta.icon("fa5s.lock")
icon.paint(painter, self.rect() - self.margin * 2)
painter.restore()
def paintEvent(self, a0: QPaintEvent) -> None:
super().paintEvent(a0)
painter = QPainter(self)
painter.save()
painter.setPen(QColor("white"))
painter.setBrush(QColor("white"))
painter.drawRect(self.rect() - self.margin)
icon: QIcon = qta.icon("mdi.chart-bell-curve-cumulative")
icon.paint(painter, self.rect())
painter.restore()
def paintEvent(self, event: QPaintEvent):
rect = event.rect()
painter = QPainter(self)
painter.save()
if self.isChecked():
lock = lock_close
else:
lock = lock_open
painter.setFont(QFont("Symbola"))
painter.drawText(rect.bottomLeft() + QPoint(0, -2), lock)
painter.restore()
def paintEvent(self, event: QtGui.QPaintEvent):
painter = QPainter(self)
color = painter.pen().color()
painter.save()
rect = self.rect()
top = int(rect.height() - (self.text_size.height() / 2))
painter.drawText(rect.height() + 5, top, self.info_text)
if self.isChecked():
icon = qta.icon("fa5s.caret-right", color=color)
else:
icon = qta.icon("fa5s.caret-down", color=color)
icon.paint(painter,
QRect(0, -self.height() / 4, self.height(), self.height()))
painter.restore()
def paint(self, painter: QPainter, style: QStyleOptionViewItem,
model: QModelIndex):
if model.data() not in image_dict:
image_dict[model.data()] = create_colormap_image(
model.data(), self.color_dict)
rect = QRect(style.rect.x(),
style.rect.y() + 2, style.rect.width(),
style.rect.height() - 4)
painter.drawImage(rect, image_dict[model.data()])
if int(style.state & QStyle.State_HasFocus):
painter.save()
pen = QPen()
pen.setWidth(5)
painter.setPen(pen)
painter.drawRect(rect)
painter.restore()
def paintEvent(self, a0: QPaintEvent) -> None:
painter = QPainter(self)
margin = 10
width = self.width() - 2 * margin
rect = QRect(margin, margin, width, self.height() - 2 * margin)
painter.drawImage(rect, self.image)
painter.save()
for pos_factor in self.position_list:
pos = width * pos_factor
point = QPointF(pos + margin, self.height() / 2)
painter.setBrush(QBrush(Qt.black))
painter.drawEllipse(point, 5, 5)
painter.setBrush(QBrush(Qt.white))
painter.drawEllipse(point, 3, 3)
painter.restore()
def paintEvent(self, paint_event):
"""Paints the box"""
painter = QPainter(self)
rect = self.contentsRect()
tile_count = 3
tile_size = int(rect.width() / tile_count)
painter.save()
painter.translate(rect.x(), rect.y())
for y in range(tile_count):
for x in range(tile_count):
color_index = (y * tile_count + x) % 2
tile_rect = QRect(x * tile_size, y * tile_size, tile_size,
tile_size)
painter.fillRect(tile_rect, self._tile_colors[color_index])
painter.restore()
painter.fillRect(rect, self._color)
QFrame.paintEvent(self, paint_event)
def paintEvent(self, QPaintEvent):
if not self._isSpinning:
return
self.updatePosition()
painter = QPainter(self)
painter.fillRect(self.rect(), Qt.transparent)
painter.setRenderHint(QPainter.Antialiasing, True)
if self._currentCounter >= self._numberOfLines:
self._currentCounter = 0
painter.setPen(Qt.NoPen)
for i in range(0, self._numberOfLines):
painter.save()
painter.translate(self._innerRadius + self._lineLength,
self._innerRadius + self._lineLength)
rotateAngle = float(360 * i) / float(self._numberOfLines)
painter.rotate(rotateAngle)
painter.translate(self._innerRadius, 0)
distance = self.lineCountDistanceFromPrimary(
i, self._currentCounter, self._numberOfLines)
color = self.currentLineColor(distance, self._numberOfLines,
self._trailFadePercentage,
self._minimumTrailOpacity,
self._color)
# Compute the scaling factor to apply to the size and thickness
# of the lines in the trail.
if self._trailSizeDecreasing:
sf = (self._numberOfLines - distance) / self._numberOfLines
else:
sf = 1
painter.setBrush(color)
rect = QRect(0, round(-self._lineWidth / 2),
round(sf * self._lineLength),
round(sf * self._lineWidth))
painter.drawRoundedRect(rect, self._roundness, self._roundness,
Qt.RelativeSize)
painter.restore()
def paintEvent(self, e):
cr = self.contentsRect()
painter = QPainter(self)
painter.setClipRegion(e.region())
# if self.__data.isDown:
# qDrawWinButton(
# painter, 0, 0, self.width(), self.height(), self.palette(), True
# )
painter.save()
if self.__data.isDown:
shiftSize = buttonShift(self)
painter.translate(shiftSize.width(), shiftSize.height())
painter.setClipRect(cr)
self.drawContents(painter)
if not self.__data.icon.isNull():
iconRect = QRect(cr)
iconRect.setX(iconRect.x() + self.margin())
if self.__data.itemMode != QwtLegendData.ReadOnly:
iconRect.setX(iconRect.x() + BUTTONFRAME)
iconRect.setSize(self.__data.icon.size())
iconRect.moveCenter(QPoint(iconRect.center().x(), cr.center().y()))
painter.drawPixmap(iconRect, self.__data.icon)
painter.restore()
def paint(self, painter: QtGui.QPainter, option: 'QStyleOptionViewItem',
index: QtCore.QModelIndex) -> None:
if not index.isValid():
return
if option.state & QStyle.State_Selected:
pass
if option.state & QStyle.State_MouseOver:
pass
item = index.model().data(index, Qt.UserRole)
if isinstance(item, QVariant):
return
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setRenderHints(QPainter.SmoothPixmapTransform)
value = item['value']
type = item['type']
x = option.rect.x()
y = option.rect.y()
w = option.rect.width()
h = option.rect.height()
if type == 'device_activity':
painter.save()
# 图标
icon = QImage(ResourceLoader().icon_path(value['icon']))
rect_icon = QRectF(x + 20, y + 13, 44, 44)
painter.drawImage(rect_icon, icon)
# 设备标签
painter.setFont(ResourceLoader().qt_font_text_xs)
rect = calculate_text_rect('设备',
painter=painter,
x=x + 70,
y=y + 15)
painter.drawText(rect, Qt.TextSingleLine, '设备')
# 设备编号
painter.setPen(ResourceLoader().qt_color_label_link)
painter.setFont(ResourceLoader().qt_font_text_xs)
rect = calculate_text_rect(value['device'],
painter=painter,
x=x + 110,
y=y + 15)
painter.drawText(rect, Qt.TextSingleLine, value['device'])
# 活动内容
painter.setPen(ResourceLoader().qt_color_sub_text)
painter.setFont(ResourceLoader().qt_font_text_xss)
content = value['content'] + '，' + toDateStr()
rect = calculate_text_rect(content,
painter=painter,
x=x + 70,
y=y + 40)
painter.drawText(rect, Qt.TextSingleLine, content)
# 绘制边框
path = QPainterPath()
path.addRoundedRect(QRectF(x + 4, y + 4, w - 8, h - 8), 4, 4)
painter.strokePath(path,
QPen(ResourceLoader().qt_color_background, 1))
painter.restore()
elif type == 'load_more':
# 绘制加载图标
# painter.save()
# painter.translate(x+16, y+16)
# self.loading_rotate += 5
# painter.rotate(self.loading_rotate%360)
# icon = qtawesome.icon('mdi.loading', color=ResourceLoader().qt_color_sub_text)
# icon_pixmap = icon.pixmap(QSize(32, 32))
# painter.drawPixmap(QRect(-16, -16, 32, 32), icon_pixmap)
# painter.restore()
# 绘制加载信息
painter.save()
painter.setFont(ResourceLoader().qt_font_text_xs)
painter.setPen(ResourceLoader().qt_color_sub_text)
_rect = calculate_text_rect('~~~ 正在努力加载 ~~~', painter=painter)
rect = calculate_middle_rect(option.rect,
width=_rect.width(),
height=_rect.height())
painter.drawText(rect, Qt.TextSingleLine, '~~~ 正在努力加载 ~~~')
painter.restore()
elif type == 'no_more':
painter.save()
painter.setFont(ResourceLoader().qt_font_text_xs)
painter.setPen(ResourceLoader().qt_color_sub_text)
_rect = calculate_text_rect('--- 我是有底线的 ---', painter=painter)
rect = calculate_middle_rect(option.rect,
width=_rect.width(),
height=_rect.height())
painter.drawText(rect, Qt.TextSingleLine, '--- 我是有底线的 ---')
painter.restore()
else:
self.initStyleOption(option, index)
QStyledItemDelegate.paint(self, painter, option, index)
def create_high_dpi_drop_indicator_pixmap(
self, size: QSizeF, area: DockWidgetArea,
mode: OverlayMode) -> QPixmap:
'''
Create high dpi drop indicator pixmap
Parameters
----------
size : QSizeF
area : DockWidgetArea
mode : OverlayMode
Returns
-------
value : QPixmap
'''
border_color = self.icon_color(IconColor.frame_color)
background_color = self.icon_color(IconColor.window_background_color)
window = self.public.window()
# QT version compatibility (TODO necessary for qtpy?)
device_pixel_ratio = (window.devicePixelRatioF()
if hasattr(window, 'devicePixelRatioF')
else window.devicePixelRatio())
pixmap_size = QSizeF(size * device_pixel_ratio)
pm = QPixmap(pixmap_size.toSize())
pm.fill(QColor(0, 0, 0, 0))
p = QPainter(pm)
pen = p.pen()
shadow_rect = QRectF(pm.rect())
base_rect = QRectF()
base_rect.setSize(shadow_rect.size() * 0.7)
base_rect.moveCenter(shadow_rect.center())
# Fill
shadow_color = self.icon_color(IconColor.shadow_color)
if shadow_color.alpha() == 255:
shadow_color.setAlpha(64)
p.fillRect(shadow_rect, shadow_color)
# Drop area rect.
p.save()
area_rect = QRectF()
area_line = QLineF()
non_area_rect = QRectF()
if area == DockWidgetArea.top:
area_rect = QRectF(base_rect.x(), base_rect.y(), base_rect.width(),
base_rect.height()*.5)
non_area_rect = QRectF(base_rect.x(), shadow_rect.height()*.5,
base_rect.width(), base_rect.height()*.5)
area_line = QLineF(area_rect.bottomLeft(), area_rect.bottomRight())
elif area == DockWidgetArea.right:
area_rect = QRectF(shadow_rect.width()*.5, base_rect.y(),
base_rect.width()*.5, base_rect.height())
non_area_rect = QRectF(base_rect.x(), base_rect.y(),
base_rect.width()*.5, base_rect.height())
area_line = QLineF(area_rect.topLeft(), area_rect.bottomLeft())
elif area == DockWidgetArea.bottom:
area_rect = QRectF(base_rect.x(), shadow_rect.height()*.5,
base_rect.width(), base_rect.height()*.5)
non_area_rect = QRectF(base_rect.x(), base_rect.y(),
base_rect.width(), base_rect.height()*.5)
area_line = QLineF(area_rect.topLeft(), area_rect.topRight())
elif area == DockWidgetArea.left:
area_rect = QRectF(base_rect.x(), base_rect.y(),
base_rect.width()*.5, base_rect.height())
non_area_rect = QRectF(shadow_rect.width()*.5, base_rect.y(),
base_rect.width()*.5, base_rect.height())
area_line = QLineF(area_rect.topRight(), area_rect.bottomRight())
baseSize = base_rect.size()
if (OverlayMode.container == mode
and area != DockWidgetArea.center):
base_rect = area_rect
p.fillRect(base_rect, background_color)
if area_rect.isValid():
pen = p.pen()
pen.setColor(border_color)
Color = self.icon_color(IconColor.overlay_color)
if Color.alpha() == 255:
Color.setAlpha(64)
p.setBrush(Color)
p.setPen(Qt.NoPen)
p.drawRect(area_rect)
pen = p.pen()
pen.setWidth(1)
pen.setColor(border_color)
pen.setStyle(Qt.DashLine)
p.setPen(pen)
p.drawLine(area_line)
p.restore()
p.save()
# Draw outer border
pen = p.pen()
pen.setColor(border_color)
pen.setWidth(1)
p.setBrush(Qt.NoBrush)
p.setPen(pen)
p.drawRect(base_rect)
# draw window title bar
p.setBrush(border_color)
frame_rect = QRectF(base_rect.topLeft(),
QSizeF(base_rect.width(), baseSize.height()/10))
p.drawRect(frame_rect)
p.restore()
# Draw arrow for outer container drop indicators
if (OverlayMode.container == mode and
area != DockWidgetArea.center):
arrow_rect = QRectF()
arrow_rect.setSize(baseSize)
arrow_rect.setWidth(arrow_rect.width()/4.6)
arrow_rect.setHeight(arrow_rect.height()/2)
arrow_rect.moveCenter(QPointF(0, 0))
arrow = QPolygonF()
arrow.append(arrow_rect.topLeft())
arrow.append(QPointF(arrow_rect.right(), arrow_rect.center().y()))
arrow.append(arrow_rect.bottomLeft())
p.setPen(Qt.NoPen)
p.setBrush(self.icon_color(IconColor.arrow_color))
p.setRenderHint(QPainter.Antialiasing, True)
p.translate(non_area_rect.center().x(), non_area_rect.center().y())
if area == DockWidgetArea.top:
p.rotate(-90)
elif area == DockWidgetArea.right:
...
elif area == DockWidgetArea.bottom:
p.rotate(90)
elif area == DockWidgetArea.left:
p.rotate(180)
p.drawPolygon(arrow)
pm.setDevicePixelRatio(device_pixel_ratio)
return pm
