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 render_as_png(self, filename):
png = self.__transparent_png()
painter = QPainter(png)
painter.setRenderHint(QPainter.Antialiasing, 1)
self.scene.render(painter, QRectF(0, 0, 50, 50), QRectF(-25, -25, 50, 50))
painter.end()
png.save(filename)
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 splash_screen():
"""
"""
pm = QPixmap(
pkg_resources.resource_filename(__name__,
"icons/orange-splash-screen.png"))
version = QCoreApplication.applicationVersion()
size = 21 if len(version) < 5 else 16
font = QFont("Helvetica")
font.setPixelSize(size)
font.setBold(True)
font.setItalic(True)
font.setLetterSpacing(QFont.AbsoluteSpacing, 2)
metrics = QFontMetrics(font)
br = metrics.boundingRect(version).adjusted(-5, 0, 5, 0)
br.moveCenter(QPoint(436, 224))
p = QPainter(pm)
p.setRenderHint(QPainter.Antialiasing)
p.setRenderHint(QPainter.TextAntialiasing)
p.setFont(font)
p.setPen(QColor("#231F20"))
p.drawText(br, Qt.AlignCenter, version)
p.end()
return pm, QRect(88, 193, 200, 20)
def test(self):
img = QImage(100, 100, QImage.Format_ARGB32)
img.fill(Qt.green)
p = QPainter(img)
pix = QPixmap(10, 10)
pix.fill(Qt.red)
frgmts = [
QPainter.PixmapFragment.create(
QPointF(25, 25),
QRectF(0, 0, 10, 10),
5., 5.,
),
QPainter.PixmapFragment.create(
QPointF(75, 75),
QRectF(0, 0, 10, 10),
5., 5.,
)
]
p.drawPixmapFragments(frgmts, pix)
p.end()
self.assertEqual(QColor(img.pixel(10, 10)), QColor(Qt.red))
self.assertEqual(QColor(img.pixel(80, 80)), QColor(Qt.red))
self.assertEqual(QColor(img.pixel(90, 10)), QColor(Qt.green))
self.assertEqual(QColor(img.pixel(10, 90)), QColor(Qt.green))
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 decorate_welcome_icon(icon, background_color):
"""Return a `QIcon` with a circle shaped background.
"""
welcome_icon = QIcon()
sizes = [32, 48, 64, 80, 128, 256]
background_color = NAMED_COLORS.get(background_color, background_color)
background_color = QColor(background_color)
grad = radial_gradient(background_color)
for size in sizes:
icon_size = QSize(5 * size / 8, 5 * size / 8)
icon_rect = QRect(QPoint(0, 0), icon_size)
pixmap = QPixmap(size, size)
pixmap.fill(Qt.transparent)
p = QPainter(pixmap)
p.setRenderHint(QPainter.Antialiasing, True)
p.setBrush(QBrush(grad))
p.setPen(Qt.NoPen)
ellipse_rect = QRect(0, 0, size, size)
p.drawEllipse(ellipse_rect)
icon_rect.moveCenter(ellipse_rect.center())
icon.paint(p, icon_rect, Qt.AlignCenter, )
p.end()
welcome_icon.addPixmap(pixmap)
return welcome_icon
def decorate_welcome_icon(icon, background_color):
"""Return a `QIcon` with a circle shaped background.
"""
welcome_icon = QIcon()
sizes = [32, 48, 64, 80]
background_color = NAMED_COLORS.get(background_color, background_color)
background_color = QColor(background_color)
grad = radial_gradient(background_color)
for size in sizes:
icon_pixmap = icon.pixmap(5 * size / 8, 5 * size / 8)
icon_size = icon_pixmap.size()
icon_rect = QRect(QPoint(0, 0), icon_size)
pixmap = QPixmap(size, size)
pixmap.fill(QColor(0, 0, 0, 0))
p = QPainter(pixmap)
p.setRenderHint(QPainter.Antialiasing, True)
p.setBrush(QBrush(grad))
p.setPen(Qt.NoPen)
ellipse_rect = QRect(0, 0, size, size)
p.drawEllipse(ellipse_rect)
icon_rect.moveCenter(ellipse_rect.center())
p.drawPixmap(icon_rect.topLeft(), icon_pixmap)
p.end()
welcome_icon.addPixmap(pixmap)
return welcome_icon
def paintEvent(self, event):
# type: (QPaintEvent) -> None
# TODO: Use QPainter.drawPixmapFragments on Qt 4.7
if self.__widget is None:
return
opt = QStyleOption()
opt.initFrom(self)
radius = self.__radius
offset = self.__offset
pixmap = self.__shadowPixmap()
pixr = pixmap.devicePixelRatio()
assert pixr == self.devicePixelRatioF()
shadow_rect = QRectF(opt.rect)
widget_rect = QRectF(self.__widget.geometry())
widget_rect.moveTo(radius - offset.x(), radius - offset.y())
left = top = right = bottom = radius * pixr
pixmap_rect = QRectF(QPointF(0, 0), QSizeF(pixmap.size()))
# Shadow casting rectangle in the source pixmap.
pixmap_shadow_rect = pixmap_rect.adjusted(left, top, -right, -bottom)
pixmap_shadow_rect.translate(-offset.x() * pixr, -offset.y() * pixr)
source_rects = self.__shadowPixmapFragments(pixmap_rect,
pixmap_shadow_rect)
target_rects = self.__shadowPixmapFragments(shadow_rect, widget_rect)
painter = QPainter(self)
for source, target in zip(source_rects, target_rects):
painter.drawPixmap(target, pixmap, source)
painter.end()
def decorate_welcome_icon(icon, background_color):
# type: (QIcon, Union[QColor, str]) -> QIcon
"""Return a `QIcon` with a circle shaped background.
"""
welcome_icon = QIcon()
sizes = [32, 48, 64, 80, 128, 256]
background_color = NAMED_COLORS.get(background_color, background_color)
background_color = QColor(background_color)
grad = radial_gradient(background_color)
for size in sizes:
icon_size = QSize(int(5 * size / 8), int(5 * size / 8))
icon_rect = QRect(QPoint(0, 0), icon_size)
pixmap = QPixmap(size, size)
pixmap.fill(Qt.transparent)
p = QPainter(pixmap)
p.setRenderHint(QPainter.Antialiasing, True)
p.setBrush(QBrush(grad))
p.setPen(Qt.NoPen)
ellipse_rect = QRect(0, 0, size, size)
p.drawEllipse(ellipse_rect)
icon_rect.moveCenter(ellipse_rect.center())
icon.paint(
p,
icon_rect,
Qt.AlignCenter,
)
p.end()
welcome_icon.addPixmap(pixmap)
return welcome_icon
def paintEvent(self, QPaintEvent):
import math
if self.direction == 'x':
_angle = self.parent.rotationX
_x1 = self.width() / 2
_y1 = self.height() / 2
_x2 = math.cos(math.radians(_angle)) * (self.width() / 2)
_y2 = math.sin(math.radians(_angle)) * (self.width() / 2)
elif self.direction == 'y':
_angle = self.parent.rotationY
_x1 = self.width() / 2
_y1 = self.height() / 2
_x2 = math.cos(math.radians(_angle + 90)) * (self.height() / 2)
_y2 = math.sin(math.radians(_angle + 90)) * (self.height() / 2)
else:
_angle = 0
_x1 = 0
_y1 = 0
_x2 = 0
_y2 = 0
_painter = QPainter(self)
_pm = QPixmap(self.width(), self.height())
_pm_compass = QPixmap(self.compassImage).transformed(QTransform().rotate(self.compassRotation))
_pm_image = QPixmap(self.image).transformed(QTransform().rotate(_angle))
_painter.drawPixmap(0, 0, _pm_compass)
_painter.setPen(QColor(255, 160, 47))
_painter.drawLine(_x1, _y1, _x2, _y2)
_x = (self.width() - _pm_image.width()) / 2
_y = (self.height() - _pm_image.height()) / 2
_painter.drawPixmap(_x, _y, _pm_image)
_painter.end()
def splash_screen():
splash_n = random.randint(1, 3)
path = pkg_resources.resource_filename(
__name__, f"icons/orange-splash-screen-{splash_n:02}.png")
pm = QPixmap(path)
version = Config.ApplicationVersion
if version:
version_parsed = LooseVersion(version)
version_comp = version_parsed.version
version = ".".join(map(str, version_comp[:2]))
size = 13
font = QFont("Helvetica")
font.setPixelSize(size)
metrics = QFontMetrics(font)
br = metrics.boundingRect(version)
br.moveTopLeft(QPoint(171, 438))
p = QPainter(pm)
p.setRenderHint(QPainter.Antialiasing)
p.setRenderHint(QPainter.TextAntialiasing)
p.setFont(font)
p.setPen(QColor("#000000"))
p.drawText(br, Qt.AlignLeft, version)
p.end()
return pm, QRect(23, 24, 200, 20)
def splash_screen():
"""
"""
pm = QPixmap(
pkg_resources.resource_filename(
__name__, "icons/orange-splash-screen.png")
)
version = QCoreApplication.applicationVersion()
size = 21 if len(version) < 5 else 16
font = QFont("Helvetica")
font.setPixelSize(size)
font.setBold(True)
font.setItalic(True)
font.setLetterSpacing(QFont.AbsoluteSpacing, 2)
metrics = QFontMetrics(font)
br = metrics.boundingRect(version).adjusted(-5, 0, 5, 0)
br.moveCenter(QPoint(436, 224))
p = QPainter(pm)
p.setRenderHint(QPainter.Antialiasing)
p.setRenderHint(QPainter.TextAntialiasing)
p.setFont(font)
p.setPen(QColor("#231F20"))
p.drawText(br, Qt.AlignCenter, version)
p.end()
return pm, QRect(88, 193, 200, 20)
def export(self, filename=None):
pw = QPdfWriter(filename)
dpi = int(QApplication.primaryScreen().logicalDotsPerInch())
pw.setResolution(dpi)
pw.setPageMargins(QMarginsF(0, 0, 0, 0))
pw.setPageSize(
QPageSize(
QSizeF(self.getTargetRect().size()) / dpi * 25.4,
QPageSize.Millimeter))
painter = QPainter(pw)
try:
self.setExportMode(
True, {
'antialias': True,
'background': self.background,
'painter': painter
})
painter.setRenderHint(QPainter.Antialiasing, True)
if QtCore.QT_VERSION >= 0x050D00:
painter.setRenderHint(QPainter.LosslessImageRendering, True)
self.getScene().render(painter, QRectF(self.getTargetRect()),
QRectF(self.getSourceRect()))
finally:
self.setExportMode(False)
painter.end()
def render_as_png(self, filename):
img = QImage(50, 50, QImage.Format_ARGB32)
img.fill(Qt.transparent)
painter = QPainter(img)
painter.setRenderHint(QPainter.Antialiasing, 1)
self.scene.render(painter, QRectF(0, 0, 50, 50),
QRectF(-25, -25, 50, 50))
painter.end()
img.save(filename)
def picture_children():
# Return a QPicture displaying all children patches of this
# node.
pic = QPicture()
painter = QPainter(pic)
for ch in child_patches():
painter.drawPicture(0, 0, ch.picture())
painter.end()
return pic
def paintEvent(self, e):
"""
:param e:
:return:
"""
self._is_painting = True
super(EventsWidget, self).paintEvent(e)
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.setFont(QFont('Decorative', 8))
slider_pos = self._scroll.sliderPosition()
start = slider_pos * self._scale
end = start + self.width() * self._scale
for i, track in enumerate(self._tracks):
if self._break_draw:
break
track.draw_events(painter,
start,
end,
track_index=i,
left_shift=-self._scroll.sliderPosition(),
scale=self._scale)
# Draw only from pixel start to end
painter.setPen(QtCore.Qt.DashLine)
painter.setOpacity(0.3)
# print('Draw', start, end, self._scale, self._scroll.sliderPosition(), self.width())
# Draw vertical lines
for x in range(start - (start % (100 * self._scale)), end,
100 * self._scale):
x2draw = (x - slider_pos * self._scale) // self._scale
painter.drawLine(x2draw, 20, x2draw, self.height())
string = str(x)
boundtext = painter.boundingRect(QtCore.QRectF(), string)
painter.drawText(x2draw - boundtext.width() / 2, 15, string)
for index, track in enumerate(self._tracks):
top = self.which_top(index)
# print(top)
painter.drawLine(0, top, self.width(), top)
painter.drawText(10, top + 15, track.title)
painter.setOpacity(1.0)
self._pointer.draw(painter, left_shift=-slider_pos,
scale=self._scale) # Draw the time pointer
painter.end()
self._break_draw = False
self._is_painting = False
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 paint_with_data(data):
model.setItemData(index, data)
opt = self.view.viewOptions()
opt.rect = QRect(QPoint(0, 0), delegate.sizeHint(opt, index))
delegate.initStyleOption(opt, index)
img = QImage(opt.rect.size(), QImage.Format_ARGB32_Premultiplied)
p = QPainter(img)
try:
delegate.paint(p, opt, index)
finally:
p.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 paintEvent(self, event):
"""
Paint event
:param event:
"""
super(TimelineWidget, self).paintEvent(event)
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.setFont(QFont('Decorative', 8))
# find the start and end X coordinate to draw
start = self.scrollbar.sliderPosition()
end = start + self.parent().width() + 50
# Draw graphs ##########################################################
if len(self._graphs) > 0:
painter.setPen(QtCore.Qt.black)
middle = self.height() // 2
painter.setOpacity(0.1)
painter.drawLine(start, middle, end, middle)
for chart in self._graphs:
chart.draw(painter, start, end, 0, self.height())
# End draw graph #######################################################
for track in self.tracks:
track.draw_title(painter, start, end)
self.__draw_track_lines(painter, start, end)
if self._selected_track is not None:
self._selected_track.draw_background(painter, start, end)
for track in self.tracks:
track.draw_events(painter, start, end)
# Draw the selected element
if self._selected != None:
painter.setBrush(QColor(255, 0, 0))
self._selected.draw(painter, showvalues=True)
# Draw the time pointer
self._pointer.draw(painter, highlight=self._creating_event)
painter.end()
if not hasattr(self, '_is_refreshing'):
self._is_refreshing = True
self.update()
else:
del self._is_refreshing
def paintEvent(self, e):
# call the base implementation to paint normal interface
QWidget.paintEvent(self, e);
draw = QPainter();
draw.begin(self)
h = self.height() - 1
diff = (self._higher - self._lower) * self.scale
try:
self._step = float(self.width()) / float(diff)
except ZeroDivisionError:
self._step = 0
x_start = (self._minVal - self._lower) * self._step * self.scale
x_end = (self._maxVal - self._lower) * self._step * self.scale
draw.setOpacity(1.0)
draw.setBrush(QtCore.Qt.NoBrush)
draw.setPen(QColor(200, 200, 255))
for i in range( int(self.width()/5), int(self.width()-self.width()/5) + 1, int(self.width()/5) ):
draw.drawLine(i, 0, i, h)
draw.setBrush(QColor(238, 238, 238))
draw.setPen(QColor(238, 238, 238))
draw.drawRoundedRect(0, 2, self.width(), h - 4, 3, 3)
draw.setBrush(QColor(33, 133, 208))
draw.setPen(QColor(33, 133, 208))
draw.drawRoundedRect(int(round(x_start)), 2, int(round(x_end - x_start)), h - 4, 3, 3)
# draw.setOpacity(1.0)
draw.setFont(QFont('Decorative', 8))
draw.setPen(QColor(80, 80, 80))
str(self._maxVal) if self._use_float else str(int(round(self._maxVal)))
boundtext = draw.boundingRect(QtCore.QRectF(),
str(self._higher) if self._use_float else str(int(round(self._higher))))
draw.drawText(self.width() - boundtext.width(), 14,
str(self._higher) if self._use_float else str(int(round(self._higher))))
draw.drawText(0, 14, str(self._lower) if self._use_float else str(int(round(self._lower))))
draw.setPen(QColor(255, 255, 255))
boundtext = draw.boundingRect(QtCore.QRectF(),
str(self._minVal) if self._use_float else str(int(round(self._minVal))))
draw.drawText(x_start + 2, 14, str(self._minVal) if self._use_float else str(int(round(self._minVal))))
boundtext = draw.boundingRect(QtCore.QRectF(),
str(self._maxVal) if self._use_float else str(int(round(self._maxVal))))
draw.drawText(x_end - boundtext.width(), 14,
str(self._maxVal) if self._use_float else str(int(round(self._maxVal))))
draw.end()
def paint_with_data_(data):
paint_with_data(delegate, data, self.view.viewOptions())
model.setItemData(index, data)
opt = self.view.viewOptions()
size = delegate.sizeHint(opt, index).expandedTo(QSize(10, 10))
opt.rect = QRect(QPoint(0, 0), size)
delegate.initStyleOption(opt, index)
img = QImage(opt.rect.size(), QImage.Format_ARGB32_Premultiplied)
p = QPainter(img)
try:
delegate.paint(p, opt, index)
finally:
p.end()
def paintEvent(self, event):
if self.__isTransparencySupported:
opt = QStyleOption()
opt.initFrom(self)
rect = opt.rect
p = QPainter(self)
p.setRenderHint(QPainter.Antialiasing, True)
p.setBrush(opt.palette.brush(QPalette.Window))
p.setPen(Qt.NoPen)
p.drawRoundedRect(rect, self.__radius, self.__radius)
p.end()
else:
StyledWidget_paintEvent(self, event)
def paintEvent(self, event):
if self.__pixmap.isNull():
return
sourcerect = QRect(QPoint(0, 0), self.__pixmap.size())
pixsize = QSizeF(self.__pixmap.size())
rect = self.contentsRect()
pixsize.scale(QSizeF(rect.size()), Qt.KeepAspectRatio)
targetrect = QRectF(QPointF(0, 0), pixsize)
targetrect.moveCenter(QPointF(rect.center()))
painter = QPainter(self)
painter.setRenderHint(QPainter.SmoothPixmapTransform)
painter.drawPixmap(targetrect, self.__pixmap, QRectF(sourcerect))
painter.end()
def paintEvent(self, event):
if self.__isTransparencySupported:
opt = QStyleOption()
opt.initFrom(self)
rect = opt.rect
p = QPainter(self)
p.setRenderHint(QPainter.Antialiasing, True)
p.setBrush(opt.palette.brush(QPalette.Window))
p.setPen(Qt.NoPen)
p.drawRoundedRect(rect, self.__radius, self.__radius)
p.end()
else:
StyledWidget_paintEvent(self, event)
def paintEvent(self, event):
if self.__pixmap.isNull():
return
sourcerect = QRect(QPoint(0, 0), self.__pixmap.size())
pixsize = QSizeF(self.__pixmap.size())
rect = self.contentsRect()
pixsize.scale(QSizeF(rect.size()), Qt.KeepAspectRatio)
targetrect = QRectF(QPointF(0, 0), pixsize)
targetrect.moveCenter(QPointF(rect.center()))
painter = QPainter(self)
painter.setRenderHint(QPainter.SmoothPixmapTransform)
painter.drawPixmap(targetrect, self.__pixmap, QRectF(sourcerect))
painter.end()
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 paintEvent(self, event):
pixmap = self._shadowPixmap
widget_rect = QRectF(QPointF(0.0, 0.0), QSizeF(self.size()))
frame_rect = QRectF(self.contentsRect())
left, top, right, bottom = self.getContentsMargins()
pixmap_rect = QRectF(QPointF(0, 0), QSizeF(pixmap.size()))
# Shadow casting rectangle.
pixmap_shadow_rect = pixmap_rect.adjusted(left, top, -right, -bottom)
source_rects = self._shadowPixmapFragments(pixmap_rect,
pixmap_shadow_rect)
target_rects = self._shadowPixmapFragments(widget_rect, frame_rect)
painter = QPainter(self)
for source, target in zip(source_rects, target_rects):
painter.drawPixmap(target, pixmap, source)
painter.end()
def paintEvent(self, event):
pixmap = self._shadowPixmap
widget_rect = QRectF(QPointF(0.0, 0.0), QSizeF(self.size()))
frame_rect = QRectF(self.contentsRect())
left, top, right, bottom = self.getContentsMargins()
pixmap_rect = QRectF(QPointF(0, 0), QSizeF(pixmap.size()))
# Shadow casting rectangle.
pixmap_shadow_rect = pixmap_rect.adjusted(left, top, -right, -bottom)
source_rects = self._shadowPixmapFragments(pixmap_rect,
pixmap_shadow_rect)
target_rects = self._shadowPixmapFragments(widget_rect, frame_rect)
painter = QPainter(self)
for source, target in zip(source_rects, target_rects):
painter.drawPixmap(target, pixmap, source)
painter.end()
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 send_report(self):
from AnyQt.QtSvg import QSvgGenerator
if self.model:
self.reportSection("Tree")
_, filefn = self.getUniqueImageName(ext=".svg")
svg = QSvgGenerator()
svg.setFileName(filefn)
ssize = self.scene.sceneRect().size()
w, h = ssize.width(), ssize.height()
fact = 600 / w
svg.setSize(QSize(600, h * fact))
painter = QPainter()
painter.begin(svg)
self.scene.render(painter)
painter.end()
def __updateMask(self):
opt = QStyleOption()
opt.initFrom(self)
rect = opt.rect
size = rect.size()
mask = QBitmap(size)
p = QPainter(mask)
p.setRenderHint(QPainter.Antialiasing)
p.setBrush(Qt.black)
p.setPen(Qt.NoPen)
p.drawRoundedRect(rect, self.__radius, self.__radius)
p.end()
self.setMask(mask)
def __updateMask(self):
opt = QStyleOption()
opt.initFrom(self)
rect = opt.rect
size = rect.size()
mask = QBitmap(size)
p = QPainter(mask)
p.setRenderHint(QPainter.Antialiasing)
p.setBrush(Qt.black)
p.setPen(Qt.NoPen)
p.drawRoundedRect(rect, self.__radius, self.__radius)
p.end()
self.setMask(mask)
def crosshairs(color, radius=24, circle=False):
radius = max(radius, 16)
pixmap = QPixmap(radius, radius)
pixmap.fill(Qt.transparent)
painter = QPainter()
painter.begin(pixmap)
painter.setRenderHints(QPainter.Antialiasing)
pen = QPen(QBrush(color), 1)
pen.setWidthF(1.5)
painter.setPen(pen)
if circle:
painter.drawEllipse(2, 2, radius - 2, radius - 2)
painter.drawLine(radius / 2, 7, radius / 2, radius / 2 - 7)
painter.drawLine(7, radius / 2, radius / 2 - 7, radius / 2)
painter.end()
return pixmap
def crosshairs(color, radius=24, circle=False):
radius = max(radius, 16)
pixmap = QPixmap(radius, radius)
pixmap.fill(Qt.transparent)
painter = QPainter()
painter.begin(pixmap)
painter.setRenderHints(QPainter.Antialiasing)
pen = QPen(QBrush(color), 1)
pen.setWidthF(1.5)
painter.setPen(pen)
if circle:
painter.drawEllipse(2, 2, radius - 2, radius - 2)
painter.drawLine(radius / 2, 7, radius / 2, radius / 2 - 7)
painter.drawLine(7, radius / 2, radius / 2 - 7, radius / 2)
painter.end()
return pixmap
def send_report(self):
from AnyQt.QtSvg import QSvgGenerator
if self.model:
self.reportSection("Tree")
_, filefn = self.getUniqueImageName(ext=".svg")
svg = QSvgGenerator()
svg.setFileName(filefn)
ssize = self.scene.sceneRect().size()
w, h = ssize.width(), ssize.height()
fact = 600 / w
svg.setSize(QSize(600, h * fact))
painter = QPainter()
painter.begin(svg)
self.scene.render(painter)
painter.end()
def test_delegate(self):
model = DistanceMatrixModel()
matrix = np.array([[0.0, 0.1, 0.2], [0.1, 0.0, 0.1], [0.2, 0.1, 0.0]])
model.set_data(matrix)
delegate = TableBorderItem()
for row, col in product(range(model.rowCount()),
range(model.columnCount())):
index = model.index(row, col)
option = QStyleOptionViewItem()
size = delegate.sizeHint(option, index).expandedTo(QSize(30, 18))
delegate.initStyleOption(option, index)
img = QImage(size, QImage.Format_ARGB32_Premultiplied)
painter = QPainter(img)
try:
delegate.paint(painter, option, index)
finally:
painter.end()
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_with_data(
delegate: QAbstractItemDelegate,
data: Dict[int, Any],
options: QStyleOptionViewItem = None
) -> None:
model = create_model(1, 1)
index = model.index(0, 0)
model.setItemData(index, data)
opt = QStyleOptionViewItem(options) if options is not None else QStyleOptionViewItem()
size = delegate.sizeHint(opt, index).expandedTo(QSize(10, 10))
opt.rect = QRect(QPoint(0, 0), size)
delegate.initStyleOption(opt, index)
img = QImage(opt.rect.size(), QImage.Format_ARGB32_Premultiplied)
p = QPainter(img)
try:
delegate.paint(p, opt, index)
finally:
p.end()
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 __startInternalDrag(self, frame, hotSpot=None):
drag = QDrag(self)
pixmap = QPixmap(frame.size())
frame.render(pixmap)
transparent = QPixmap(pixmap.size())
transparent.fill(Qt.transparent)
painter = QPainter(transparent)
painter.setOpacity(0.35)
painter.drawPixmap(0, 0, pixmap.width(), pixmap.height(), pixmap)
painter.end()
drag.setPixmap(transparent)
if hotSpot is not None:
drag.setHotSpot(hotSpot)
mime = QMimeData()
mime.setData("application/x-internal-move", b"")
drag.setMimeData(mime)
return drag.exec_(Qt.MoveAction)
def splash_screen():
# type: () -> Tuple[QPixmap, QRect]
"""
Return a splash screen pixmap and an text area within it.
The text area is used for displaying text messages during application
startup.
The default implementation returns a bland rectangle splash screen.
Returns
-------
t : Tuple[QPixmap, QRect]
A QPixmap and a rect area within it.
"""
path = pkg_resources.resource_filename(
__name__, "icons/orange-canvas-core-splash.svg")
pm = QPixmap(path)
version = QCoreApplication.applicationVersion()
if version:
version_parsed = LooseVersion(version)
version_comp = version_parsed.version
version = ".".join(map(str, version_comp[:2]))
size = 21 if len(version) < 5 else 16
font = QFont()
font.setPixelSize(size)
font.setBold(True)
font.setItalic(True)
font.setLetterSpacing(QFont.AbsoluteSpacing, 2)
metrics = QFontMetrics(font)
br = metrics.boundingRect(version).adjusted(-5, 0, 5, 0)
br.moveBottomRight(QPoint(pm.width() - 15, pm.height() - 15))
p = QPainter(pm)
p.setRenderHint(QPainter.Antialiasing)
p.setRenderHint(QPainter.TextAntialiasing)
p.setFont(font)
p.setPen(QColor("#231F20"))
p.drawText(br, Qt.AlignCenter, version)
p.end()
textarea = QRect(15, 15, 170, 20)
return pm, textarea
def render_drop_shadow_frame(pixmap, shadow_rect, shadow_color,
offset, radius, rect_fill_color):
pixmap.fill(QColor(0, 0, 0, 0))
scene = QGraphicsScene()
rect = QGraphicsRectItem(shadow_rect)
rect.setBrush(QColor(rect_fill_color))
rect.setPen(QPen(Qt.NoPen))
scene.addItem(rect)
effect = QGraphicsDropShadowEffect(color=shadow_color,
blurRadius=radius,
offset=offset)
rect.setGraphicsEffect(effect)
scene.setSceneRect(QRectF(QPointF(0, 0), QSizeF(pixmap.size())))
painter = QPainter(pixmap)
scene.render(painter)
painter.end()
scene.clear()
scene.deleteLater()
return pixmap
def export(self, filename=None):
from AnyQt.QtGui import QPdfWriter
pw = QPdfWriter(filename)
dpi = QDesktopWidget().logicalDpiX()
pw.setResolution(dpi)
pw.setPageMargins(QMarginsF(0, 0, 0, 0))
pw.setPageSizeMM(QSizeF(self.getTargetRect().size()) / dpi * 25.4)
painter = QPainter(pw)
try:
self.setExportMode(True, {'antialias': True,
'background': self.background,
'painter': painter})
painter.setRenderHint(QPainter.Antialiasing, True)
self.getScene().render(painter,
QRectF(self.getTargetRect()),
QRectF(self.getSourceRect()))
finally:
self.setExportMode(False)
painter.end()
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 paintEvent(self, event):
# TODO: Use QPainter.drawPixmapFragments on Qt 4.7
opt = QStyleOption()
opt.initFrom(self)
pixmap = self.__shadowPixmap
shadow_rect = QRectF(opt.rect)
widget_rect = QRectF(self.widget().geometry())
widget_rect.moveTo(self.radius_, self.radius_)
left = top = right = bottom = self.radius_
pixmap_rect = QRectF(QPointF(0, 0), QSizeF(pixmap.size()))
# Shadow casting rectangle in the source pixmap.
pixmap_shadow_rect = pixmap_rect.adjusted(left, top, -right, -bottom)
source_rects = self.__shadowPixmapFragments(pixmap_rect,
pixmap_shadow_rect)
target_rects = self.__shadowPixmapFragments(shadow_rect, widget_rect)
painter = QPainter(self)
for source, target in zip(source_rects, target_rects):
painter.drawPixmap(target, pixmap, source)
painter.end()
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
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()
style = QApplication.style()
if style is not None:
opt = QStyleOption()
opt.palette = QApplication.palette()
pm = style.generatedIconPixmap(mode, pm, opt)
return pm
