def shadowTemplatePixmap(color, length):
"""
Returns 1 pixel wide, `length` pixels long linear-gradient.
Args:
color (QColor): shadow color
length (int): length of cast shadow
"""
key = "InnerShadowTemplate " + \
color.name() + " " + \
str(length)
# get cached template
shadowPixmap = QPixmapCache.find(key)
if shadowPixmap:
return shadowPixmap
shadowPixmap = QPixmap(1, length)
shadowPixmap.fill(Qt.transparent)
grad = QLinearGradient(0, 0, 0, length)
grad.setColorAt(0, color)
grad.setColorAt(1, Qt.transparent)
painter = QPainter()
painter.begin(shadowPixmap)
painter.fillRect(shadowPixmap.rect(), grad)
painter.end()
# cache template
QPixmapCache.insert(key, shadowPixmap)
return shadowPixmap
def pixmap(self, size, mode, state):
# type: (QSize, QIcon.Mode, QIcon.State) -> QPixmap
if not self.__generator.isValid():
return QPixmap()
dsize = self.__generator.defaultSize() # type: QSize
if not dsize.isNull():
dsize.scale(size, Qt.KeepAspectRatio)
size = dsize
key = "{}.SVGIconEngine/{}/{}x{}".format(__name__, self.__cache_id,
size.width(), size.height())
pm = QPixmapCache.find(key)
if pm is None or pm.isNull():
pm = QPixmap(size)
pm.fill(Qt.transparent)
painter = QPainter(pm)
try:
self.__generator.render(
painter, QRectF(0, 0, size.width(), size.height()))
finally:
painter.end()
QPixmapCache.insert(key, pm)
style = QApplication.style()
if style is not None:
opt = QStyleOption()
opt.palette = QApplication.palette()
pm = style.generatedIconPixmap(mode, pm, opt)
return pm
def pixmap(self, size, mode, state):
# type: (QSize, QIcon.Mode, QIcon.State) -> QPixmap
if not self.__generator.isValid():
return QPixmap()
dsize = self.__generator.defaultSize() # type: QSize
if not dsize.isNull():
dsize.scale(size, Qt.KeepAspectRatio)
size = dsize
key = "{}.SVGIconEngine/{}/{}x{}".format(
__name__, self.__cache_id, size.width(), size.height()
)
pm = QPixmapCache.find(key)
if pm is None or pm.isNull():
pm = QPixmap(size)
pm.fill(Qt.transparent)
painter = QPainter(pm)
try:
self.__generator.render(
painter, QRectF(0, 0, size.width(), size.height()))
finally:
painter.end()
QPixmapCache.insert(key, pm)
style = QApplication.style()
if style is not None:
opt = QStyleOption()
opt.palette = QApplication.palette()
pm = style.generatedIconPixmap(mode, pm, opt)
return pm
def innerShadowPixmap(color, size, pos, length=5):
"""
Args:
color (QColor): shadow color
size (QSize): size of pixmap
pos (int): shadow position int flag, use bitwise operations
1 - top
2 - right
4 - bottom
8 - left
length (int): length of cast shadow
"""
key = "InnerShadow " + \
color.name() + " " + \
str(size) + " " + \
str(pos) + " " + \
str(length)
# get cached shadow if it exists
finalShadow = QPixmapCache.find(key)
if finalShadow:
return finalShadow
shadowTemplate = shadowTemplatePixmap(color, length)
finalShadow = QPixmap(size)
finalShadow.fill(Qt.transparent)
shadowPainter = QPainter(finalShadow)
shadowPainter.setCompositionMode(QPainter.CompositionMode_Darken)
# top/bottom rect
targetRect = QRect(0, 0, size.width(), length)
# shadow on top
if pos & 1:
shadowPainter.drawPixmap(targetRect, shadowTemplate, shadowTemplate.rect())
# shadow on bottom
if pos & 4:
shadowPainter.save()
shadowPainter.translate(QPointF(0, size.height()))
shadowPainter.scale(1, -1)
shadowPainter.drawPixmap(targetRect, shadowTemplate, shadowTemplate.rect())
shadowPainter.restore()
# left/right rect
targetRect = QRect(0, 0, size.height(), shadowTemplate.rect().height())
# shadow on the right
if pos & 2:
shadowPainter.save()
shadowPainter.translate(QPointF(size.width(), 0))
shadowPainter.rotate(90)
shadowPainter.drawPixmap(targetRect, shadowTemplate, shadowTemplate.rect())
shadowPainter.restore()
# shadow on left
if pos & 8:
shadowPainter.save()
shadowPainter.translate(0, size.height())
shadowPainter.rotate(-90)
shadowPainter.drawPixmap(targetRect, shadowTemplate, shadowTemplate.rect())
shadowPainter.restore()
shadowPainter.end()
# cache shadow
QPixmapCache.insert(key, finalShadow)
return finalShadow
def innerGlowBackgroundPixmap(color, size, radius=5):
""" Draws radial gradient pixmap, then uses that to draw
a rounded-corner gradient rectangle pixmap.
Args:
color (QColor): used as outer color (lightness 245 used for inner)
size (QSize): size of output pixmap
radius (int): radius of inner glow rounded corners
"""
key = "InnerGlowBackground " + \
color.name() + " " + \
str(radius)
bg = QPixmapCache.find(key)
if bg:
return bg
# set background colors for gradient
color = color.toHsl()
light_color = color.fromHsl(color.hslHue(), color.hslSaturation(), 245)
dark_color = color
# initialize radial gradient
center = QPoint(radius, radius)
pixRect = QRect(0, 0, radius * 2, radius * 2)
gradientPixmap = QPixmap(radius * 2, radius * 2)
gradientPixmap.fill(dark_color)
# draw radial gradient pixmap
pixPainter = QPainter(gradientPixmap)
pixPainter.setPen(Qt.NoPen)
gradient = QRadialGradient(center, radius - 1)
gradient.setColorAt(0, light_color)
gradient.setColorAt(1, dark_color)
pixPainter.setBrush(gradient)
pixPainter.drawRect(pixRect)
pixPainter.end()
# set tl and br to the gradient's square-shaped rect
tl = QPoint(0, 0)
br = QPoint(size.width(), size.height())
# fragments of radial gradient pixmap to create rounded gradient outline rectangle
frags = [
# top-left corner
QPainter.PixmapFragment.create(
QPointF(tl.x() + radius / 2, tl.y() + radius / 2),
QRectF(0, 0, radius, radius)
),
# top-mid 'linear gradient'
QPainter.PixmapFragment.create(
QPointF(tl.x() + (br.x() - tl.x()) / 2, tl.y() + radius / 2),
QRectF(radius, 0, 1, radius),
scaleX=(br.x() - tl.x() - 2 * radius)
),
# top-right corner
QPainter.PixmapFragment.create(
QPointF(br.x() - radius / 2, tl.y() + radius / 2),
QRectF(radius, 0, radius, radius)
),
# left-mid 'linear gradient'
QPainter.PixmapFragment.create(
QPointF(tl.x() + radius / 2, tl.y() + (br.y() - tl.y()) / 2),
QRectF(0, radius, radius, 1),
scaleY=(br.y() - tl.y() - 2 * radius)
),
# mid solid
QPainter.PixmapFragment.create(
QPointF(tl.x() + (br.x() - tl.x()) / 2, tl.y() + (br.y() - tl.y()) / 2),
QRectF(radius, radius, 1, 1),
scaleX=(br.x() - tl.x() - 2 * radius),
scaleY=(br.y() - tl.y() - 2 * radius)
),
# right-mid 'linear gradient'
QPainter.PixmapFragment.create(
QPointF(br.x() - radius / 2, tl.y() + (br.y() - tl.y()) / 2),
QRectF(radius, radius, radius, 1),
scaleY=(br.y() - tl.y() - 2 * radius)
),
# bottom-left corner
QPainter.PixmapFragment.create(
QPointF(tl.x() + radius / 2, br.y() - radius / 2),
QRectF(0, radius, radius, radius)
),
# bottom-mid 'linear gradient'
QPainter.PixmapFragment.create(
QPointF(tl.x() + (br.x() - tl.x()) / 2, br.y() - radius / 2),
QRectF(radius, radius, 1, radius),
scaleX=(br.x() - tl.x() - 2 * radius)
),
# bottom-right corner
QPainter.PixmapFragment.create(
QPointF(br.x() - radius / 2, br.y() - radius / 2),
QRectF(radius, radius, radius, radius)
),
]
# draw icon background to pixmap
outPix = QPixmap(size.width(), size.height())
outPainter = QPainter(outPix)
outPainter.setPen(Qt.NoPen)
outPainter.drawPixmapFragments(frags,
gradientPixmap,
QPainter.PixmapFragmentHints(QPainter.OpaqueHint))
outPainter.end()
QPixmapCache.insert(key, outPix)
return outPix
