def generate_masthead(title,
output_path=None,
width=600,
height=60,
as_qimage=False,
font_family=None):
init_environment()
font_family = font_family or cprefs[
'title_font_family'] or 'Liberation Serif'
img = QImage(width, height, QImage.Format.Format_ARGB32)
img.fill(Qt.GlobalColor.white)
p = QPainter(img)
p.setRenderHints(QPainter.RenderHint.Antialiasing
| QPainter.RenderHint.TextAntialiasing)
f = QFont(font_family)
f.setStyleStrategy(QFont.StyleStrategy.PreferAntialias)
f.setPixelSize((height * 3) // 4), f.setBold(True)
p.setFont(f)
p.drawText(img.rect(),
Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter,
sanitize(title))
p.end()
if as_qimage:
return img
data = pixmap_to_data(img)
if output_path is None:
return data
with open(output_path, 'wb') as f:
f.write(data)
def paintEvent(self, ev):
if self.mouse_over:
p = QPainter(self)
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, p, self)
p.end()
return QLabel.paintEvent(self, ev)
def paintEvent(self, ev):
p = QPainter(self)
p.setClipRect(ev.rect())
bg = self.palette().color(QPalette.ColorRole.AlternateBase)
if self.hovering:
bg = bg.lighter(115)
p.fillRect(self.rect(), bg)
try:
p.drawText(self.rect(), Qt.AlignmentFlag.AlignLeft|Qt.AlignmentFlag.AlignVCenter|Qt.TextFlag.TextSingleLine, self.rendered_text)
finally:
p.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 rasterize_svg(self, elem, width=0, height=0, format='PNG'):
view_box = elem.get('viewBox', elem.get('viewbox', None))
sizes = None
logger = self.oeb.logger
if view_box is not None:
try:
box = [
float(x) for x in filter(None, re.split('[, ]', view_box))
]
sizes = [box[2] - box[0], box[3] - box[1]]
except (TypeError, ValueError, IndexError):
logger.warn(
'SVG image has invalid viewBox="%s", ignoring the viewBox'
% view_box)
else:
for image in elem.xpath(
'descendant::*[local-name()="image" and '
'@height and contains(@height, "%")]'):
logger.info(
'Found SVG image height in %, trying to convert...')
try:
h = float(image.get('height').replace('%', '')) / 100.
image.set('height', str(h * sizes[1]))
except:
logger.exception(
'Failed to convert percentage height:',
image.get('height'))
data = QByteArray(xml2str(elem, with_tail=False))
svg = QSvgRenderer(data)
size = svg.defaultSize()
if size.width() == 100 and size.height() == 100 and sizes:
size.setWidth(sizes[0])
size.setHeight(sizes[1])
if width or height:
size.scale(int(width), int(height),
Qt.AspectRatioMode.KeepAspectRatio)
logger.info('Rasterizing %r to %dx%d' %
(elem, size.width(), size.height()))
image = QImage(size, QImage.Format.Format_ARGB32_Premultiplied)
image.fill(QColor("white").rgb())
painter = QPainter(image)
svg.render(painter)
painter.end()
array = QByteArray()
buffer = QBuffer(array)
buffer.open(QIODevice.OpenModeFlag.WriteOnly)
image.save(buffer, format)
return array.data()
def render_svg(widget, path):
img = QPixmap()
rend = QSvgRenderer()
if rend.load(path):
dpr = getattr(widget, 'devicePixelRatioF', widget.devicePixelRatio)()
sz = rend.defaultSize()
h = (max_available_height() - 50)
w = int(h * sz.height() / float(sz.width()))
pd = QImage(w * dpr, h * dpr, QImage.Format.Format_RGB32)
pd.fill(Qt.GlobalColor.white)
p = QPainter(pd)
rend.render(p)
p.end()
img = QPixmap.fromImage(pd)
img.setDevicePixelRatio(dpr)
return img
def paintEvent(self, ev):
size = self._icon_size if self._icon_size > 10 else self.iconSize().width()
p = QPainter(self)
opt = QStyleOptionToolButton()
self.initStyleOption(opt)
s = self.style()
opt.iconSize = QSize(size, size)
s.drawComplexControl(QStyle.ComplexControl.CC_ToolButton, opt, p, self)
def __call__(self, canvas):
if canvas.has_selection and canvas.selection_state.rect is not None:
pimg = self.after_image
img = self.after_image = QImage(canvas.current_image)
rect = QRectF(*get_selection_rect(img, canvas.selection_state.rect, canvas.target))
p = QPainter(img)
p.setRenderHint(QPainter.RenderHint.SmoothPixmapTransform, True)
p.drawImage(rect, pimg, QRectF(pimg.rect()))
p.end()
return self.after_image
def paintEvent(self, ev):
if self.last_layout_rect != self.rect():
self.do_layout()
p = QPainter(self)
br = self.layout.boundingRect()
y = 0
if br.height() < self.height():
y = (self.height() - br.height()) / 2
self.layout.draw(p, QPointF(0, y))
def paintEvent(self, ev):
painter = QPainter(self)
painter.setRenderHint(QPainter.RenderHint.Antialiasing, True)
painter.setRenderHint(QPainter.RenderHint.SmoothPixmapTransform, True)
try:
if self.rendered_pixmap is None:
self.paint_background(painter)
else:
self.animated_paint(painter)
finally:
painter.end()
def message_image(text, width=500, height=400, font_size=20):
init_environment()
img = QImage(width, height, QImage.Format.Format_ARGB32)
img.fill(Qt.GlobalColor.white)
p = QPainter(img)
f = QFont()
f.setPixelSize(font_size)
p.setFont(f)
r = img.rect().adjusted(10, 10, -10, -10)
p.drawText(r, Qt.AlignmentFlag.AlignJustify | Qt.AlignmentFlag.AlignVCenter | Qt.TextFlag.TextWordWrap, text)
p.end()
return pixmap_to_data(img)
def rasterize_external(self, elem, style, item, svgitem):
width = style['width']
height = style['height']
width = (width / 72) * self.profile.dpi
height = (height / 72) * self.profile.dpi
data = QByteArray(svgitem.bytes_representation)
svg = QSvgRenderer(data)
size = svg.defaultSize()
size.scale(width, height, Qt.AspectRatioMode.KeepAspectRatio)
key = (svgitem.href, size.width(), size.height())
if key in self.images:
href = self.images[key]
else:
logger = self.oeb.logger
logger.info('Rasterizing %r to %dx%d'
% (svgitem.href, size.width(), size.height()))
image = QImage(size, QImage.Format.Format_ARGB32_Premultiplied)
image.fill(QColor("white").rgb())
painter = QPainter(image)
svg.render(painter)
painter.end()
array = QByteArray()
buffer = QBuffer(array)
buffer.open(QIODevice.OpenModeFlag.WriteOnly)
image.save(buffer, 'PNG')
data = array.data()
manifest = self.oeb.manifest
href = os.path.splitext(svgitem.href)[0] + '.png'
id, href = manifest.generate(svgitem.id, href)
manifest.add(id, href, PNG_MIME, data=data)
self.images[key] = href
elem.tag = XHTML('img')
for attr in elem.attrib:
if attr not in KEEP_ATTRS:
del elem.attrib[attr]
elem.attrib['src'] = item.relhref(href)
if elem.text:
elem.attrib['alt'] = elem.text
elem.text = None
for child in elem:
elem.remove(child)
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.GlobalColor.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.ItemDataRole.DecorationRole, icon)
def generate_cover(mi, prefs=None, as_qimage=False):
init_environment()
prefs = prefs or cprefs
prefs = {k: prefs.get(k) for k in cprefs.defaults}
prefs = Prefs(**prefs)
color_theme = random.choice(load_color_themes(prefs))
style = random.choice(load_styles(prefs))(color_theme, prefs)
title, subtitle, footer = format_text(mi, prefs)
img = QImage(prefs.cover_width, prefs.cover_height,
QImage.Format.Format_ARGB32)
title_block, subtitle_block, footer_block = layout_text(
prefs, img, title, subtitle, footer,
img.height() // 3, style)
p = QPainter(img)
rect = QRect(0, 0, img.width(), img.height())
colors = style(p, rect, color_theme, title_block, subtitle_block,
footer_block)
for block, color in zip((title_block, subtitle_block, footer_block),
colors):
p.setPen(color)
block.draw(p)
p.end()
img.setText('Generated cover', '{} {}'.format(__appname__, __version__))
if as_qimage:
return img
return pixmap_to_data(img)
def paintEvent(self, ev):
painter = QPainter(self)
# Purely subjective: shorten the line a bit to look 'better'
r = ev.rect()
r.setTop(r.top() + 3)
r.setBottom(r.bottom() - 3)
painter.fillRect(r, self.brush)
painter.end()
def calibre_cover2(title,
author_string='',
series_string='',
prefs=None,
as_qimage=False,
logo_path=None):
init_environment()
title, subtitle, footer = '<b>' + escape_formatting(
title), '<i>' + escape_formatting(
series_string), '<b>' + escape_formatting(author_string)
prefs = prefs or cprefs
prefs = {k: prefs.get(k) for k in cprefs.defaults}
scale = 800. / prefs['cover_height']
scale_cover(prefs, scale)
prefs = Prefs(**prefs)
img = QImage(prefs.cover_width, prefs.cover_height,
QImage.Format.Format_ARGB32)
img.fill(Qt.GlobalColor.white)
# colors = to_theme('ffffff ffffff 000000 000000')
color_theme = theme_to_colors(fallback_colors)
class CalibeLogoStyle(Style):
NAME = GUI_NAME = 'calibre'
def __call__(self, painter, rect, color_theme, title_block,
subtitle_block, footer_block):
top = title_block.position.y + 10
extra_spacing = subtitle_block.line_spacing // 2 if subtitle_block.line_spacing else title_block.line_spacing // 3
height = title_block.height + subtitle_block.height + extra_spacing + title_block.leading
top += height + 25
bottom = footer_block.position.y - 50
logo = QImage(logo_path or I('library.png'))
pwidth, pheight = rect.width(), bottom - top
scaled, width, height = fit_image(logo.width(), logo.height(),
pwidth, pheight)
x, y = (pwidth - width) // 2, (pheight - height) // 2
rect = QRect(x, top + y, width, height)
painter.setRenderHint(QPainter.RenderHint.SmoothPixmapTransform)
painter.drawImage(rect, logo)
return self.ccolor1, self.ccolor1, self.ccolor1
style = CalibeLogoStyle(color_theme, prefs)
title_block, subtitle_block, footer_block = layout_text(
prefs, img, title, subtitle, footer,
img.height() // 3, style)
p = QPainter(img)
rect = QRect(0, 0, img.width(), img.height())
colors = style(p, rect, color_theme, title_block, subtitle_block,
footer_block)
for block, color in zip((title_block, subtitle_block, footer_block),
colors):
p.setPen(color)
block.draw(p)
p.end()
img.setText('Generated cover', '{} {}'.format(__appname__, __version__))
if as_qimage:
return img
return pixmap_to_data(img)
def paintEvent(self, ev):
if self._animated_size < 1.0:
rect = self.rect()
painter = QPainter(self)
pal = self.palette()
col = pal.color(QPalette.ColorRole.Button)
rect.setLeft(rect.left() + int(rect.width() * self._animated_size))
painter.setClipRect(rect)
painter.fillRect(self.rect(), col)
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)
def paintEvent(self, event):
pmap = self.pixmap
if pmap is None:
return
target = self.rect()
scaled, width, height = fit_image(pmap.width(), pmap.height(), target.width(), target.height())
dx = 0
if target.width() > width + 1:
dx += (target.width() - width) // 2
target.setRect(target.x() + dx, target.y(), width, height)
p = QPainter(self)
p.setRenderHints(QPainter.RenderHint.Antialiasing | QPainter.RenderHint.SmoothPixmapTransform)
p.drawPixmap(target, pmap)
def paintEvent(self, event):
QWidget.paintEvent(self, event)
p = QPainter(self)
p.setRenderHints(QPainter.RenderHint.Antialiasing | QPainter.RenderHint.SmoothPixmapTransform)
try:
self.draw_background(p)
if self.original_image_data is None:
return
if not self.is_valid:
return self.draw_image_error(p)
self.load_pixmap()
self.draw_pixmap(p)
if self.selection_state.rect is not None:
self.draw_selection_rect(p)
finally:
p.end()
def paintEvent(self, ev):
p = QPainter(self)
p.setRenderHints(QPainter.RenderHint.Antialiasing)
p.setBrush(self.brush)
p.setPen(Qt.PenStyle.NoPen)
p.drawPath(self.arrow_path)
p.end()
def create_icon(text, palette=None, sz=None, divider=2, fill='white'):
if isinstance(fill, string_or_bytes):
fill = QColor(fill)
sz = sz or int(
math.ceil(tprefs['toolbar_icon_size'] *
QApplication.instance().devicePixelRatio()))
if palette is None:
palette = QApplication.palette()
img = QImage(sz, sz, QImage.Format.Format_ARGB32)
img.fill(Qt.GlobalColor.transparent)
p = QPainter(img)
p.setRenderHints(QPainter.RenderHint.TextAntialiasing
| QPainter.RenderHint.Antialiasing)
if fill is not None:
qDrawShadeRect(p,
img.rect(),
palette,
fill=fill,
lineWidth=1,
midLineWidth=1)
f = p.font()
f.setFamily('Liberation Sans'), f.setPixelSize(int(
sz // divider)), f.setBold(True)
p.setFont(f), p.setPen(QColor('#2271d5'))
p.drawText(img.rect().adjusted(2, 2, -2, -2), Qt.AlignmentFlag.AlignCenter,
text)
p.end()
return QIcon(QPixmap.fromImage(img))
def paintEvent(self, ev):
painter = QPainter(self)
painter.fillRect(ev.rect(), self.brush)
painter.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.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 paintEvent(self, ev):
QGraphicsView.paintEvent(self, ev)
if self.show_size:
v = self.viewport()
p = QPainter(v)
draw_size(p, v.rect(), *self.pixmap_size)
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.AspectRatioMode.IgnoreAspectRatio,
Qt.TransformationMode.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.RenderHint.Antialiasing
| QPainter.RenderHint.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, 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, ev):
br = ev.region().boundingRect()
p = QPainter(self)
p.setOpacity(0.2)
p.fillRect(br, QBrush(self.palette().text()))
p.end()
QWidget.paintEvent(self, ev)
p = QPainter(self)
p.setClipRect(br)
f = p.font()
f.setBold(True)
f.setPointSize(20)
p.setFont(f)
p.setPen(Qt.PenStyle.SolidLine)
r = QRect(0,
self.dummy.geometry().top() + 10,
self.geometry().width(), 150)
p.drawText(
r, Qt.AlignmentFlag.AlignHCenter | Qt.AlignmentFlag.AlignTop
| Qt.TextFlag.TextSingleLine, self.text)
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.RenderHint.Antialiasing
| QPainter.RenderHint.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 = int(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()
