def __init__(self, parentWidget):
QWidget.__init__(self, parentWidget)
self.texture = QImage("ui/gras.png")
self.tree = QSvgRenderer("ui/tree.svg")
self.compass = QSvgRenderer("ui/compass2.svg")
# set the gras texture as the background image
self.setAutoFillBackground(True)
pal = self.palette()
pal.setBrush(QPalette.Window, QBrush(self.texture))
self.setPalette(pal)
self.angle = 0
self.shadowLength = 10
def setIcon(self, icon, name):
name = name.lower()
icon_path = ""
if icon == ICON_APPLICATION:
self.p_size = QRectF(3, 2, 19, 18)
if "audacious" in name:
icon_path = ":/scalable/pb_audacious.svg"
self.p_size = QRectF(5, 4, 16, 16)
elif "clementine" in name:
icon_path = ":/scalable/pb_clementine.svg"
self.p_size = QRectF(5, 4, 16, 16)
elif "distrho" in name:
icon_path = ":/scalable/pb_distrho.svg"
self.p_size = QRectF(5, 4, 16, 16)
elif "jamin" in name:
icon_path = ":/scalable/pb_jamin.svg"
self.p_size = QRectF(5, 3, 16, 16)
elif "mplayer" in name:
icon_path = ":/scalable/pb_mplayer.svg"
self.p_size = QRectF(5, 4, 16, 16)
elif "vlc" in name:
icon_path = ":/scalable/pb_vlc.svg"
self.p_size = QRectF(5, 3, 16, 16)
else:
icon_path = ":/scalable/pb_generic.svg"
self.p_size = QRectF(4, 3, 16, 16)
elif icon == ICON_HARDWARE:
icon_path = ":/scalable/pb_hardware.svg"
self.p_size = QRectF(5, 2, 16, 16)
elif icon == ICON_DISTRHO:
icon_path = ":/scalable/pb_distrho.svg"
self.p_size = QRectF(5, 4, 16, 16)
elif icon == ICON_FILE:
icon_path = ":/scalable/pb_file.svg"
self.p_size = QRectF(5, 4, 16, 16)
elif icon == ICON_PLUGIN:
icon_path = ":/scalable/pb_plugin.svg"
self.p_size = QRectF(5, 4, 16, 16)
elif icon == ICON_LADISH_ROOM:
# TODO - make a unique ladish-room icon
icon_path = ":/scalable/pb_hardware.svg"
self.p_size = QRectF(5, 2, 16, 16)
else:
self.p_size = QRectF(0, 0, 0, 0)
qCritical("PatchCanvas::CanvasIcon.setIcon(%s, %s) - unsupported icon requested" % (
icon2str(icon), name.encode()))
return
self.m_renderer = QSvgRenderer(icon_path, canvas.scene)
self.setSharedRenderer(self.m_renderer)
self.update()
def __init__(self, parent=None):
super(GameWidget, self).__init__(parent)
self.game = Game()
self.renderer = QSvgRenderer("theme.svg")
self.boardWidget = BoardWidget(self.game, self.renderer, self)
self.stackLayoutWidget = QWidget(self)
self.stackLayoutWidget.setFixedWidth(150)
self.initWidget = GameInitWidget(self.game, self.stackLayoutWidget)
self.playWidget = GamePlayWidget(self.game, self.stackLayoutWidget)
self.finishedWidget = GameFinishedWidget(self.game,
self.stackLayoutWidget)
self.stackLayout = QStackedLayout()
self.stackLayout.addWidget(self.initWidget)
self.stackLayout.addWidget(self.playWidget)
self.stackLayout.addWidget(self.finishedWidget)
self.stackLayoutWidget.setLayout(self.stackLayout)
self.hboxLayout = QHBoxLayout()
self.hboxLayout.addWidget(self.boardWidget)
self.hboxLayout.addWidget(self.stackLayoutWidget)
self.hboxLayout.setStretch(0, 1)
self.hboxLayout.setContentsMargins(0, 0, 0, 0)
self.setLayout(self.hboxLayout)
self.game.phaseChanged.connect(self.update)
self.update()
def pixmap(name, size, mode, state):
"""Returns a (possibly cached) pixmap of the name and size with the default text color.
The state argument is ignored for now.
"""
if mode == QIcon.Selected:
color = QApplication.palette().highlightedText().color()
else:
color = QApplication.palette().text().color()
key = (name, size.width(), size.height(), color.rgb(), mode)
try:
return _pixmaps[key]
except KeyError:
i = QImage(size, QImage.Format_ARGB32_Premultiplied)
i.fill(0)
painter = QPainter(i)
# render SVG symbol
QSvgRenderer(os.path.join(__path__[0], name + ".svg")).render(painter)
# recolor to text color
painter.setCompositionMode(QPainter.CompositionMode_SourceIn)
painter.fillRect(i.rect(), color)
painter.end()
# let style alter the drawing based on mode, and create QPixmap
pixmap = QApplication.style().generatedIconPixmap(
mode, QPixmap.fromImage(i), QStyleOption())
_pixmaps[key] = pixmap
return pixmap
def __init__(self, canvas, color, svg=None, width=0.0, length=0.0, orientation=True, marker_mode=False, config=None):
super(CanvasMarker, self).__init__(canvas)
self.canvas = canvas
self.config = config
self.size = 20
self.changing_scale = 400
self.marker_mode = marker_mode
self.color = color
self.pointbrush = QBrush(self.color)
self.pointpen = QPen(Qt.black)
self.pointpen.setWidth(1)
self.map_pos = QgsPointXY(0.0, 0.0)
self.heading = 0
self.width = width
self.length = length
self.orientation = orientation
if svg is not None:
# set crs and ellipsoid
crs = self.canvas.mapSettings().destinationCrs()
self.distance_calc = QgsDistanceArea()
self.distance_calc.setSourceCrs(crs, QgsProject.instance().transformContext())
self.distance_calc.setEllipsoid(crs.ellipsoidAcronym())
self.svg = QSvgRenderer(svg)
else:
self.svg = None
def flush(self):
self._renderer = QSvgRenderer(self.dot.pipe())
max_h = self._renderer.defaultSize().height() / self._height
if max_h <= 1:
max_h = 0
max_h = int(self.delta() * max_h)
self.scrollbar.setMaximum(max_h)
def generate_qr_code(text):
qr = qrcode.QRCode(version=None,
error_correction=qrcode.constants.ERROR_CORRECT_H,
border=4,
box_size=10)
qr.add_data(text)
qr.make(fit=True)
qr_img = qr.make_image(image_factory=qrcode.image.svg.SvgPathImage)
stream = io.BytesIO()
qr_img.save(stream)
renderer = QSvgRenderer()
renderer.load(stream.getvalue())
final_img = QImage(600, 600, QImage.Format_ARGB32)
final_img.fill(QColor(0xF4, 0xF4, 0xF4))
painter = QPainter()
painter.begin(final_img)
painter.setCompositionMode(QPainter.CompositionMode_SourceOver)
renderer.render(
painter,
QRectF(0, 0,
final_img.rect().width(),
final_img.rect().height()))
painter.end()
pix = QPixmap.fromImage(final_img)
return pix
def initialize_loading_page(self):
svg_container = QGraphicsScene(self.window().loading_svg_view)
svg_item = QGraphicsSvgItem()
svg = QSvgRenderer(get_image_path("loading_animation.svg"))
svg.repaintNeeded.connect(svg_item.update)
svg_item.setSharedRenderer(svg)
svg_container.addItem(svg_item)
self.window().loading_svg_view.setScene(svg_container)
self.window().core_manager.events_manager.upgrader_tick.connect(self.set_loading_text)
self.window().core_manager.events_manager.upgrader_started.connect(
lambda: self.set_loading_text("Upgrading..."))
self.window().core_manager.events_manager.upgrader_finished.connect(lambda: self.loading_label.hide())
# Create a loading label that displays the status during upgrading
self.loading_label = QLabel(self)
self.loading_label.setStyleSheet("color: #ddd; font-size: 22px;")
self.loading_label.setAlignment(Qt.AlignCenter)
self.on_window_resize()
self.loading_label.hide()
# Hide the force shutdown button initially. Should be triggered by shutdown timer from main window.
self.window().force_shutdown_btn.hide()
def getIcon(self, icon_name, base_color, hover_color):
root = QFileInfo(__file__).absolutePath()
svg_files = os.listdir(root + "/../../styles/assets/icons/svg/")
filename = "appbar." + icon_name + ".svg"
if filename in svg_files:
f = QFile(root + '/../../styles/assets/icons/svg/' + filename)
if f.open(QFile.ReadOnly | QFile.Text):
textStream = QTextStream(f)
svgData = textStream.readAll().replace(
'fill="#000000"', 'fill="{}"'.format(base_color))
svgData_hover = svgData.replace(
'fill="{}"'.format(base_color),
'fill="{}"'.format(hover_color))
f.close()
svg = QSvgRenderer(QByteArray().append(svgData))
svg_hover = QSvgRenderer(QByteArray().append(svgData_hover))
qim = QImage(76, 76, QImage.Format_RGBA8888)
qim.fill(0)
painter = QPainter()
painter.begin(qim)
svg.render(painter)
painter.end()
qim_hover = QImage(76, 76, QImage.Format_ARGB32)
qim_hover.fill(0)
painter = QPainter()
painter.begin(qim_hover)
svg_hover.render(painter)
painter.end()
self.icon = QIcon(QPixmap.fromImage(qim))
self.hovericon = QIcon(QPixmap.fromImage(qim_hover))
self.setIcon(self.icon)
else:
qim = QImage(76, 76, QImage.Format_RGBA8888)
qim.fill(0)
self.icon = QPixmap.fromImage(qim)
self.hovericon = QPixmap.fromImage(qim)
self.setIcon(self.icon)
def from_svg_bytes(self, svg_bytes):
"""Paints an svg from a bytes object"""
renderer = QSvgRenderer(svg_bytes)
painter = QPainter(self)
painter.eraseRect(self.rect())
renderer.render(painter)
painter.end()
def load_svg_sized_pixmap(path, w=100, h=100):
svg_renderer = QSvgRenderer(path)
image = QImage(w, h, QImage.Format_ARGB32)
painter = QPainter(image)
painter.eraseRect(0, 0, w, h)
svg_renderer.render(painter)
painter.end()
return QPixmap.fromImage(image)
def __init__(self, proj, canvas):
super(NorthArrow, self).__init__(canvas)
self.proj = proj
self.canvas = canvas
self.map_pos = QgsPointXY(0.0, 0.0)
self.svg = QSvgRenderer(":/resources/arrow.svg")
self.size = QSize(42, 64)
self.corner = 1
def intrinsicSize(self, doc, posInDocument, format):
renderer = QSvgRenderer(format.property(Window.SvgData))
size = renderer.defaultSize()
if size.height() > 25:
size *= 25.0 / size.height()
return QSizeF(size)
def __init__(self, filename, scene):
super(Vectorgraphic, self).__init__(scene)
self.renderer = QSvgRenderer()
self.renderer.load(filename)
self.svg = QGraphicsSvgItem(self)
self.svg.setSharedRenderer(self.renderer)
self.setRect(0, 0,
self.svg.boundingRect().width(),
self.svg.boundingRect().height())
def read_cards():
""" A function for importing the .svg image files depicting the playing cards.
"""
all_cards = dict()
for suit in 'HDSC':
for value in ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A']:
file = value + suit
all_cards[file] = QSvgRenderer('cards/' + file + '.svg')
return all_cards
def load_gears_animation():
svg_container = QGraphicsScene()
svg_item = QGraphicsSvgItem()
svg = QSvgRenderer(get_image_path("loading_animation.svg"))
svg.repaintNeeded.connect(svg_item.update)
svg_item.setSharedRenderer(svg)
svg_container.addItem(svg_item)
return svg_container
def __init__(self, parent=None, **kwargs):
self.m_value = False
self.m_onColour = QLed.Red
self.m_offColour = QLed.Grey
self.m_shape = QLed.Circle
QWidget.__init__(self, parent, **kwargs)
self._pressed = False
self.renderer = QSvgRenderer()
def loadSvgContent(self, content):
s = self.scene()
s.clear()
self.resetTransform()
item = QGraphicsSvgItem()
item.setSharedRenderer(QSvgRenderer(content))
item.setFlags(QGraphicsItem.ItemClipsToShape)
item.setCacheMode(QGraphicsItem.NoCache)
item.setZValue(0)
s.addItem(item)
def _render(self, data: XMLIconData) -> QIcon:
""" Create a template image, render the XML data in place, and convert it to an icon.
Use the viewbox dimensions as pixel sizes. """
svg = QSvgRenderer(data)
viewbox = svg.viewBox().size()
im = QImage(viewbox, QImage.Format_ARGB32)
im.fill(self._bg_color)
with QPainter(im) as p:
p.setRenderHints(self._render_hints)
svg.render(p)
return QIcon(QPixmap.fromImage(im))
def load(cls, filename, renderer=None):
"""Load a SVG document from filename, which may also be a QByteArray.
Yields only one Page instance, as SVG currently supports one page per
file. If the file can't be loaded by the underlying QSvgRenderer,
no Page is yielded.
"""
r = QSvgRenderer()
if r.load(filename):
yield cls(r, renderer)
def setDigitsFile(self, filemon):
self.m_digitsFile = filemon
if self.m_svg:
del self.m_svg
self.m_svg = QSvgRenderer(self)
if not self.m_svg.load(self.m_digitsFile):
print("Cannot load resource File")
self.m_digitsFile = ":/default/resources/train_digits.svg"
self.m_svg.load(self.m_digitsFile)
else:
print("Train digits correctly loaded")
self.update()
def foo(percent=0, size=32):
"""Returns QIcon"""
svgstr = svgFactory(svgExamples[0], percent, size)
svg_bytes = bytearray(svgstr, encoding="utf-8")
r = QSvgRenderer(svg_bytes)
i = QImage(32, 32, QImage.Format_ARGB32)
i.fill(0xffffffff)
p = QPainter(i)
r.render(p)
a = QPixmap.fromImage(i)
p.end()
return a
def __init__(self, *args, **kwargs):
super(DWaterProgress, self).__init__(*args, **kwargs)
self.waterFrontImage = QImage()
self.waterBackImage = QImage()
self.waterFrontSvg = QSvgRenderer(WATER_FRONT.encode())
self.waterBackSvg = QSvgRenderer(WATER_BACK.encode())
self.pops = []
self.initPops()
self.setTextVisible(True)
self.interval = 33
self.timer = QTimer(self)
self.timer.setInterval(self.interval)
self.timer.timeout.connect(self.onTimerOut)
self.resizePixmap(self.size())
self.frontXOffset = self.width()
self.backXOffset = 0
effect = QGraphicsDropShadowEffect(self)
effect.setOffset(0, 6)
effect.setColor(QColor(1, 153, 248, 255 * 5 / 20))
effect.setBlurRadius(12)
self.setGraphicsEffect(effect)
def update_board(self) -> None:
self._image.fill(0)
painter = QPainter()
painter.begin(self._image)
renderer = QSvgRenderer()
renderer.load(self._game_view._repr_svg_().encode("utf-8"))
renderer.render(painter)
painter.end()
self._label.setPixmap(QPixmap.fromImage(self._image))
self.setMinimumSize(
QSize(self._image.width() + 10,
self._image.height() + 10))
def svg2png( input_svg_file, newWidth = None, verify = True ):
"""
Returns an :py:class:`Image <PIL.Image.Image>` object of the PNG_ file produced when the CloudConvert_ server uploaded an input `SVG(Z) <svg_>`_ file. The PNG_ file has the same aspect ratio as the input file. Uses :py:class:`QSvgRenderer <PyQt5.QtSvg.QSvgRenderer>` to convert an `SVG(Z) <svg_>`_ into a PNG_.
:param str input_svg_file: the input SVG or SVGZ file. Filename must end in ``.svg`` or ``.svgz``.
:param int newWidth: optional argument. If specified, the pixel width of the output image.
:param bool verify: optional argument, whether to verify SSL connections. Default is ``True``.
:returns: the :py:class:`Image <PIL.Image.Image>` object of the PNG_ file from the input SVG or SVGZ file.
.. _PNG: https://en.wikipedia.org/wiki/Portable_Network_Graphics
.. _svg: https://en.wikipedia.org/wiki/Scalable_Vector_Graphics
.. seealso::
* :py:meth:`png2png <nprstuff.core.convert_image.png2png>`.
* :py:meth:`pdf2png <nprstuff.core.convert_image.pdf2png>`.
"""
try:
from PyQt5.QtSvg import QSvgRenderer
except:
logging.error( "ERROR, MUST INSTALL PyQt5.QtSvg MODULE. IT DOES NOT EXIST ON PYPI RIGHT NOW. YOU CAN RUN THE COMMAND, 'sudo apt install python3-pyqt5.qtsvg', TO INSTALL MODULE." )
sys.exit( 0 )
assert(any(map(lambda suffix: os.path.basename( input_svg_file ).endswith( '.%s' % suffix ),
( 'svg', 'svgz' ) ) ) )
assert( os.path.isfile( input_svg_file ) )
if os.path.basename( input_svg_file ).endswith( '.svgz' ):
r = QSvgRenderer( QByteArray( gzip.open( input_svg_file, 'rb' ).read( ) ) )
files = { 'file' : gzip.open( input_svg_file, 'rb' ).read( ) }
else:
r = QSvgRenderer( input_svg_file )
files = { 'file' : open( input_svg_file, 'rb' ).read( ) }
width = r.defaultSize().width()
height = r.defaultSize().height()
return _return_image_cc(
width, height, input_svg_file, 'svg', files,
newWidth = newWidth, verify = verify )
def updateUiSvg(self,color_list):
svgXmlStreamReader = QXmlStreamReader('<svg xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">\n' +
self.svgBoxArraySrc(10,10,40,5,24,4,color_list) +
'</svg>\n')
svgRender = QSvgRenderer()
svgRender.load(svgXmlStreamReader)
svgPixmap = QPixmap(480,80)
svgPixmap.fill(QtCore.Qt.transparent)
svgPainter = QPainter(svgPixmap)
svgRender.render(svgPainter)
self.ui.label_8.setPixmap(svgPixmap)
self.ui.label_8.setAlignment(QtCore.Qt.AlignCenter)
svgPainter.end()
def svg_to_png(svg_path, png_path):
"""
inspired by https://stackoverflow.com/questions/8551690/how-to-render-a-scaled-svg-to-a-qimage
"""
renderer = QSvgRenderer(svg_path)
print(renderer)
print(renderer.viewBoxF())
print(renderer.defaultSize())
image = QImage(width, height, QImage.Format_ARGB32)
painter = QPainter(image)
renderer.render(painter)
image.save(png_path)
painter.end()
def initialize_discovering_page(self):
svg_container = QGraphicsScene(self.window().discovering_svg_view)
svg_item = QGraphicsSvgItem()
svg = QSvgRenderer(get_image_path("loading_animation.svg"))
connect(svg.repaintNeeded, svg_item.update)
svg_item.setSharedRenderer(svg)
svg_container.addItem(svg_item)
self.window().discovering_svg_view.setScene(svg_container)
connect(self.window().core_manager.events_manager.discovered_channel,
self.on_discovered_channel)
def __init__(self, parent):
super().__init__(parent)
self._y = 0
self._width = 1
self._height = 1
self.dot = Digraph(format='svg', strict=True)
self._declared_count = 1
self._declared = dict()
self._renderer = QSvgRenderer(self.dot.pipe(), self)
self.scrollbar = QScrollBar(self.parent())
self.scrollbar.setRange(0, 0)
self.parent().wheelEvent = self.wheelEvent
def load_icon(name: AutoKeyIcon) -> QIcon:
file_path = ICON_PATH_PREFIX + "/" + name.value
icon = QIcon(file_path)
if not icon.availableSizes() and file_path.endswith(".svg"):
# FIXME: Work around Qt Bug: https://bugreports.qt.io/browse/QTBUG-63187
# Manually render the SVG to some common icon sizes.
icon = QIcon() # Discard the bugged QIcon
renderer = QSvgRenderer(file_path)
for size in (16, 22, 24, 32, 64, 128):
pixmap = QPixmap(QSize(size, size))
pixmap.fill(QColor(255, 255, 255, 0))
renderer.render(QPainter(pixmap))
icon.addPixmap(pixmap)
return icon
