def paint(self, painter: QPainter, *_):
painter.save()
painter.setPen(pg.mkPen((255, 255, 100), width=1))
painter.setBrush(pg.mkBrush(255, 255, 0, 100))
if self.__selection_range is not None:
painter.drawRect(self.selection_rect)
painter.restore()
def paintEvent(self, event):
opt = QStyleOption()
opt.initFrom(self)
if not self.__popupicon.isVisible():
return
if not (opt.state & QStyle.State_MouseOver
or opt.state & QStyle.State_HasFocus):
return
palette = opt.palette # type: QPalette
if opt.state & QStyle.State_HasFocus:
pen = QPen(palette.color(QPalette.Highlight))
else:
pen = QPen(palette.color(QPalette.Dark))
if (self.__fulltext and opt.state & QStyle.State_MouseOver
and opt.state & QStyle.State_Active):
g = QLinearGradient()
g.setCoordinateMode(QLinearGradient.ObjectBoundingMode)
base = palette.color(QPalette.Window)
base.setAlpha(90)
g.setColorAt(0, base.lighter(200))
g.setColorAt(0.6, base)
g.setColorAt(1.0, base.lighter(200))
brush = QBrush(g)
else:
brush = QBrush(Qt.NoBrush)
p = QPainter(self)
p.setBrush(brush)
p.setPen(pen)
p.drawRect(opt.rect.adjusted(0, 0, -1, -1))
def paintEvent(self, event):
opt = QStyleOption()
opt.initFrom(self)
if not self.__popupicon.isVisible():
return
if not (opt.state & QStyle.State_MouseOver or
opt.state & QStyle.State_HasFocus):
return
palette = opt.palette # type: QPalette
if opt.state & QStyle.State_HasFocus:
pen = QPen(palette.color(QPalette.Highlight))
else:
pen = QPen(palette.color(QPalette.Dark))
if self.__fulltext and \
opt.state & QStyle.State_MouseOver and \
opt.state & QStyle.State_Active:
g = QLinearGradient()
g.setCoordinateMode(QLinearGradient.ObjectBoundingMode)
base = palette.color(QPalette.Window)
base.setAlpha(90)
g.setColorAt(0, base.lighter(200))
g.setColorAt(0.6, base)
g.setColorAt(1.0, base.lighter(200))
brush = QBrush(g)
else:
brush = QBrush(Qt.NoBrush)
p = QPainter(self)
p.setBrush(brush)
p.setPen(pen)
p.drawRect(opt.rect.adjusted(0, 0, -1, -1))
def paint(self, painter: QPainter, option, widget):
painter.setBrush(self.COLOR)
painter.setPen(self.COLOR)
painter.drawRect(self.boundingRect().adjusted(-self.PADDING,
-self.PADDING,
self.PADDING,
self.PADDING))
super().paint(painter, option, widget)
def paintEvent(self, e):
# call the base implementation to paint normal interface
super(GaugeWidgetVertical, self).paintEvent(e)
draw = QPainter()
draw.begin(self)
window_with = self.width() - 1
diff = (self._higher - self._lower) * self.scale
try:
self._step = float(self.height()) / float(diff)
except ZeroDivisionError:
self._step = 0
y_start = self.height() - (self._minVal -
self._lower) * self._step * self.scale
y_end = self.height() - (self._maxVal -
self._lower) * self._step * self.scale
draw.setOpacity(1.0)
draw.setBrush(QtCore.Qt.NoBrush)
draw.setPen(QColor(200, 200, 255))
b = int(self.height() / 5)
e = int(self.height() - (self.height() / 5) + 1)
s = int(self.height() / 5)
for i in range(b, e, s):
draw.drawLine(0, i, window_with, i)
draw.setBrush(QColor(33, 133, 208))
draw.setPen(QColor(33, 133, 208))
draw.setOpacity(0.7)
draw.drawRect(0, y_start, window_with, y_end - y_start)
draw.setFont(QFont('Decorative', 8))
draw.setPen(QColor(30, 30, 30))
draw.drawText(
3,
self.height() - 3,
str(self._lower) if self._use_float else str(
int(round(self._lower))))
draw.drawText(
3, 10,
str(self._higher) if self._use_float else str(
int(round(self._higher))))
draw.drawText(
3, y_start + 11,
str(self._minVal) if self._use_float else str(
int(round(self._minVal))))
draw.drawText(
3, y_end - 4,
str(self._maxVal) if self._use_float else str(
int(round(self._maxVal))))
draw.end()
def palette_pixmap(colors, size):
img = QPixmap(size)
img.fill(Qt.transparent)
painter = QPainter(img)
grad = palette_gradient(colors)
grad.setCoordinateMode(QLinearGradient.ObjectBoundingMode)
painter.setPen(Qt.NoPen)
painter.setBrush(QBrush(grad))
painter.drawRect(0, 0, size.width(), size.height())
painter.end()
return img
def __init__(self, parent=None):
super().__init__(parent, Qt.CustomizeWindowHint | Qt.FramelessWindowHint | Qt.Window |
Qt.WindowStaysOnTopHint | Qt.X11BypassWindowManagerHint)
self.setAttribute(Qt.WA_DeleteOnClose)
self.installEventFilter(self)
self.setMouseTracking(True)
self._band = QRubberBand(QRubberBand.Rectangle, self)
self._resize_origin = None
self._drag_mask = 0
self._origin = None
self.selected_image = None
# Window background
desktop = QApplication.desktop()
if is_qt5():
g = desktop.geometry()
self._snapshot = QPixmap(g.width(), g.height())
painter = QPainter(self._snapshot)
for screen in QApplication.screens():
g = screen.geometry()
painter.drawPixmap(g, screen.grabWindow(0, g.x(), g.y(), g.width(), g.height()))
painter.end()
else:
self._snapshot = QPixmap.grabWindow(desktop.winId(), 0, 0, desktop.width(), desktop.height())
self.setGeometry(desktop.geometry())
self._darken = self._snapshot.copy()
painter = QPainter(self._darken)
brush = QBrush(QColor(0, 0, 0, 128))
painter.setBrush(brush)
painter.drawRect(self._darken.rect())
painter.end()
# Buttons
self._buttons = QWidget(self)
self._button_layout = QHBoxLayout(self._buttons)
self._button_layout.setSpacing(0)
self._button_layout.setContentsMargins(0, 0, 0, 0)
self._button_layout.setContentsMargins(0, 0, 0, 0)
self.save_as = QPushButton(self.tr('Save As'))
self.save_as.pressed.connect(self.save_image_as)
self.save_as.setCursor(Qt.ArrowCursor)
self._button_layout.addWidget(self.save_as)
self.copy = QPushButton(self.tr('Copy'))
self.copy.pressed.connect(self.copy_to_clipboard)
self.copy.setCursor(Qt.ArrowCursor)
self._button_layout.addWidget(self.copy)
self.share = QPushButton(self.tr('Share'))
self.share.pressed.connect(self.share_selection)
self.share.setCursor(Qt.ArrowCursor)
self._button_layout.addWidget(self.share)
self._buttons.hide()
def palette_pixmap(colors, size):
img = QPixmap(size)
img.fill(Qt.transparent)
painter = QPainter(img)
grad = palette_gradient(colors)
grad.setCoordinateMode(QLinearGradient.ObjectBoundingMode)
painter.setPen(Qt.NoPen)
painter.setBrush(QBrush(grad))
painter.drawRect(0, 0, size.width(), size.height())
painter.end()
return img
def createDiscPalettePixmap(width, height, palette):
p = QPainter()
img = QPixmap(width, height)
p.begin(img)
p.setPen(QPen(Qt.NoPen))
if type(palette) == dict: # if palette is the dict with different
palette = palette[max(palette.keys())]
if len(palette) == 0: return img
rectWidth = width / float(len(palette))
for i, col in enumerate(palette):
p.setBrush(QBrush(QColor(*col)))
p.drawRect(QRectF(i * rectWidth, 0, (i + 1) * rectWidth, height))
return img
def createDiscPalettePixmap(width, height, palette):
p = QPainter()
img = QPixmap(width, height)
p.begin(img)
p.setPen(QPen(Qt.NoPen))
if type(palette) == dict: # if palette is the dict with different
palette = palette[max(palette.keys())]
if len(palette) == 0: return img
rectWidth = width / float(len(palette))
for i, col in enumerate(palette):
p.setBrush(QBrush(QColor(*col)))
p.drawRect(QRectF(i * rectWidth, 0, (i + 1) * rectWidth, height))
return img
def grab_svg(scene):
# type: (QGraphicsScene) -> str
"""
Return a SVG rendering of the scene contents.
Parameters
----------
scene : :class:`CanvasScene`
"""
svg_buffer = QBuffer()
gen = _QSvgGenerator()
gen.setOutputDevice(svg_buffer)
items_rect = scene.itemsBoundingRect().adjusted(-10, -10, 10, 10)
if items_rect.isNull():
items_rect = QRectF(0, 0, 10, 10)
width, height = items_rect.width(), items_rect.height()
rect_ratio = float(width) / height
# Keep a fixed aspect ratio.
aspect_ratio = 1.618
if rect_ratio > aspect_ratio:
height = int(height * rect_ratio / aspect_ratio)
else:
width = int(width * aspect_ratio / rect_ratio)
target_rect = QRectF(0, 0, width, height)
source_rect = QRectF(0, 0, width, height)
source_rect.moveCenter(items_rect.center())
gen.setSize(target_rect.size().toSize())
gen.setViewBox(target_rect)
painter = QPainter(gen)
# Draw background.
painter.setPen(Qt.NoPen)
painter.setBrush(scene.palette().base())
painter.drawRect(target_rect)
# Render the scene
scene.render(painter, target_rect, source_rect)
painter.end()
buffer_str = bytes(svg_buffer.buffer())
return buffer_str.decode("utf-8")
def grab_svg(scene):
"""
Return a SVG rendering of the scene contents.
Parameters
----------
scene : :class:`CanvasScene`
"""
from AnyQt.QtSvg import QSvgGenerator
svg_buffer = QBuffer()
gen = QSvgGenerator()
gen.setOutputDevice(svg_buffer)
items_rect = scene.itemsBoundingRect().adjusted(-10, -10, 10, 10)
if items_rect.isNull():
items_rect = QRectF(0, 0, 10, 10)
width, height = items_rect.width(), items_rect.height()
rect_ratio = float(width) / height
# Keep a fixed aspect ratio.
aspect_ratio = 1.618
if rect_ratio > aspect_ratio:
height = int(height * rect_ratio / aspect_ratio)
else:
width = int(width * aspect_ratio / rect_ratio)
target_rect = QRectF(0, 0, width, height)
source_rect = QRectF(0, 0, width, height)
source_rect.moveCenter(items_rect.center())
gen.setSize(target_rect.size().toSize())
gen.setViewBox(target_rect)
painter = QPainter(gen)
# Draw background.
painter.setBrush(QBrush(Qt.white))
painter.drawRect(target_rect)
# Render the scene
scene.render(painter, target_rect, source_rect)
painter.end()
buffer_str = bytes(svg_buffer.buffer())
return buffer_str.decode("utf-8")
def __paint(self):
picture = QPicture()
painter = QPainter(picture)
pen = QPen(QBrush(Qt.white), 0.5)
pen.setCosmetic(True)
painter.setPen(pen)
geom = self.geometry
x, y = geom.x(), geom.y()
w, h = geom.width(), geom.height()
wsingle = w / len(self.dist)
for d, c in zip(self.dist, self.colors):
painter.setBrush(QBrush(c))
painter.drawRect(QRectF(x, y, wsingle, d * h))
x += wsingle
painter.end()
self.__picture = picture
def __paint(self):
picture = QPicture()
painter = QPainter(picture)
pen = QPen(QBrush(Qt.white), 0.5)
pen.setCosmetic(True)
painter.setPen(pen)
geom = self.geometry
x, y = geom.x(), geom.y()
w, h = geom.width(), geom.height()
wsingle = w / len(self.dist)
for d, c in zip(self.dist, self.colors):
painter.setBrush(QBrush(c))
painter.drawRect(QRectF(x, y, wsingle, d * h))
x += wsingle
painter.end()
self.__picture = picture
def picture_this_level():
# Create a QPicture drawing the contribution from this
# level only. This is all regions where the contingency is
# not empty and does not have a computed sub-contingency
# (i.e. the node does not have a child in that cell).
pic = QPicture()
painter = QPainter(pic)
ctng = node.contingencies
colors = create_image(ctng, palette, scale=scale)
x, y, w, h = node.brect
N, M = ctng.shape[:2]
# Nonzero contingency mask
any_mask = Node_mask(node)
if node.is_leaf:
skip = itertools.repeat(False)
else:
# Skip all None children they were already painted.
skip = (ch is not None for ch in node.children.flat)
painter.save()
painter.translate(x, y)
painter.scale(w / node.nbins, h / node.nbins)
indices = itertools.product(range(N), range(M))
for (i, j), skip, any_ in zip(indices, skip, any_mask.flat):
if not skip and any_:
painter.setBrush(QColor(*colors[i, j]))
if shape == Rect:
painter.drawRect(i, j, 1, 1)
elif shape == Circle:
painter.drawEllipse(i, j, 1, 1)
elif shape == RoundRect:
painter.drawRoundedRect(i, j, 1, 1, 25.0, 25.0,
Qt.RelativeSize)
painter.restore()
painter.end()
return pic
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
def paint(self, painter: QPainter, *_):
painter.save()
painter.setPen(pg.mkPen((255, 255, 0), width=1))
painter.setBrush(pg.mkBrush(255, 255, 0, 100))
painter.drawRect(self.__rect)
painter.restore()
def __paintEventNoStyle(self):
p = QPainter(self)
opt = QStyleOptionToolButton()
self.initStyleOption(opt)
fm = QFontMetrics(opt.font)
palette = opt.palette
# highlight brush is used as the background for the icon and background
# when the tab is expanded and as mouse hover color (lighter).
brush_highlight = palette.highlight()
foregroundrole = QPalette.ButtonText
if opt.state & QStyle.State_Sunken:
# State 'down' pressed during a mouse press (slightly darker).
background_brush = brush_darker(brush_highlight, 110)
foregroundrole = QPalette.HighlightedText
elif opt.state & QStyle.State_MouseOver:
background_brush = brush_darker(brush_highlight, 95)
foregroundrole = QPalette.HighlightedText
elif opt.state & QStyle.State_On:
background_brush = brush_highlight
foregroundrole = QPalette.HighlightedText
else:
# The default button brush.
background_brush = palette.button()
rect = opt.rect
icon_area_rect = QRect(rect)
icon_area_rect.setRight(int(icon_area_rect.height() * 1.26))
text_rect = QRect(rect)
text_rect.setLeft(icon_area_rect.right() + 10)
# Background (TODO: Should the tab button have native
# toolbutton shape, drawn using PE_PanelButtonTool or even
# QToolBox tab shape)
# Default outline pen
pen = QPen(palette.color(QPalette.Mid))
p.save()
p.setPen(Qt.NoPen)
p.setBrush(QBrush(background_brush))
p.drawRect(rect)
# Draw the background behind the icon if the background_brush
# is different.
if not opt.state & QStyle.State_On:
p.setBrush(brush_highlight)
p.drawRect(icon_area_rect)
# Line between the icon and text
p.setPen(pen)
p.drawLine(icon_area_rect.topRight(),
icon_area_rect.bottomRight())
if opt.state & QStyle.State_HasFocus:
# Set the focus frame pen and draw the border
pen = QPen(QColor(FOCUS_OUTLINE_COLOR))
p.setPen(pen)
p.setBrush(Qt.NoBrush)
# Adjust for pen
rect = rect.adjusted(0, 0, -1, -1)
p.drawRect(rect)
else:
p.setPen(pen)
# Draw the top/bottom border
if self.position == QStyleOptionToolBox.OnlyOneTab or \
self.position == QStyleOptionToolBox.Beginning or \
self.selected & \
QStyleOptionToolBox.PreviousIsSelected:
p.drawLine(rect.topLeft(), rect.topRight())
p.drawLine(rect.bottomLeft(), rect.bottomRight())
p.restore()
p.save()
text = fm.elidedText(opt.text, Qt.ElideRight, text_rect.width())
p.setPen(QPen(palette.color(foregroundrole)))
p.setFont(opt.font)
p.drawText(text_rect,
int(Qt.AlignVCenter | Qt.AlignLeft) | \
int(Qt.TextSingleLine),
text)
if not opt.icon.isNull():
if opt.state & QStyle.State_Enabled:
mode = QIcon.Normal
else:
mode = QIcon.Disabled
if opt.state & QStyle.State_On:
state = QIcon.On
else:
state = QIcon.Off
icon_area_rect = icon_area_rect
icon_rect = QRect(QPoint(0, 0), opt.iconSize)
icon_rect.moveCenter(icon_area_rect.center())
opt.icon.paint(p, icon_rect, Qt.AlignCenter, mode, state)
p.restore()
def __paintEventNoStyle(self):
p = QPainter(self)
opt = QStyleOptionToolButton()
self.initStyleOption(opt)
fm = QFontMetrics(opt.font)
palette = opt.palette
# highlight brush is used as the background for the icon and background
# when the tab is expanded and as mouse hover color (lighter).
brush_highlight = palette.highlight()
if opt.state & QStyle.State_Sunken:
# State 'down' pressed during a mouse press (slightly darker).
background_brush = brush_darker(brush_highlight, 110)
elif opt.state & QStyle.State_MouseOver:
background_brush = brush_darker(brush_highlight, 95)
elif opt.state & QStyle.State_On:
background_brush = brush_highlight
else:
# The default button brush.
background_brush = palette.button()
rect = opt.rect
icon_area_rect = QRect(rect)
icon_area_rect.setRight(int(icon_area_rect.height() * 1.26))
text_rect = QRect(rect)
text_rect.setLeft(icon_area_rect.right() + 10)
# Background (TODO: Should the tab button have native
# toolbutton shape, drawn using PE_PanelButtonTool or even
# QToolBox tab shape)
# Default outline pen
pen = QPen(palette.color(QPalette.Mid))
p.save()
p.setPen(Qt.NoPen)
p.setBrush(QBrush(background_brush))
p.drawRect(rect)
# Draw the background behind the icon if the background_brush
# is different.
if not opt.state & QStyle.State_On:
p.setBrush(brush_highlight)
p.drawRect(icon_area_rect)
# Line between the icon and text
p.setPen(pen)
p.drawLine(icon_area_rect.topRight(),
icon_area_rect.bottomRight())
if opt.state & QStyle.State_HasFocus:
# Set the focus frame pen and draw the border
pen = QPen(QColor(FOCUS_OUTLINE_COLOR))
p.setPen(pen)
p.setBrush(Qt.NoBrush)
# Adjust for pen
rect = rect.adjusted(0, 0, -1, -1)
p.drawRect(rect)
else:
p.setPen(pen)
# Draw the top/bottom border
if self.position == QStyleOptionToolBox.OnlyOneTab or \
self.position == QStyleOptionToolBox.Beginning or \
self.selected & \
QStyleOptionToolBox.PreviousIsSelected:
p.drawLine(rect.topLeft(), rect.topRight())
p.drawLine(rect.bottomLeft(), rect.bottomRight())
p.restore()
p.save()
text = fm.elidedText(opt.text, Qt.ElideRight, text_rect.width())
p.setPen(QPen(palette.color(QPalette.ButtonText)))
p.setFont(opt.font)
p.drawText(text_rect,
int(Qt.AlignVCenter | Qt.AlignLeft) | \
int(Qt.TextSingleLine),
text)
if not opt.icon.isNull():
if opt.state & QStyle.State_Enabled:
mode = QIcon.Normal
else:
mode = QIcon.Disabled
if opt.state & QStyle.State_On:
state = QIcon.On
else:
state = QIcon.Off
icon_area_rect = icon_area_rect
icon_rect = QRect(QPoint(0, 0), opt.iconSize)
icon_rect.moveCenter(icon_area_rect.center())
opt.icon.paint(p, icon_rect, Qt.AlignCenter, mode, state)
p.restore()
