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.RenderHint.Antialiasing
| QPainter.RenderHint.SmoothPixmapTransform)
try:
dpr = self.devicePixelRatioF()
except AttributeError:
dpr = self.devicePixelRatio()
spmap = self.pixmap.scaled(target.size() * dpr,
Qt.AspectRatioMode.KeepAspectRatio,
Qt.TransformationMode.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 = '\u00a0%d x %d\u00a0' % (self.pixmap.width(),
self.pixmap.height())
flags = Qt.AlignmentFlag.AlignBottom | Qt.AlignmentFlag.AlignRight | Qt.TextFlag.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 failed_img(self):
if self._failed_img is None:
try:
dpr = self.devicePixelRatioF()
except AttributeError:
dpr = self.devicePixelRatio()
i = QImage(200, 150, QImage.Format.Format_ARGB32)
i.setDevicePixelRatio(dpr)
i.fill(Qt.GlobalColor.white)
p = QPainter(i)
r = i.rect().adjusted(10, 10, -10, -10)
n = QPen(Qt.PenStyle.DashLine)
n.setColor(Qt.GlobalColor.black)
p.setPen(n)
p.drawRect(r)
p.setPen(Qt.GlobalColor.black)
f = self.font()
f.setPixelSize(20)
p.setFont(f)
p.drawText(r.adjusted(10, 0, -10, 0), Qt.AlignmentFlag.AlignCenter | Qt.TextFlag.TextWordWrap, _('Image could not be rendered'))
p.end()
self._failed_img = QPixmap.fromImage(i)
return self._failed_img
def paintEvent(self, ev):
offset = QPoint(0, 0)
p = QPainter(self)
p.setClipRect(ev.rect())
bottom = self.rect().bottom()
if self.results:
for i, (prefix, full, text) in enumerate(self.results):
size = prefix.size()
if offset.y() + size.height() > bottom:
break
self.max_result = i
offset.setX(0)
if i in (self.current_result, self.mouse_hover_result):
p.save()
if i != self.current_result:
p.setPen(Qt.PenStyle.DotLine)
p.drawLine(offset, QPoint(self.width(), offset.y()))
p.restore()
offset.setY(offset.y() + self.MARGIN // 2)
p.drawStaticText(offset, prefix)
offset.setX(self.maxwidth + 5)
p.drawStaticText(offset, self.divider)
offset.setX(offset.x() + int(ceil(self.divider.size().width())))
p.drawStaticText(offset, full)
offset.setY(int(offset.y() + size.height() + self.MARGIN // 2))
if i in (self.current_result, self.mouse_hover_result):
offset.setX(0)
p.save()
if i != self.current_result:
p.setPen(Qt.PenStyle.DotLine)
p.drawLine(offset, QPoint(self.width(), offset.y()))
p.restore()
else:
p.drawText(self.rect(), Qt.AlignmentFlag.AlignCenter, _('No results found'))
p.end()
def paintEvent(self, ev):
painter = QPainter(self)
painter.setClipRect(ev.rect())
pal = self.palette()
painter.fillRect(self.rect(), pal.color(QPalette.ColorRole.Text))
crect = self.rect().adjusted(1, 1, -1, -1)
painter.fillRect(crect, pal.color(QPalette.ColorRole.Base))
painter.setClipRect(crect)
painter.setFont(self.parent().font())
width = self.rect().width()
for i, st, y, height in self.iter_visible_items():
painter.save()
if i == self.current_index:
painter.fillRect(1, y, width, height,
pal.color(QPalette.ColorRole.Highlight))
color = pal.color(QPalette.ColorRole.HighlightedText).name()
st = QStaticText(st)
text = st.text().partition('>')[2]
st.setText('<span style="color: %s">%s' % (color, text))
painter.drawStaticText(self.SIDE_MARGIN, y, st)
painter.restore()
painter.end()
if self.current_size_hint is None:
QTimer.singleShot(0, self.layout)
def paintEvent(self, ev):
painter = QPainter(self)
painter.fillRect(ev.rect(), self.brush)
painter.end()
def paintEvent(self, ev):
p = QPainter(self)
pal = self.palette()
self.a.draw(p, self.rect(),
pal.color(QPalette.ColorRole.WindowText))
p.end()
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, event):
QSplitterHandle.paintEvent(self, event)
left, right = self.parent().left, self.parent().right
painter = QPainter(self)
painter.setClipRect(event.rect())
w = self.width()
h = self.height()
painter.setRenderHints(QPainter.RenderHint.Antialiasing, True)
C = 16 # Curve factor.
def create_line(ly, ry, right_to_left=False):
' Create path that represents upper or lower line of change marker '
line = QPainterPath()
if not right_to_left:
line.moveTo(0, ly)
line.cubicTo(C, ly, w - C, ry, w, ry)
else:
line.moveTo(w, ry)
line.cubicTo(w - C, ry, C, ly, 0, ly)
return line
ldoc, rdoc = left.document(), right.document()
lorigin, rorigin = left.contentOffset(), right.contentOffset()
lfv, rfv = left.firstVisibleBlock().blockNumber(), right.firstVisibleBlock().blockNumber()
lines = []
for (ltop, lbot, kind), (rtop, rbot, kind) in zip(left.changes, right.changes):
if lbot < lfv and rbot < rfv:
continue
ly_top = left.blockBoundingGeometry(ldoc.findBlockByNumber(ltop)).translated(lorigin).y()
ly_bot = left.blockBoundingGeometry(ldoc.findBlockByNumber(lbot)).translated(lorigin).y()
ry_top = right.blockBoundingGeometry(rdoc.findBlockByNumber(rtop)).translated(rorigin).y()
ry_bot = right.blockBoundingGeometry(rdoc.findBlockByNumber(rbot)).translated(rorigin).y()
if max(ly_top, ly_bot, ry_top, ry_bot) < 0:
continue
if min(ly_top, ly_bot, ry_top, ry_bot) > h:
break
upper_line = create_line(ly_top, ry_top)
lower_line = create_line(ly_bot, ry_bot, True)
region = QPainterPath()
region.moveTo(0, ly_top)
region.connectPath(upper_line)
region.lineTo(w, ry_bot)
region.connectPath(lower_line)
region.closeSubpath()
painter.fillPath(region, left.diff_backgrounds[kind])
for path, aa in zip((upper_line, lower_line), (ly_top != ry_top, ly_bot != ry_bot)):
lines.append((kind, path, aa))
for kind, path, aa in sorted(lines, key=lambda x:{'replace':0}.get(x[0], 1)):
painter.setPen(left.diff_foregrounds[kind])
painter.setRenderHints(QPainter.RenderHint.Antialiasing, aa)
painter.drawPath(path)
painter.setFont(left.heading_font)
for (lnum, text), (rnum, text) in zip(left.headers, right.headers):
ltop, lbot, rtop, rbot = lnum, lnum + 3, rnum, rnum + 3
if lbot < lfv and rbot < rfv:
continue
ly_top = left.blockBoundingGeometry(ldoc.findBlockByNumber(ltop)).translated(lorigin).y()
ly_bot = left.blockBoundingGeometry(ldoc.findBlockByNumber(lbot)).translated(lorigin).y()
ry_top = right.blockBoundingGeometry(rdoc.findBlockByNumber(rtop)).translated(rorigin).y()
ry_bot = right.blockBoundingGeometry(rdoc.findBlockByNumber(rbot)).translated(rorigin).y()
if max(ly_top, ly_bot, ry_top, ry_bot) < 0:
continue
if min(ly_top, ly_bot, ry_top, ry_bot) > h:
break
ly = painter.boundingRect(3, ly_top, left.width(), ly_bot - ly_top - 5, Qt.TextFlag.TextSingleLine, text).bottom() + 3
ry = painter.boundingRect(3, ry_top, right.width(), ry_bot - ry_top - 5, Qt.TextFlag.TextSingleLine, text).bottom() + 3
line = create_line(ly, ry)
painter.setPen(QPen(left.palette().text(), 2))
painter.setRenderHints(QPainter.RenderHint.Antialiasing, ly != ry)
painter.drawPath(line)
painter.end()
# Paint the splitter without the change lines if the mouse is over the
# splitter
if getattr(self, 'hover', False):
QSplitterHandle.paintEvent(self, event)
def decoration_for_style(palette, style, icon_size, device_pixel_ratio, is_dark):
style_key = (is_dark, icon_size, device_pixel_ratio, tuple((k, style[k]) for k in sorted(style)))
sentinel = object()
ans = decoration_cache.get(style_key, sentinel)
if ans is not sentinel:
return ans
ans = None
kind = style.get('kind')
if kind == 'color':
key = 'dark' if is_dark else 'light'
val = style.get(key)
if val is None:
which = style.get('which')
val = (builtin_colors_dark if is_dark else builtin_colors_light).get(which)
if val is None:
val = style.get('background-color')
if val is not None:
ans = QColor(val)
elif kind == 'decoration':
which = style.get('which')
if which is not None:
q = builtin_decorations.get(which)
if q is not None:
style = q
sz = int(math.ceil(icon_size * device_pixel_ratio))
canvas = QImage(sz, sz, QImage.Format.Format_ARGB32)
canvas.fill(Qt.GlobalColor.transparent)
canvas.setDevicePixelRatio(device_pixel_ratio)
p = QPainter(canvas)
p.setRenderHint(QPainter.RenderHint.Antialiasing, True)
p.setPen(palette.color(QPalette.ColorRole.WindowText))
irect = QRect(0, 0, icon_size, icon_size)
adjust = -2
text_rect = p.drawText(irect.adjusted(0, adjust, 0, adjust), Qt.AlignmentFlag.AlignHCenter| Qt.AlignmentFlag.AlignTop, 'a')
p.drawRect(irect)
fm = p.fontMetrics()
pen = p.pen()
if 'text-decoration-color' in style:
pen.setColor(QColor(style['text-decoration-color']))
lstyle = style.get('text-decoration-style') or 'solid'
q = {'dotted': Qt.PenStyle.DotLine, 'dashed': Qt.PenStyle.DashLine, }.get(lstyle)
if q is not None:
pen.setStyle(q)
lw = fm.lineWidth()
if lstyle == 'double':
lw * 2
pen.setWidth(fm.lineWidth())
q = style.get('text-decoration-line') or 'underline'
pos = text_rect.bottom()
height = irect.bottom() - pos
if q == 'overline':
pos = height
elif q == 'line-through':
pos = text_rect.center().y() - adjust - lw // 2
p.setPen(pen)
if lstyle == 'wavy':
p.drawPath(wavy_path(icon_size, height, pos))
else:
p.drawLine(0, pos, irect.right(), pos)
p.end()
ans = QPixmap.fromImage(canvas)
elif 'background-color' in style:
ans = QColor(style['background-color'])
decoration_cache[style_key] = ans
return ans
def add_image(self, img, cache_key):
ref = self.get_image(cache_key)
if ref is not None:
return ref
fmt = img.format()
image = QImage(img)
if (image.depth() == 1 and img.colorTable().size() == 2 and
img.colorTable().at(0) == QColor(Qt.GlobalColor.black).rgba()
and img.colorTable().at(1) == QColor(
Qt.GlobalColor.white).rgba()):
if fmt == QImage.Format.Format_MonoLSB:
image = image.convertToFormat(QImage.Format.Format_Mono)
fmt = QImage.Format.Format_Mono
else:
if (fmt != QImage.Format.Format_RGB32
and fmt != QImage.Format.Format_ARGB32):
image = image.convertToFormat(QImage.Format.Format_ARGB32)
fmt = QImage.Format.Format_ARGB32
w = image.width()
h = image.height()
d = image.depth()
if fmt == QImage.Format.Format_Mono:
bytes_per_line = (w + 7) >> 3
data = image.constBits().asstring(bytes_per_line * h)
return self.write_image(data, w, h, d, cache_key=cache_key)
has_alpha = False
soft_mask = None
if fmt == QImage.Format.Format_ARGB32:
tmask = image.constBits().asstring(4 * w * h)[self.alpha_bit::4]
sdata = bytearray(tmask)
vals = set(sdata)
vals.discard(255) # discard opaque pixels
has_alpha = bool(vals)
if has_alpha:
# Blend image onto a white background as otherwise Qt will render
# transparent pixels as black
background = QImage(image.size(),
QImage.Format.Format_ARGB32_Premultiplied)
background.fill(Qt.GlobalColor.white)
painter = QPainter(background)
painter.drawImage(0, 0, image)
painter.end()
image = background
ba = QByteArray()
buf = QBuffer(ba)
image.save(buf, 'jpeg', 94)
data = ba.data()
if has_alpha:
soft_mask = self.write_image(tmask, w, h, 8)
return self.write_image(data,
w,
h,
32,
dct=True,
soft_mask=soft_mask,
cache_key=cache_key)
