def __init__(self,
escena,
bloqueMarker,
rutinaPulsada=None,
siEditando=False):
super(MarkerSC, self).__init__(escena, bloqueMarker)
self.rutinaPulsada = rutinaPulsada
self.rutinaPulsadaCarga = None
self.distBordes = 0.20 * bloqueMarker.anchoCasilla
self.pixmap = QtSvg.QSvgRenderer(
QtCore.QByteArray(bloqueMarker.xml.encode("utf8")))
self.posicion2xy()
self.siMove = False
self.tpSize = None
self.siEditando = siEditando
self.siRecuadro = False
if siEditando:
self.setAcceptHoverEvents(True)
def test_init(qtbot):
svg = 'linuxnano/resources/icons/general/unknown.svg'
renderer = QtSvg.QSvgRenderer()
renderer.load(svg)
wid = DeviceIconWidget(renderer)
assert isinstance(wid, DeviceIconWidget)
def pushButtonPulseshapeShow(self):
if transmitter.pulseshapeShapeIndex == 1 and transmitter.pulseshapeNumberOfZeros is None:
return
sequenceLength = 20 # TODO replace with real sequence Length
if transmitter.pulseshapeShapeIndex == 0:
sequence = self.createRectSequence(sequenceLength)
if transmitter.pulseshapeShapeIndex == 1:
sequence = self.createSincSequence(sequenceLength, transmitter.pulseshapeNumberOfZeros)
self.createPulseShapeImage(self, sequence, sequenceLength)
renderer = QtSvg.QSvgRenderer()
renderer.load(CONFIG.TEMPORARY_DIRECTORY_NAME + "pulseshape_plot.svg")
size = renderer.defaultSize()
item = QtSvg.QGraphicsSvgItem()
item.setSharedRenderer(renderer)
scene = QtWidgets.QGraphicsScene()
scene.addItem(item)
graphicsView = QtWidgets.QGraphicsView()
graphicsView.setScene(scene)
graphicsView.fitInView(item)
graphicsView.isInteractive = True
layout = QtWidgets.QGridLayout()
layout.addWidget(graphicsView)
dialog = QtWidgets.QDialog(self)
dialog.setLayout(layout)
dialog.setWindowTitle("Pulseshape")
dialog.exec_()
def paintEvent(self, event): # pylint: disable=W0613
xml = copy.deepcopy(self._svg)
for pad in self.pads():
xml.find('.//*[@id="%s"]' % self.indexToId(pad)
).attrib['transform'] = 'translate(%f %f)' % (
self._values[pad].x(), self._values[pad].y())
for btn in self.buttons():
self._fillElement(xml.find('.//*[@id="%s"]' % self.indexToId(btn)),
(0xFF0000 if self._values[btn] else 0xcccccc),
recurse=btn
not in {self.INDEX_PS, self.INDEX_TPAD})
img = QtGui.QImage(self._hit.width(), self._hit.height(),
QtGui.QImage.Format_RGB888)
painter = QtGui.QPainter(img)
painter.setBackground(QtCore.Qt.white)
painter.eraseRect(self.rect())
renderer = QtSvg.QSvgRenderer(ET.tostring(xml.getroot()))
renderer.render(painter)
painter = QtGui.QPainter(self)
painter.drawImage(
QtCore.QPoint((self.width() - self._hit.width()) // 2,
self.height() - self._hit.height()), img)
if self._status:
mt = painter.fontMetrics()
rc = QtCore.QRectF(0,
self.height() - mt.height() - 1, self.width(),
mt.height())
painter.drawText(rc, QtCore.Qt.AlignCenter, self._status)
def __init__(self, content: str, parent: QWidget = None):
"""Creates a new SVG viewer with the given SVG content.
:param content: the SVG content to show.
:param parent: optional parent widget, defaults to None.
"""
super().__init__(parent)
self.setScene(QGraphicsScene(self))
self.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)
self.setDragMode(QGraphicsView.ScrollHandDrag)
self.setViewportUpdateMode(QGraphicsView.FullViewportUpdate)
svg_renderer = QtSvg.QSvgRenderer(content.encode('utf-8'))
svg_item = QtSvg.QGraphicsSvgItem()
svg_item.setSharedRenderer(svg_renderer)
svg_item.setFlags(QGraphicsItem.ItemClipsToShape)
svg_item.setCacheMode(QGraphicsItem.NoCache)
svg_item.setZValue(0)
scene = self.scene()
scene.clear()
self.resetTransform()
scene.addItem(svg_item)
scene.setSceneRect(svg_item.boundingRect())
def __init__(self, parent=None, path=None, layer=0):
super(CustomButton, self).__init__(parent)
if path is None:
tpath = os.path.expanduser(INFO.MACRO_PATH)
path = os.path.join(tpath, 'LatheMacro.svg')
self.r = QtSvg.QSvgRenderer(path)
self.basename = 'layer'
self.setLayerNumber(layer)
def _render(self, path):
render = QtSvg.QSvgRenderer()
render.load(path)
img = QtGui.QPixmap(60, 60)
img.fill(QtGui.QColor(255, 255, 255, 0))
render.render(QtGui.QPainter(img))
icon = QtGui.QIcon(img)
return icon
def _load_icon(self, path, bg_color=0x10808080):
base_image = QtGui.QImage(24, 24, QtGui.QImage.Format_ARGB32)
base_image.fill(bg_color)
# create the icon pixmap:
QtSvg.QSvgRenderer(path).render(QtGui.QPainter(base_image))
pixmap = QtGui.QPixmap.fromImage(base_image)
return pixmap
def reset(self):
self.posicion2xy()
bm = self.bloqueDatos
self.pixmap = QtSvg.QSvgRenderer(
QtCore.QByteArray(bm.xml.encode("utf8")))
self.setOpacity(bm.opacidad)
self.setZValue(bm.posicion.orden)
self.update()
def __init__(self, *, node: music.BaseNode, **kwargs: Any) -> None:
assert isinstance(node, model.ScoreTrack)
self.__widget = None # type: ScoreTrackWidget
self.__track = node # type: model.ScoreTrack
super().__init__(
node=node,
icon=QtSvg.QSvgRenderer(os.path.join(DATA_DIR, 'icons', 'track-type-score.svg')),
**kwargs)
def render_svg(self, svg, size):
renderer = QtSvg.QSvgRenderer(bytes(svg, 'utf-8'))
qim = QtGui.QImage(size, QtGui.QImage.Format_ARGB32)
qim.fill(0)
painter = QtGui.QPainter()
painter.begin(qim)
renderer.render(painter)
painter.end()
return qim
def getImage(self, file, width=0, height=0, color=None, scale=1.0, size=0):
if os.path.splitext(file)[1] == '.svg':
try:
renderer = self._svgRendererMap[file]
except:
renderer = QtSvg.QSvgRenderer(os.path.join(
self.basepath, file))
if renderer.isValid():
self._svgRendererMap[file] = renderer
else:
self._logger.error('Could not load image file "' + file +
'".')
return QtGui.QImage()
return ImageFactory.createImageFromSvg(renderer, width, height,
color, scale, size)
else:
try:
image = self._imageMap[file]
except:
image = QtGui.QImage(os.path.join(self.basepath, file))
if image.format() == QtGui.QImage.Format_Invalid:
self._logger.error('Could not load image file "' + file +
'".')
return QtGui.QImage()
self._imageMap[file] = image
noScale = False
if width <= 0 or height <= 0:
owidth = image.width()
oheight = image.height()
if width <= 0 and height <= 0:
if size > 0:
if owidth == oheight:
witdth = size
height = size
elif owidth > oheight:
height = oheight / owidth * size
width = size
else:
height = size
width = owidth / oheight * size
elif scale == 1.0:
noScale = True
else:
width = int(owidth * scale)
height = int(oheight * scale)
elif height <= 0:
height = int(width * float(oheight) / float(owidth))
elif width <= 0:
width = int(height * float(owidth) / float(oheight))
if noScale:
outimage = QtGui.QImage(image)
else:
outimage = image.scaled(width, height)
if color and outimage:
self.colorizeImage(outimage, color)
return outimage
def _add_item(self, name, text, number, svg=None):
item = QtWidgets.QListWidgetItem(text)
icon = QtGui.QIcon()
filename = get_filename('pics/{}.svg'.format(name))
icon.addFile(filename)
item.setIcon(icon)
self.palette.addItem(item)
svg = svg or QtSvg.QSvgRenderer(filename)
self.grid.pics[number] = svg
item.setData(KIND_ROLE, number)
def svg2pixmap(self, img, size):
render = QtSvg.QSvgRenderer(img)
image = QtGui.QImage(size.width(), size.height(),
QtGui.QImage.Format_ARGB32)
painter = QtGui.QPainter(image)
painter.setCompositionMode(QtGui.QPainter.CompositionMode_SourceOver)
image.fill(Qt.Qt.transparent)
render.render(painter)
img = QtGui.QPixmap.fromImage(image)
del painter
return img
def __init__(self, interface: Interfaces_module.Interfaces, skaner: Scanner_module.Scanner):
super(Mapa, self).__init__()
# logika
self.items = []
self.skaner = skaner
self.connected_interface = interface
# qt
self.image = QtGui.QImage()
self.ui = QtWidgets.QWidget()
self.pc_renderer = QtSvg.QSvgRenderer("pc_svgs.svg")
self.painter = QtGui.QPainter(self.image)
self.pen = QtGui.QPen()
def setIcon(self, imagePath, size=None):
svg = QtSvg.QSvgRenderer(imagePath)
qim = QtGui.QImage(48, 48, QtGui.QImage.Format_ARGB32)
qim.fill(0)
painter = QtGui.QPainter()
painter.begin(qim)
svg.render(painter)
painter.end()
pixmap = QtGui.QPixmap(qim)
self.iconQLabel.setPixmap(pixmap)
def __init__(self, *, icon_name: str, hotspot: Tuple[int, int],
**kwargs: Any) -> None:
super().__init__(**kwargs)
self.__icon_name = icon_name
pixmap = QtGui.QPixmap(64, 64)
pixmap.fill(Qt.transparent)
painter = QtGui.QPainter(pixmap)
renderer = QtSvg.QSvgRenderer(self.iconPath())
renderer.render(painter, QtCore.QRectF(0, 0, 64, 64))
painter.end()
self.__cursor = QtGui.QCursor(pixmap, *hotspot)
def renderSvg(fileOrRenderer, name, width, height, background=Qt.transparent):
"""Load the object with the given name from *file* and render it into a pixmap of the given
dimensions. Return that pixmap."""
if isinstance(fileOrRenderer, str):
renderer = QtSvg.QSvgRenderer(fileOrRenderer)
else:
renderer = fileOrRenderer
pixmap = QtGui.QPixmap(width, height)
pixmap.fill(background)
painter = QtGui.QPainter(pixmap)
renderer.render(painter, name)
painter.end()
return pixmap
def _svgImage(self, *, width: _tp.Optional[int],
height: _tp.Optional[int]) -> _qtg.QImage:
imageBytes = self._loadBytes()
svgRenderer = _qsvg.QSvgRenderer(imageBytes)
defaultSize = svgRenderer.defaultSize()
size = self._getSize(defaultSize, width=width, height=height)
image = _qtg.QImage(size, _qtg.QImage.Format_ARGB32_Premultiplied)
image.fill(_qtc.Qt.transparent)
painter = _qtg.QPainter(image)
svgRenderer.render(painter)
return image
def update_nlp_graphics(self):
"""Updates the current graph.
This takes into account all changes to the filter, NLP instance and
drawing parameters.
"""
# print('NLPCanvas#updateNLPGraphics')
scene = QtWidgets.QGraphicsScene()
self.ui.graphicsView.setScene(scene)
br = QtSvg.QGraphicsSvgItem()
rr = QtSvg.QSvgRenderer(self.render_nlpgraphics())
br.setSharedRenderer(rr)
scene.addItem(br)
self.ui.graphicsView.show()
def icono(self, pieza, nombre):
fich = os.path.join("Pieces", nombre, "%s%s.svg" % ("w" if pieza.isupper() else "b", pieza.lower()))
f = codecs.open(fich, "r", 'utf-8', 'ignore')
qb = QtCore.QByteArray(f.read().encode("utf-8"))
f.close()
pm = QtGui.QPixmap(32, 32)
pm.fill(QtCore.Qt.transparent)
render = QtSvg.QSvgRenderer(qb)
painter = QtGui.QPainter()
painter.begin(pm)
render.render(painter)
painter.end()
icon = QtGui.QIcon(pm)
return icon
def get_path_arrow(arrow):
filenames = {
b"<": "left.svg",
b">": "right.svg",
b"v": "down.svg",
b"^": "up.svg"
}
filename = filenames.get(arrow)
if filename:
return QtSvg.QSvgRenderer(
os.path.join(os.path.dirname(__file__), "pics", "arrows",
filename))
else:
return None
def __init__(self, fileName, size=None, colormap=None):
"""
Load an SVG resource file and replace colors according to
provided dictionary `colormap`. Only fill and stroke is replaced.
Also scales the pixmap if a QSize is provided.
"""
data = self.loadAndMap(fileName, colormap)
renderer = QtSvg.QSvgRenderer(data)
size = renderer.defaultSize() if size is None else size
super().__init__(size)
self.fill(QtCore.Qt.transparent)
painter = QtGui.QPainter(self)
renderer.render(painter)
painter.end()
def saveAllPNG(self, nombre, px):
for pieza in "pnbrqk":
for color in "wb":
fich = os.path.join("Pieces", nombre, "%s%s.svg" % (color, pieza))
f = codecs.open(fich, "r", 'utf-8', 'ignore')
qb = QtCore.QByteArray(f.read().encode("utf-8"))
f.close()
pm = QtGui.QPixmap(px, px)
pm.fill(QtCore.Qt.transparent)
render = QtSvg.QSvgRenderer(qb)
painter = QtGui.QPainter()
painter.begin(pm)
render.render(painter)
painter.end()
pm.save("IntFiles/Figs/%s%s.png" % (color, pieza), "PNG")
def generaPM(piezas):
dicPM["V"] = Iconos.pmComentario()
dicPM["R"] = Iconos.pmApertura()
dicPM["M"] = Iconos.pmComentarioMas()
dicPM["S"] = Iconos.pmAperturaComentario()
for k in "KQRNBkqrnb":
dicPZ[k] = piezas.render(k)
carpNAGs = "./IntFiles/NAGs"
for f in os.listdir(carpNAGs):
if f.endswith(".svg") and f.startswith("$") and len(f) > 5:
nag = f[1:-4]
if nag.isdigit():
fsvg = carpNAGs + "/" + f
dicNG[nag] = QtSvg.QSvgRenderer(fsvg)
def updt_map_data(self, config_path, width, height):
"""Mise à jour des objets à dessiner sur la map
Entrée:
- config_path (str): le chemin du fichier svg de map
- height (int): taille de la carte, en mm
- width (int): taille de la carte, en mm
"""
self.svg_scl = self.qt_is_compatible and self.parent.settings_dict[
'Carte (Scaling)']
self.map_width = width
self.map_height = height
self.svg_data = QtSvg.QSvgRenderer(config_path)
if self.svg_scl:
self.svg_data.setAspectRatioMode(Qt.KeepAspectRatio)
def initialise():
for x in _pixmap_files:
with importlib_resources.path(__name__, x) as res:
with open(res, 'rb') as f:
img = os.path.splitext(x)[0]
pixmap = QtGui.QPixmap()
pixmap.loadFromData(f.read())
_pixmaps[img] = pixmap
for x in _svg_files:
with importlib_resources.path(__name__, x) as res:
with open(res, 'rb') as f:
img = os.path.splitext(x)[0]
svg = QtSvg.QSvgRenderer(f.read())
_svgs[img] = svg
def __init__(self, symbol, parent=None):
super().__init__(parent)
self._symbol = symbol
try:
renderer, svg_symbol = self._cache[self._symbol]
except KeyError:
path = os.path.join(DATA_DIR, 'symbols', '%s.svg' % self._symbol)
svg_symbol = SvgSymbol(path)
renderer = QtSvg.QSvgRenderer(svg_symbol.get_xml())
self._cache[self._symbol] = (renderer, svg_symbol)
self.grp = QtWidgets.QGraphicsItemGroup(self)
origin_x, origin_y = svg_symbol.get_origin()
self.grp.setPos(-origin_x, -origin_y)
self.body = QtSvg.QGraphicsSvgItem(self.grp)
self.body.setSharedRenderer(renderer)
def init():
from maestro.widgets import WidgetClass
WidgetClass(
id='playback', theClass=PlaybackWidget, name=translate('Playback', 'playback'),
icon=utils.images.icon('media-playback-start'),
areas='dock', preferredDockArea='left'
).register()
for command in PlayCommand:
PlayControlAction.register(
context='playback', identifier=command.value, label=command.label(),
shortcut=Qt.Key_Space if command is PlayCommand.PlayPause else None
)
global renderer, playIcon, pauseIcon
renderer = QtSvg.QSvgRenderer(':maestro/playback.svg')
playIcon = QtGui.QIcon(utils.images.renderSvg(
renderer, "media_playback_start", ICON_SIZE, ICON_SIZE))
pauseIcon = QtGui.QIcon(utils.images.renderSvg(
renderer, "media_playback_pause", ICON_SIZE, ICON_SIZE))
async def startProfile(self) -> None:
self.setEnabled(False)
self.setCursor(Qt.BusyCursor)
if self.__item is not None:
self.__scene.removeItem(self.__item)
self.__item = None
try:
svg = await self.audioproc_client.profile_audio_thread(
duration=self.__duration.value())
renderer = QtSvg.QSvgRenderer()
renderer.load(svg)
self.__item = QtSvg.QGraphicsSvgItem()
self.__item.setSharedRenderer(renderer)
self.__scene.addItem(self.__item)
finally:
self.setEnabled(True)
self.unsetCursor()
