def paintEvent(self, ev):
shown = self.button.isChecked()
ls = self.fm.lineSpacing()
painter = QPainter(self)
if self.mouse_over:
tool = QStyleOption()
tool.rect = self.rect()
tool.state = QStyle.State_Raised | QStyle.State_Active | QStyle.State_MouseOver
s = self.style()
s.drawPrimitive(QStyle.PE_PanelButtonTool, tool, painter, self)
painter.drawText(
0, 0,
self.width(),
ls, Qt.AlignCenter | Qt.TextSingleLine, self.text)
text = _('Hide') if shown else _('Show')
f = self.font()
f.setBold(True)
painter.setFont(f)
painter.drawText(
0, self.height() - ls,
self.width(),
ls, Qt.AlignCenter | Qt.TextSingleLine, text)
x = (self.width() - ICON_SZ) // 2
y = ls + (self.height() - ICON_SZ - 2 * ls) // 2
pmap = self.bright_icon if shown else self.dull_icon
painter.drawPixmap(x, y, pmap)
painter.end()
def paintEvent(self, event):
QWidget.paintEvent(self, event)
pmap = self._pixmap
if pmap.isNull():
return
w, h = pmap.width(), pmap.height()
ow, oh = w, h
cw, ch = self.rect().width(), self.rect().height()
scaled, nw, nh = fit_image(w, h, cw, ch)
if scaled:
pmap = pmap.scaled(int(nw*pmap.devicePixelRatio()), int(nh*pmap.devicePixelRatio()), Qt.IgnoreAspectRatio,
Qt.SmoothTransformation)
w, h = int(pmap.width()/pmap.devicePixelRatio()), int(pmap.height()/pmap.devicePixelRatio())
x = int(abs(cw - w)/2.)
y = int(abs(ch - h)/2.)
target = QRect(x, y, w, h)
p = QPainter(self)
p.setRenderHints(QPainter.Antialiasing | QPainter.SmoothPixmapTransform)
p.drawPixmap(target, pmap)
if self.draw_border:
pen = QPen()
pen.setWidth(self.BORDER_WIDTH)
p.setPen(pen)
p.drawRect(target)
if self.show_size:
draw_size(p, target, ow, oh)
p.end()
def paintEvent(self, e):
if self.img:
painter = QPainter()
painter.begin(self)
painter.scale(self.scale, self.scale)
painter.drawPixmap(self.point, self.img)
painter.end()
def paintEvent(self, event):
if self.pixmap.isNull():
return
canvas_size = self.rect()
width = self.current_pixmap_size.width()
extrax = canvas_size.width() - width
if extrax < 0:
extrax = 0
x = int(extrax / 2.)
height = self.current_pixmap_size.height()
extray = canvas_size.height() - height
if extray < 0:
extray = 0
y = int(extray / 2.)
target = QRect(x, y, min(canvas_size.width(), width),
min(canvas_size.height(), height))
p = QPainter(self)
p.setRenderHints(QPainter.RenderHint.Antialiasing
| QPainter.RenderHint.SmoothPixmapTransform)
p.drawPixmap(
target,
self.pixmap.scaled(target.size(),
Qt.AspectRatioMode.KeepAspectRatio,
Qt.TransformationMode.SmoothTransformation))
p.end()
def paintEvent(self, event):
pmap = self.blank if self.pixmap is None or self.pixmap.isNull(
) else self.pixmap
target = self.rect()
scaled, width, height = fit_image(pmap.width(), pmap.height(),
target.width(), target.height())
target.setRect(target.x(), target.y(), width, height)
p = QPainter(self)
p.setRenderHints(QPainter.Antialiasing
| QPainter.SmoothPixmapTransform)
p.drawPixmap(target, pmap)
if self.pixmap is not None and not self.pixmap.isNull():
sztgt = target.adjusted(0, 0, 0, -4)
f = p.font()
f.setBold(True)
p.setFont(f)
sz = u'\u00a0%d x %d\u00a0' % (self.pixmap.width(),
self.pixmap.height())
flags = Qt.AlignBottom | Qt.AlignRight | Qt.TextSingleLine
szrect = p.boundingRect(sztgt, flags, sz)
p.fillRect(szrect.adjusted(0, 0, 0, 4), QColor(0, 0, 0, 200))
p.setPen(QPen(QColor(255, 255, 255)))
p.drawText(sztgt, flags, sz)
p.end()
def paintEvent(self, event):
canvas_size = self.rect()
width = self.current_pixmap_size.width()
extrax = canvas_size.width() - width
if extrax < 0:
extrax = 0
x = int(extrax/2.)
height = self.current_pixmap_size.height()
extray = canvas_size.height() - height
if extray < 0:
extray = 0
y = int(extray/2.)
target = QRect(x, y, width, height)
p = QPainter(self)
p.setRenderHints(QPainter.Antialiasing | QPainter.SmoothPixmapTransform)
try:
dpr = self.devicePixelRatioF()
except AttributeError:
dpr = self.devicePixelRatio()
spmap = self.pixmap.scaled(target.size() * dpr, Qt.KeepAspectRatio, Qt.SmoothTransformation)
spmap.setDevicePixelRatio(dpr)
p.drawPixmap(target, spmap)
if gprefs['bd_overlay_cover_size']:
sztgt = target.adjusted(0, 0, 0, -4)
f = p.font()
f.setBold(True)
p.setFont(f)
sz = u'\u00a0%d x %d\u00a0'%(self.pixmap.width(), self.pixmap.height())
flags = Qt.AlignBottom|Qt.AlignRight|Qt.TextSingleLine
szrect = p.boundingRect(sztgt, flags, sz)
p.fillRect(szrect.adjusted(0, 0, 0, 4), QColor(0, 0, 0, 200))
p.setPen(QPen(QColor(255,255,255)))
p.drawText(sztgt, flags, sz)
p.end()
def paintEvent(self, ev):
shown = self.button.isChecked()
ls = self.fm.lineSpacing()
painter = QPainter(self)
if self.mouse_over:
tool = QStyleOption()
tool.rect = self.rect()
tool.state = QStyle.StateFlag.State_Raised | QStyle.StateFlag.State_Active | QStyle.StateFlag.State_MouseOver
s = self.style()
s.drawPrimitive(QStyle.PrimitiveElement.PE_PanelButtonTool, tool, painter, self)
painter.drawText(
0, 0,
self.width(),
ls, Qt.AlignmentFlag.AlignCenter | Qt.TextFlag.TextSingleLine, self.text)
text = _('Hide') if shown else _('Show')
f = self.font()
f.setBold(True)
painter.setFont(f)
painter.drawText(
0, self.height() - ls,
self.width(),
ls, Qt.AlignmentFlag.AlignCenter | Qt.TextFlag.TextSingleLine, text)
x = (self.width() - ICON_SZ) // 2
y = ls + (self.height() - ICON_SZ - 2 * ls) // 2
pmap = self.bright_icon if shown else self.dull_icon
painter.drawPixmap(x, y, pmap)
painter.end()
def render_emblems(item, emblems):
emblems = tuple(emblems)
if not emblems:
return
icon = self.rendered_emblem_cache.get(emblems, None)
if icon is None:
pixmaps = []
for emblem in emblems:
pm = self.emblem_cache.get(emblem, None)
if pm is None:
pm = self.emblem_cache[emblem] = QIcon(I(emblem)).pixmap(self.iconSize())
pixmaps.append(pm)
num = len(pixmaps)
w, h = pixmaps[0].width(), pixmaps[0].height()
if num == 1:
icon = self.rendered_emblem_cache[emblems] = QIcon(pixmaps[0])
else:
canvas = QPixmap((num * w) + ((num-1)*2), h)
canvas.setDevicePixelRatio(pixmaps[0].devicePixelRatio())
canvas.fill(Qt.transparent)
painter = QPainter(canvas)
for i, pm in enumerate(pixmaps):
painter.drawPixmap(int(i * (w + 2)/canvas.devicePixelRatio()), 0, pm)
painter.end()
icon = self.rendered_emblem_cache[emblems] = canvas
item.setData(0, Qt.DecorationRole, icon)
def paintEvent(self, event):
QWidget.paintEvent(self, event)
pmap = self._pixmap
if pmap.isNull():
return
w, h = pmap.width(), pmap.height()
ow, oh = w, h
cw, ch = self.rect().width(), self.rect().height()
scaled, nw, nh = fit_image(w, h, cw, ch)
if scaled:
pmap = pmap.scaled(int(nw * pmap.devicePixelRatio()),
int(nh * pmap.devicePixelRatio()),
Qt.IgnoreAspectRatio, Qt.SmoothTransformation)
w, h = int(pmap.width() / pmap.devicePixelRatio()), int(
pmap.height() / pmap.devicePixelRatio())
x = int(abs(cw - w) / 2)
y = int(abs(ch - h) / 2)
target = QRect(x, y, w, h)
p = QPainter(self)
p.setRenderHints(QPainter.Antialiasing
| QPainter.SmoothPixmapTransform)
p.drawPixmap(target, pmap)
if self.draw_border:
pen = QPen()
pen.setWidth(self.BORDER_WIDTH)
p.setPen(pen)
p.drawRect(target)
if self.show_size:
draw_size(p, target, ow, oh)
p.end()
def paintEvent(self, event):
'''
@param: event QPaintEvent
'''
if not self._use_background:
return
painter = QPainter(self)
rect = self._side_widget.rect().adjusted(0, 0, 1, 0)
rect = self.style().visualRect(self.layoutDirection(), self.geometry(),
rect)
styleHelper.verticalGradient(painter, rect, rect)
if not self._background_pixmap.isNull():
pixmap_rect = QRect(self._background_pixmap.rect())
pixmap_rect.moveTo(rect.topLeft())
while pixmap_rect.top() < rect.bottom():
source_rect = QRect(pixmap_rect.intersected(rect))
source_rect.moveTo(0, 0)
painter.drawPixmap(pixmap_rect.topLeft(),
self._background_pixmap, source_rect)
pixmap_rect.moveTop(pixmap_rect.bottom() - 10)
painter.setPen(styleHelper.borderColor())
painter.drawLine(rect.topRight(), rect.bottomRight())
# QColor
light = styleHelper.sidebarHighlight()
painter.setPen(light)
painter.drawLine(rect.bottomLeft(), rect.bottomRight())
def paintEvent(self, event):
painter = QPainter(self)
painter.drawPixmap(
self.rect(),
QPixmap(
os.path.join(self.__config.diretorio_assets, "menu principal",
"fundo.png")))
super().paintEvent(event)
def paintEvent(self, event):
w = self.viewport().rect().width()
painter = QPainter(self.viewport())
painter.setClipRect(event.rect())
painter.setRenderHint(QPainter.SmoothPixmapTransform, True)
floor = event.rect().bottom()
ceiling = event.rect().top()
fv = self.firstVisibleBlock().blockNumber()
origin = self.contentOffset()
doc = self.document()
lines = []
for num, text in self.headers:
top, bot = num, num + 3
if bot < fv:
continue
y_top = self.blockBoundingGeometry(doc.findBlockByNumber(top)).translated(origin).y()
y_bot = self.blockBoundingGeometry(doc.findBlockByNumber(bot)).translated(origin).y()
if max(y_top, y_bot) < ceiling:
continue
if min(y_top, y_bot) > floor:
break
painter.setFont(self.heading_font)
br = painter.drawText(3, y_top, w, y_bot - y_top - 5, Qt.TextSingleLine, text)
painter.setPen(QPen(self.palette().text(), 2))
painter.drawLine(0, br.bottom()+3, w, br.bottom()+3)
for top, bot, kind in self.changes:
if bot < fv:
continue
y_top = self.blockBoundingGeometry(doc.findBlockByNumber(top)).translated(origin).y()
y_bot = self.blockBoundingGeometry(doc.findBlockByNumber(bot)).translated(origin).y()
if max(y_top, y_bot) < ceiling:
continue
if min(y_top, y_bot) > floor:
break
if y_top != y_bot:
painter.fillRect(0, y_top, w, y_bot - y_top, self.diff_backgrounds[kind])
lines.append((y_top, y_bot, kind))
if top in self.images:
img, maxw = self.images[top][:2]
if bot > top + 1 and not img.isNull():
y_top = self.blockBoundingGeometry(doc.findBlockByNumber(top+1)).translated(origin).y() + 3
y_bot -= 3
scaled, imgw, imgh = fit_image(int(img.width()/img.devicePixelRatio()), int(img.height()/img.devicePixelRatio()), w - 3, y_bot - y_top)
painter.drawPixmap(QRect(3, y_top, imgw, imgh), img)
painter.end()
PlainTextEdit.paintEvent(self, event)
painter = QPainter(self.viewport())
painter.setClipRect(event.rect())
for top, bottom, kind in sorted(lines, key=lambda t_b_k:{'replace':0}.get(t_b_k[2], 1)):
painter.setPen(QPen(self.diff_foregrounds[kind], 1))
painter.drawLine(0, top, w, top)
painter.drawLine(0, bottom - 1, w, bottom - 1)
def paintEvent(self, event):
w = self.viewport().rect().width()
painter = QPainter(self.viewport())
painter.setClipRect(event.rect())
floor = event.rect().bottom()
ceiling = event.rect().top()
fv = self.firstVisibleBlock().blockNumber()
origin = self.contentOffset()
doc = self.document()
lines = []
for num, text in self.headers:
top, bot = num, num + 3
if bot < fv:
continue
y_top = self.blockBoundingGeometry(doc.findBlockByNumber(top)).translated(origin).y()
y_bot = self.blockBoundingGeometry(doc.findBlockByNumber(bot)).translated(origin).y()
if max(y_top, y_bot) < ceiling:
continue
if min(y_top, y_bot) > floor:
break
painter.setFont(self.heading_font)
br = painter.drawText(3, y_top, w, y_bot - y_top - 5, Qt.TextSingleLine, text)
painter.setPen(QPen(self.palette().text(), 2))
painter.drawLine(0, br.bottom()+3, w, br.bottom()+3)
for top, bot, kind in self.changes:
if bot < fv:
continue
y_top = self.blockBoundingGeometry(doc.findBlockByNumber(top)).translated(origin).y()
y_bot = self.blockBoundingGeometry(doc.findBlockByNumber(bot)).translated(origin).y()
if max(y_top, y_bot) < ceiling:
continue
if min(y_top, y_bot) > floor:
break
if y_top != y_bot:
painter.fillRect(0, y_top, w, y_bot - y_top, self.diff_backgrounds[kind])
lines.append((y_top, y_bot, kind))
if top in self.images:
img, maxw = self.images[top][:2]
if bot > top + 1 and not img.isNull():
y_top = self.blockBoundingGeometry(doc.findBlockByNumber(top+1)).translated(origin).y() + 3
y_bot -= 3
scaled, imgw, imgh = fit_image(img.width(), img.height(), w - 3, y_bot - y_top)
painter.setRenderHint(QPainter.SmoothPixmapTransform, True)
painter.drawPixmap(QRect(3, y_top, imgw, imgh), img)
painter.end()
PlainTextEdit.paintEvent(self, event)
painter = QPainter(self.viewport())
painter.setClipRect(event.rect())
for top, bottom, kind in sorted(lines, key=lambda (t, b, k):{'replace':0}.get(k, 1)):
painter.setPen(QPen(self.diff_foregrounds[kind], 1))
painter.drawLine(0, top, w, top)
painter.drawLine(0, bottom - 1, w, bottom - 1)
def paintEvent(self, e):
"""
receive paint events
:param e: QPaintEvent
:return:
"""
if self.scaled_img:
painter = QPainter()
painter.begin(self)
painter.scale(self.scale, self.scale)
painter.drawPixmap(self.point, self.scaled_img)
painter.end()
class PaintBoard(QWidget):
def __init__(self, parent=None):
super().__init__(parent)
self.__InitData()
self.__InitView()
def __InitData(self):
self.__size = QSize(280, 280)
self.__board = QPixmap(self.__size)
self.__board.fill(Qt.black)
self.__isEmpty = True
self.__lastPose = QPoint(0, 0)
self.__currentPose = QPoint(0, 0)
self.__painter = QPainter()
self.__thickness = 20
self.__penColor = QColor('white')
def __InitView(self):
self.setFixedSize(self.__size)
def paintEvent(self, paintEvent):
self.__painter.begin(self)
self.__painter.drawPixmap(0, 0, self.__board)
self.__painter.end()
def mousePressEvent(self, mouseEvent):
self.__currentPose = mouseEvent.pos()
self.__lastPose = self.__currentPose
def mouseMoveEvent(self, mouseEvent):
self.__currentPose = mouseEvent.pos()
self.__painter.begin(self.__board)
self.__painter.setPen(QPen(self.__penColor, self.__thickness))
self.__painter.drawLine(self.__lastPose, self.__currentPose)
self.__painter.end()
self.__lastPose = self.__currentPose
self.update()
def mouseReleaseEvent(self, mouseEvent):
self.__isEmpty = False
def clear(self):
self.__board.fill(Qt.black)
self.update()
self.__isEmpty = True
def isEmpty(self):
return self.__isEmpty
def getImage(self):
image = self.__board.toImage()
return image
def paintEvent(self, event):
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.drawPixmap(0, 0, self._pixmap)
painter.fillRect(self.rect(), self.palette().midlight().color())
round_path = QPainterPath()
round_path.addRoundedRect(0, 0, self.width(), self.height(), 5, 5)
sq_path = QPainterPath()
sq_path.addRect(0, 0, 10, self.height())
draw_path = sq_path - round_path
painter.setPen(Qt.NoPen)
painter.setBrush(self.palette().dark().color())
painter.drawPath(draw_path)
def _get_scaled_icon(self, icon):
if icon.isNull():
return self.blank_icon
# We need the icon scaled to 16x16
src = icon.pixmap(ICON_SIZE, ICON_SIZE)
if src.width() == ICON_SIZE and src.height() == ICON_SIZE:
return icon
# Need a new version of the icon
pm = QPixmap(ICON_SIZE, ICON_SIZE)
pm.fill(Qt.transparent)
p = QPainter(pm)
p.drawPixmap(QPoint((ICON_SIZE - src.width()) / 2, (ICON_SIZE - src.height()) / 2), src)
p.end()
return QIcon(pm)
def paintEvent(self, ev):
if self.timer.isActive():
if not self.errored_out:
try:
draw_snake_spinner(QPainter(self), self.rect(), self.angle, self.light, self.dark)
except Exception:
import traceback
traceback.print_exc()
self.errored_out = True
else:
r = self.rect()
painter = QPainter(self)
painter.setRenderHint(QPainter.SmoothPixmapTransform, True)
icon = downloads_icon()
pmap = icon.pixmap(r.width(), r.height())
x = (r.width() - int(pmap.width() / pmap.devicePixelRatio())) // 2
y = (r.height() - int(pmap.height() / pmap.devicePixelRatio())) // 2 + 1
painter.drawPixmap(x, y, pmap)
def paintEvent(self, event):
if self.pixmap.isNull():
return
canvas_size = self.rect()
width = self.current_pixmap_size.width()
extrax = canvas_size.width() - width
if extrax < 0:
extrax = 0
x = int(extrax / 2.0)
height = self.current_pixmap_size.height()
extray = canvas_size.height() - height
if extray < 0:
extray = 0
y = int(extray / 2.0)
target = QRect(x, y, min(canvas_size.width(), width), min(canvas_size.height(), height))
p = QPainter(self)
p.setRenderHints(QPainter.Antialiasing | QPainter.SmoothPixmapTransform)
p.drawPixmap(target, self.pixmap.scaled(target.size(), Qt.KeepAspectRatio, Qt.SmoothTransformation))
p.end()
def paintEvent(self, ev):
if self.timer.isActive():
if not self.errored_out:
try:
draw_snake_spinner(QPainter(self), self.rect(), self.angle,
self.light, self.dark)
except Exception:
import traceback
traceback.print_exc()
self.errored_out = True
else:
r = self.rect()
painter = QPainter(self)
painter.setRenderHint(QPainter.SmoothPixmapTransform, True)
icon = downloads_icon()
pmap = icon.pixmap(r.width(), r.height())
x = (r.width() - int(pmap.width() / pmap.devicePixelRatio())) // 2
y = (r.height() -
int(pmap.height() / pmap.devicePixelRatio())) // 2 + 1
painter.drawPixmap(x, y, pmap)
def paintEvent(self, event):
pmap = self.blank if self.pixmap is None or self.pixmap.isNull() else self.pixmap
target = self.rect()
scaled, width, height = fit_image(pmap.width(), pmap.height(), target.width(), target.height())
target.setRect(target.x(), target.y(), width, height)
p = QPainter(self)
p.setRenderHints(QPainter.Antialiasing | QPainter.SmoothPixmapTransform)
p.drawPixmap(target, pmap)
if self.pixmap is not None and not self.pixmap.isNull():
sztgt = target.adjusted(0, 0, 0, -4)
f = p.font()
f.setBold(True)
p.setFont(f)
sz = u'\u00a0%d x %d\u00a0'%(self.pixmap.width(), self.pixmap.height())
flags = Qt.AlignBottom|Qt.AlignRight|Qt.TextSingleLine
szrect = p.boundingRect(sztgt, flags, sz)
p.fillRect(szrect.adjusted(0, 0, 0, 4), QColor(0, 0, 0, 200))
p.setPen(QPen(QColor(255,255,255)))
p.drawText(sztgt, flags, sz)
p.end()
def paintEvent(self, event):
if self._flag_1:
qp = QPainter()
qp.begin(self)
qp.setBrush(QColor(255, 237,
0)) # задаем желтый цвет для рамки выбора
qp.drawRect(self._col * 40 + 15, self._activ_pic * 50, 50,
50) # задаем положение и размер рамки выбора
for i in range(self._col):
for j in range(self._row):
qp.setBrush(QColor(50, 50, 50))
qp.drawRect(i * 40, j * 40, 40, 40)
qp.drawPixmap(i * 40, j * 40, self._elem_map[
self._sp_map[j][i]]) # рисуем картинками из elem_map
for i in range(PIC):
qp.drawPixmap(self._col * 40 + 20, i * 50 + 5,
self._elem_map[i])
if self._mouse_x < self._col * 40 and self._mouse_y < self._row * 40:
qp.drawPixmap(self._mouse_x - 30, self._mouse_y - 30,
self._elem_map[self._activ_pic])
qp.end()
def paintEvent(self, event):
QWidget.paintEvent(self, event)
pmap = self._pixmap
if pmap.isNull():
return
w, h = pmap.width(), pmap.height()
ow, oh = w, h
cw, ch = self.rect().width(), self.rect().height()
scaled, nw, nh = fit_image(w, h, cw, ch)
if scaled:
pmap = pmap.scaled(int(nw * pmap.devicePixelRatio()),
int(nh * pmap.devicePixelRatio()),
Qt.IgnoreAspectRatio, Qt.SmoothTransformation)
w, h = int(pmap.width() / pmap.devicePixelRatio()), int(
pmap.height() / pmap.devicePixelRatio())
x = int(abs(cw - w) / 2.)
y = int(abs(ch - h) / 2.)
target = QRect(x, y, w, h)
p = QPainter(self)
p.setRenderHints(QPainter.Antialiasing
| QPainter.SmoothPixmapTransform)
p.drawPixmap(target, pmap)
if self.draw_border:
pen = QPen()
pen.setWidth(self.BORDER_WIDTH)
p.setPen(pen)
p.drawRect(target)
if self.show_size:
sztgt = target.adjusted(0, 0, 0, -4)
f = p.font()
f.setBold(True)
p.setFont(f)
sz = u'\u00a0%d x %d\u00a0' % (ow, oh)
flags = Qt.AlignBottom | Qt.AlignRight | Qt.TextSingleLine
szrect = p.boundingRect(sztgt, flags, sz)
p.fillRect(szrect.adjusted(0, 0, 0, 4), QColor(0, 0, 0, 200))
p.setPen(QPen(QColor(255, 255, 255)))
p.drawText(sztgt, flags, sz)
p.end()
def paintEvent(self, ev):
if self.before_image is None:
return
canvas_size = self.rect()
p = QPainter(self)
p.setRenderHints(QPainter.Antialiasing | QPainter.SmoothPixmapTransform)
p.drawPixmap(canvas_size, self.before_image, self.before_image.rect())
if self.after_image is not None:
width = self._current_width
iw = self.after_image.width()
sh = min(self.after_image.height(), canvas_size.height())
if self.flip_forwards:
source = QRect(max(0, iw - width), 0, width, sh)
else:
source = QRect(0, 0, width, sh)
target = QRect(source)
target.moveLeft(0)
p.drawPixmap(target, self.after_image, source)
p.end()
def paintEvent(self, event):
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
if self.isDown():
painter.translate(1, 1)
font = QFont()
font.setPixelSize(14)
painter.setFont(font)
if self._hover or self.isChecked():
color = self.palette().highlight().color()
icon = self._hover_icon
else:
color = self.palette().text().color()
icon = self._icon
painter.setPen(color)
icon_size = self._icon.size()
if self._text:
text_size = painter.fontMetrics().size(0, self._text)
label_height = (text_size.height() + self._spacing +
icon_size.height())
else:
label_height = icon_size.height()
center = self.contentsRect().center()
painter.drawPixmap(center.x() - icon_size.width() / 2,
center.y() - label_height / 2, icon)
if self._text:
painter.drawText(center.x() - text_size.width() / 2,
center.y() - label_height / 2, text_size.width(),
label_height, Qt.AlignBottom | Qt.AlignVCenter,
self._text)
def paintEvent(self, ev):
if self.before_image is None:
return
canvas_size = self.rect()
p = QPainter(self)
p.setRenderHints(QPainter.Antialiasing
| QPainter.SmoothPixmapTransform)
p.drawPixmap(canvas_size, self.before_image, self.before_image.rect())
if self.after_image is not None:
width = self._current_width
iw = self.after_image.width()
sh = min(self.after_image.height(), canvas_size.height())
if self.flip_forwards:
source = QRect(max(0, iw - width), 0, width, sh)
else:
source = QRect(0, 0, width, sh)
target = QRect(source)
target.moveLeft(0)
p.drawPixmap(target, self.after_image, source)
p.end()
def paintEvent(self, event):
QWidget.paintEvent(self, event)
pmap = self._pixmap
if pmap.isNull():
return
w, h = pmap.width(), pmap.height()
ow, oh = w, h
cw, ch = self.rect().width(), self.rect().height()
scaled, nw, nh = fit_image(w, h, cw, ch)
if scaled:
pmap = pmap.scaled(int(nw*pmap.devicePixelRatio()), int(nh*pmap.devicePixelRatio()), Qt.IgnoreAspectRatio,
Qt.SmoothTransformation)
w, h = int(pmap.width()/pmap.devicePixelRatio()), int(pmap.height()/pmap.devicePixelRatio())
x = int(abs(cw - w)/2.)
y = int(abs(ch - h)/2.)
target = QRect(x, y, w, h)
p = QPainter(self)
p.setRenderHints(QPainter.Antialiasing | QPainter.SmoothPixmapTransform)
p.drawPixmap(target, pmap)
if self.draw_border:
pen = QPen()
pen.setWidth(self.BORDER_WIDTH)
p.setPen(pen)
p.drawRect(target)
if self.show_size:
sztgt = target.adjusted(0, 0, 0, -4)
f = p.font()
f.setBold(True)
p.setFont(f)
sz = u'\u00a0%d x %d\u00a0'%(ow, oh)
flags = Qt.AlignBottom|Qt.AlignRight|Qt.TextSingleLine
szrect = p.boundingRect(sztgt, flags, sz)
p.fillRect(szrect.adjusted(0, 0, 0, 4), QColor(0, 0, 0, 200))
p.setPen(QPen(QColor(255,255,255)))
p.drawText(sztgt, flags, sz)
p.end()
def paintEvent(self, event):
qp = QPainter()
qp.begin(self)
if self._flag_1:
for i in range(self.map.get_col()):
for j in range(self.map.get_row()):
qp.drawPixmap(
i * 40, j * 40 + 40,
self.map.get_elem_xy(
i, j).get_pic()) # рисуем картинками из elem_map
qp.drawPixmap(self.hero.get_x() * 40,
self.hero.get_y() * 40 + 40, self.hero.get_pic())
for enemy in self.enemies:
qp.drawPixmap(enemy.get_x() * 40,
enemy.get_y() * 40 + 40, enemy.get_pic())
for i in range(game.hero.get_lifes()):
qp.drawPixmap(280 + i * 40, 0,
self.hero._pic[self.hero._STOP][0])
txt = "00000" + str(self._score)
self.lable_score.setText(txt[len(txt) - 5:len(txt)])
qp.end()
def paintEvent(self, event):
painter = QPainter(self)
if self._inspect:
painter.drawPixmap(
(self.width() - self._inspect_map.width()) / 2,
(self.height() - self._inspect_map.height()) / 2,
self._inspect_map)
return
if self._pixmap.width() > 50:
painter.setRenderHint(QPainter.SmoothPixmapTransform)
painter.drawPixmap(self._paint_rect, self._pixmap)
else:
painter.drawPixmap((self.width() - self._pixmap.width()) / 2,
(self.height() - self._pixmap.height()) / 2,
self._pixmap)
if self._hover:
painter.setPen(QPen(self.palette().highlight().color(), 2))
painter.drawRect(self._paint_rect)
class PaintBoard(QWidget):
def __init__(self, Parent=None):
super().__init__(Parent)
self.__InitData() #先初始化数据，再初始化界面
self.__InitView()
def __InitData(self):
self.__size = QSize(1024, 512)
#新建QPixmap作为画板，尺寸为__size
self.__board = QPixmap(self.__size)
self.__board.fill(Qt.white) #用白色填充画板
self.__IsEmpty = True #默认为空画板
self.EraserMode = False #默认为禁用橡皮擦模式
self.__lastPos = QPoint(0, 0) #上一次鼠标位置
self.__currentPos = QPoint(0, 0) #当前的鼠标位置
self.__painter = QPainter() #新建绘图工具
self.__thickness = 6 #默认画笔粗细为6px
self.__eraser = 20
def __InitView(self):
#设置界面的尺寸为__size
self.setFixedSize(self.__size)
def Clear(self):
#清空画板
self.__board.fill(Qt.white)
self.update()
self.__IsEmpty = True
def ChangePenThickness(self, eraser=20):
#改变橡皮画笔粗细,默认20px
self.__eraser = eraser
def IsEmpty(self):
#返回画板是否为空
return self.__IsEmpty
def GetContentAsQImage(self):
#获取画板内容（返回QImage）
image = self.__board.toImage()
return image
def paintEvent(self, paintEvent):
#绘图事件
#绘图时必须使用QPainter的实例，此处为__painter
#绘图在begin()函数与end()函数间进行
#begin(param)的参数要指定绘图设备，即把图画在哪里
#drawPixmap用于绘制QPixmap类型的对象
self.__painter.begin(self)
# 0,0为绘图的左上角起点的坐标，__board即要绘制的图
self.__painter.drawPixmap(0, 0, self.__board)
self.__painter.end()
def mousePressEvent(self, mouseEvent):
#鼠标按下时，获取鼠标的当前位置保存为上一次位置
self.__currentPos = mouseEvent.pos()
self.__lastPos = self.__currentPos
def mouseMoveEvent(self, mouseEvent):
#鼠标移动时，更新当前位置，并在上一个位置和当前位置间画线
self.__currentPos = mouseEvent.pos()
self.__painter.begin(self.__board)
if self.EraserMode == False:
#非橡皮擦模式
self.__painter.setPen(
QPen(Qt.red, 6, Qt.SolidLine, Qt.RoundCap,
Qt.RoundJoin)) #设置画笔颜色，粗细
else:
#橡皮擦模式下画笔为纯白色
self.__painter.setPen(
QPen(Qt.white, self.__eraser, Qt.SolidLine, Qt.RoundCap,
Qt.RoundJoin))
#画线
self.__painter.drawLine(self.__lastPos, self.__currentPos)
self.__painter.end()
self.__lastPos = self.__currentPos
self.update() #更新显示
def mouseReleaseEvent(self, mouseEvent):
self.__IsEmpty = False #画板不再为空
def paintEvent(self, ev):
p = QPainter(self)
p.setOpacity(min(1, abs(1 - self._fraction)))
p.drawPixmap(self.rect(), self.icon)
p.end()
def paintEvent(self, e):
painter = QPainter(self)
h = self.pixmap.height() / 2
painter.drawPixmap(self.rect(), self.pixmap,
QRect(0, h * (1 if self.isOn else 0),
self.pixmap.width(), h))
class PaintBoard(QWidget):
set_paint = pyqtSignal(bool)
def __init__(self, signals: ClientSignal, Parent=None):
'''
Constructor
'''
super().__init__(Parent)
self.Signals = signals
# 是否是本玩家在画图
# 判断是否需要发送画图信息
self.Painting = False
self.BoardSize = QSize(*board_resolution)
# 新建QPixmap作为画板，尺寸为size
self.Board = QPixmap(self.BoardSize)
self.Board.fill(Qt.white) # 用白色填充画板
self.IsEmpty = True # 默认为空画板
self.EraserMode = False # 默认为禁用橡皮擦模式
self.LastPos = QPoint(0, 0) # 上一次鼠标位置
self.CurrentPos = QPoint(0, 0) # 当前的鼠标位置
self.Painter = QPainter() # 新建绘图工具
self.Thickness = default_thickness # 默认画笔粗细为10px
self.PenColor = QColor(default_color) # 设置默认画笔颜色为黑色
self.ColorList = QColor.colorNames() # 获取颜色列表
self.set_paint.connect(self.set_painting)
self.PaintPoints = []
self.init_view()
def init_view(self):
# 设置界面的尺寸为size
self.setFixedSize(self.BoardSize)
def set_painting(self, painting):
# print('seting painting to', painting)
self.Painting = painting
def set_pen_thickness(self, thickness):
self.Thickness = int(thickness)
def set_pen_color(self, color):
self.PenColor = QColor(color)
def set_eraser(self, e):
self.EraserMode = e
if self.Painting:
self.Signals.EraserChangeSignal.emit(e)
# self.EraserSender.emit(e)
def clear(self):
if self.Painting:
self.Signals.ClearSignal.emit()
# self.ClearSender.emit()
# 清空画板
self.Board.fill(Qt.white)
self.repaint()#update()
self.IsEmpty = True
def change_pen_color(self, color="black"):
print('color changed:', color)
if self.Painting:
self.Signals.ColorChangeSignal.emit(color)
# self.ColorSender.emit(color)
# 改变画笔颜色
self.PenColor = QColor(color)
def change_pen_thickness(self, thickness=default_thickness):
if self.Painting:
self.Signals.ThicknessChangeSignal.emit(thickness)
# self.ThicknessSender.emit(thickness)
# 改变画笔粗细
self.Thickness = thickness
# print('thickness:',type(self.thickness), self.thickness)
# 返回画板是否为空
def is_empty(self):
return self.IsEmpty
def get_content_as_QImage(self):
# 获取画板内容（返回QImage）
image = self.Board.toImage()
return image
def paintEvent(self, paintEvent):
# 绘图事件
# 绘图时必须使用QPainter的实例，此处为painter
# 绘图在begin()函数与end()函数间进行
# begin(param)的参数要指定绘图设备，即把图画在哪里
# drawPixmap用于绘制QPixmap类型的对象
self.Painter.begin(self)
# 0,0为绘图的左上角起点的坐标，board即要绘制的图
self.Painter.drawPixmap(0, 0, self.Board)
self.Painter.end()
def mousePressEvent(self, mouseEvent):
# 鼠标按下时，获取鼠标的当前位置保存为上一次位置
self.CurrentPos = mouseEvent.pos()
self.LastPos = self.CurrentPos
if self.Painting:
self.Signals.ClickPointSignal.emit(mouseEvent.pos())
# self.click_point_sender.emit(mouseEvent.pos())
def mouseMoveEvent(self, mouseEvent):
# print('moving! painting=', self.Painting)
if self.Painting:
# 鼠标移动时，更新当前位置，并在上一个位置和当前位置间画线
self.CurrentPos = mouseEvent.pos()
self.paint_point()
# print('painting...')
self.repaint()
# print('complete painting...')
self.LastPos = self.CurrentPos
# self.paint_points.append([self.currentPos.x(), self.currentPos.y()])
# self.paint_point_sender.emit(mouseEvent.pos())
self.Signals.PaintPointSignal.emit(mouseEvent.pos())
def mouseReleaseEvent(self, mouseEvent):
self.IsEmpty = False # 画板不再为空
if self.Painting:
self.Signals.ReleasePointSignal.emit()
# self.release_point_sender.emit()
# self.paint_points.clear()
def paint_point(self):
self.Painter.begin(self.Board)
if not self.EraserMode:
# 非橡皮擦模式
self.Painter.setPen(QPen(self.PenColor, self.Thickness)) # 设置画笔颜色，粗细
else:
# 橡皮擦模式下画笔为纯白色，粗细为10
self.Painter.setPen(QPen(Qt.white, 10))
# 画线
self.Painter.drawLine(self.LastPos, self.CurrentPos)
self.Painter.end()
def extern_click(self, x, y):
self.LastPos = QPoint(x, y)
self.CurrentPos = QPoint(x, y)
def extern_paint(self, ps):
for x,y in ps:
self.CurrentPos = QPoint(x, y)
self.paint_point()
self.LastPos = self.CurrentPos
self.repaint()
def reset_last_point(self, x, y):
self.LastPos = QPoint(x, y)
self.CurrentPos = QPoint(x, y)
class PaintBoard(QWidget):
def __init__(self, parent=None):
super().__init__(parent)
self.__size = QSize(350, 350)
# 新建画板，尺寸为__size
self.__board = QPixmap(self.__size)
self.__board.fill(Qt.white) # 用白色填充画板
self.__painter = QPainter() # 新建绘图工具
self.eraser_mode = False # 默认为禁用橡皮擦模式
self.__thickness = 6 # 默认画笔粗细为10px
self.__lastPos = QPoint(0, 0) # 上一次鼠标位置
self.__currentPos = QPoint(0, 0) # 当前的鼠标位置
self.__undo_num = 0
self.__redo_num = 0
self.__undo_list = []
self.__redo_list = []
self.__undo_list.append(self.__board.toImage())
# 设置界面的尺寸为__size
self.setFixedSize(self.__size)
def clear(self):
self.__board.fill(Qt.white)
# 清空画板
self.update()
self.__undo_list.append(self.__board.toImage())
self.__redo_list = []
self.__undo_num += 1
self.__redo_num = 0
def up(self, image):
self.__board = image
# 清空画板
self.update()
self.__undo_list.append(self.__board.toImage())
self.__redo_list = []
self.__undo_num += 1
self.__redo_num = 0
def undo(self):
if self.__undo_num > 0:
image = self.__undo_list[self.__undo_num - 1]
self.__board = QPixmap.fromImage(image)
self.update()
self.__redo_list.append(self.__undo_list.pop())
self.__redo_num += 1
self.__undo_num -= 1
def redo(self):
if self.__redo_num > 0:
image = self.__redo_list[self.__redo_num - 1]
self.__board = QPixmap(image)
self.update()
self.__undo_list.append(self.__redo_list.pop())
self.__redo_num -= 1
self.__undo_num += 1
def change_pen_thickness(self, thickness=10):
# 改变画笔粗细
self.__thickness = thickness
def get_content_as_image(self):
# 获取画板内容（返回QImage）
image = self.__board.toImage()
return image
def paintEvent(self, paint_event):
# 绘图事件
# 绘图时必须使用QPainter的实例，此处为__painter
# 绘图在begin()函数与end()函数间进行
# begin(param)的参数要指定绘图设备，即把图画在哪里
self.__painter.begin(self)
# 0,0为绘图的左上角起点的坐标，__board即要绘制的图
self.__painter.drawPixmap(0, 0, self.__board)
self.__painter.end()
def mouse_press_event(self, mouse_event):
# 鼠标按下时，获取鼠标的当前位置保存为上一次位置
# self.__currentPos = mouse_event.pos()
self.__currentPos.setX(mouse_event.pos().x() - 803)
self.__currentPos.setY(mouse_event.pos().y() - 147)
self.__lastPos = self.__currentPos
def mouse_move_event(self, mouse_event):
# self.__currentPos = mouse_event.pos()
# 鼠标移动时，更新当前位置，并在上一个位置和当前位置间画线
self.__currentPos.setX(mouse_event.pos().x() - 803)
self.__currentPos.setY(mouse_event.pos().y() - 147)
self.__painter.begin(self.__board)
if not self.eraser_mode:
# 非橡皮擦模式
self.__painter.setPen(QPen(Qt.black,
self.__thickness)) # 设置画笔颜色，粗细
else:
# 橡皮擦模式下画笔为纯白色，粗细为10
self.__painter.setPen(QPen(Qt.white, self.__thickness))
# 画线
self.__painter.drawLine(self.__lastPos, self.__currentPos)
self.__painter.end()
self.__lastPos = self.__currentPos
self.update() # 更新显示
def mouse_release_event(self, mouse_event):
self.__undo_list.append(self.__board.toImage())
self.__redo_list = []
self.__undo_num += 1
self.__redo_num = 0
def paintEvent(self, ev):
if self.pixmap is not None:
x = (self.width() - self.size) // 2
y = (self.height() - self.size) // 2
p = QPainter(self)
p.drawPixmap(x, y, self.size, self.size, self.pixmap)
class PaintBoard(QWidget):
def __init__(self, Parent=None):
'''
Constructor
'''
super().__init__(Parent)
self.__InitData() #先初始化数据，再初始化界面
self.__InitView()
def __InitView(self):
self.setFixedSize(self.__size)
def __InitData(self):
self.__size = QSize(1600,1200)
self.__board = QPixmap(self.__size) #新建QPixmap作为画板，宽350px,高250px
self.__board.fill(Qt.white) #用白色填充画板
self.__IsEmpty = True #默认为空画板
self.EraserMode = False #默认为禁用橡皮擦模式
self.__lastPos = QPoint(0,0)
self.__currentPos = QPoint(0,0)
self.__painter = QPainter()
self.__thickness = 10 #默认画笔粗细为10px
self.__penColor = QColor("black") #设置默认画笔颜色为黑色
self.__colorList = QColor.colorNames() #获取颜色列表
def Clear(self):
#清空画板
self.__board.fill(Qt.white)
self.update()
self.__IsEmpty = True
def ChangePenColor(self, color="black"):
#改变画笔颜色
self.__penColor = QColor(color)
def ChangePenThickness(self, thickness=10):
#改变画笔粗细
self.__thickness = thickness
def IsEmpty(self):
#返回画板是否为空
return self.__IsEmpty
def GetContentAsQImage(self):
#获取画板内容（返回QImage）
image = self.__board.toImage()
return image
def paintEvent(self, paintEvent):
self.__painter.begin(self)
self.__painter.drawPixmap(0,0,self.__board)
self.__painter.end()
def mousePressEvent(self, mouseEvent):
self.__currentPos = mouseEvent.pos()
self.__lastPos = self.__currentPos
def mouseMoveEvent(self, mouseEvent):
self.__currentPos = mouseEvent.pos()
self.__painter.begin(self.__board)
if self.EraserMode == False:
#非橡皮擦模式
self.__painter.setPen(QPen(self.__penColor,self.__thickness)) #设置画笔颜色，粗细
else:
#橡皮擦模式下画笔为纯白色，粗细为10
self.__painter.setPen(QPen(Qt.white,10))
self.__painter.drawLine(self.__lastPos, self.__currentPos)
self.__painter.end()
self.__lastPos = self.__currentPos
self.update() #更新显示
def mouseReleaseEvent(self, mouseEvent):
self.__IsEmpty = False #画板不再为空
def paintEvent(self, evt):
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
w = self.width()
hw = self._handle_width
w -= hw
h = self.height()
if self.maximum() == 0:
tw = 0
else:
tw = w / self.maximum()
# bar map
painter.drawPixmap(0, 0, self._bar_map)
# crop
painter.translate(hw / 2, 0)
body_mode = state.get('body_mode')
if state.get('Crop') or state.get('Loop'):
cw, ch, oh = self._crop_size
clip_range = 'crop_range'
if body_mode is BodyMode.MODEL:
clip_range = 'loop_range'
sc, ec = state.get(clip_range)
if sc is not None and ec is not None:
painter.fillRect(
tw * sc, h - ch - oh,
tw * (ec - sc), ch / 2,
self.palette().base().color()
)
if sc is not None:
painter.fillPath(
self._crop_path.translated(tw * sc - cw / 2, h - ch - oh),
self._crop_brush
)
if ec is not None:
painter.fillPath(
self._crop_path.translated(tw * ec - cw / 2, h - ch - oh),
self._crop_brush
)
painter.translate(-hw / 2, 0)
# normal
super().paintEvent(evt)
frames = state.get('frames')
fm = painter.fontMetrics()
text = str(frames[self.value()])
width = fm.width(text)
x = self.value() * tw - width / 2 + hw / 2
x_max_width = self.width() - width
if x < 0:
x = 0
elif x > x_max_width:
x = x_max_width
painter.drawText(
x, 0, width, 20,
Qt.AlignCenter,
text
)
def paintEvent(self, ev):
p = QPainter(self)
p.setOpacity(min(1, abs(1 - self._fraction)))
p.drawPixmap(self.rect(), self.icon)
p.end()
def paintEvent(self, ev):
if self.pixmap is not None:
x = (self.width() - self.size) // 2
y = (self.height() - self.size) // 2
p = QPainter(self)
p.drawPixmap(x, y, self.size, self.size, self.pixmap)
class PaintBoard(QWidget):
def __init__(self, Parent=None):
'''
Constructor
'''
super().__init__(Parent)
self.__InitData() # 先初始化数据，再初始化界面
self.__InitView()
def __InitData(self):
self.__size = QSize(480, 460)
# 新建QPixmap作为画板，尺寸为__size
self.__board = QPixmap(self.__size)
self.__board.fill(Qt.white) # 用白色填充画板
self.__IsEmpty = True # 默认为空画板
self.EraserMode = False # 默认为禁用橡皮擦模式
self.__lastPos = QPoint(0, 0) # 上一次鼠标位置
self.__currentPos = QPoint(0, 0) # 当前的鼠标位置
self.__painter = QPainter() # 新建绘图工具
self.__thickness = 10 # 默认画笔粗细为10px
self.__penColor = QColor("black") # 设置默认画笔颜色为黑色
self.__colorList = QColor.colorNames() # 获取颜色列表
def __InitView(self):
# 设置界面的尺寸为__size
self.setFixedSize(self.__size)
def Clear(self):
# 清空画板
self.__board.fill(Qt.white)
self.update()
self.__IsEmpty = True
def ChangePenColor(self, color="black"):
# 改变画笔颜色
self.__penColor = QColor(color)
def ChangePenThickness(self, thickness=10):
# 改变画笔粗细
self.__thickness = thickness
def IsEmpty(self):
# 返回画板是否为空
return self.__IsEmpty
def GetContentAsQImage(self):
# 获取画板内容（返回QImage）
image = self.__board.toImage()
return image
def paintEvent(self, paintEvent):
# 绘图事件
# 绘图时必须使用QPainter的实例，此处为__painter
# 绘图在begin()函数与end()函数间进行
# begin(param)的参数要指定绘图设备，即把图画在哪里
# drawPixmap用于绘制QPixmap类型的对象
self.__painter.begin(self)
# 0,0为绘图的左上角起点的坐标，__board即要绘制的图
self.__painter.drawPixmap(0, 0, self.__board)
self.__painter.end()
def mousePressEvent(self, mouseEvent):
# 鼠标按下时，获取鼠标的当前位置保存为上一次位置
self.__currentPos = mouseEvent.pos()
self.__lastPos = self.__currentPos
def mouseMoveEvent(self, mouseEvent):
# 鼠标移动时，更新当前位置，并在上一个位置和当前位置间画线
self.__currentPos = mouseEvent.pos()
self.__painter.begin(self.__board)
if self.EraserMode == False:
# 非橡皮擦模式
self.__painter.setPen(QPen(self.__penColor, self.__thickness)) # 设置画笔颜色，粗细
else:
# 橡皮擦模式下画笔为纯白色，粗细为10
self.__painter.setPen(QPen(Qt.white, 10))
# 画线
self.__painter.drawLine(self.__lastPos, self.__currentPos)
self.__painter.end()
self.__lastPos = self.__currentPos
self.update() # 更新显示
def mouseReleaseEvent(self, mouseEvent):
self.__IsEmpty = False # 画板不再为空
def paintEvent(self, event):
'''
@param event QPaintEvent
'''
p = QPainter(self)
p.setRenderHint(QPainter.Antialiasing)
size = 16
pixmapSize = round(size *
self.data().animationPixmap.devicePixelRatioF())
# Center the pixmap in rect
r = QRect(self.rect())
r.setX((r.width() - size) / 2)
r.setY((r.height() - size) / 2)
r.setWidth(size)
r.setHeight(size)
if self._animationRunning:
p.drawPixmap(
r,
self.data().animationPixmap,
QRect(self._currentFrame * pixmapSize, 0, pixmapSize,
pixmapSize))
elif self._audioIconDisplayed and not self._tab.isPinned():
self._audioIconRect = QRect(r)
p.drawPixmap(
r,
self._tab.isMuted() and self.data().audioMutedPixmap
or self.data().audioPlayingPixmap)
elif not self._sitePixmap.isNull():
p.drawPixmap(r, self._sitePixmap)
elif self._tab and self._tab.isPinned():
p.drawPixmap(r, IconProvider.emptyWebIcon().pixmap(size))
# Draw audio icon on top of site icon for pinned tabs
if not self._animationRunning and self._audioIconDisplayed and self._tab.isPinned(
):
s = size - 4
r0 = QRect(self.width() - 4, 0, s, s)
self._audioIconRect = r0
c = self.palette().color(QPalette.Window)
c.setAlpha(180)
p.setPen(c)
p.setBrush(c)
p.drawEllipse(r)
p.drawPixmap(
r,
self._tab.isMuted() and self.data().audioMutedPixmap
or self.data().audioPlayingPixmap)
# Draw background activity indicator
if self._tab and self._tab.isPinned() and self._tab.webView(
).backgroundActivity():
s = 5
# Background
r1 = QRect(self.width() - s - 2,
self.height() - s - 2, s + 2, s + 2)
c1 = self.palette().color(QPalette.Window)
c1.setAlpha(180)
p.setPen(Qt.transparent)
p.setBrush(c1)
p.drawEllipse(r1)
# Forground
r2 = QRect(self.width() - s - 1, self.height() - s - 1, s, s)
c2 = self.palette().color(QPalette.Text)
p.setPen(Qt.transparent)
p.setBrush(c2)
p.drawEllipse(r2)
