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 __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 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 __init__(self, parent=None):
super().__init__()
#QFrame.__init__(self, parent)
self.svg_view = QtSvg.QSvgWidget("ichimatsu.svg")
self.svg_bkg = QtSvg.QSvgWidget("ichimatsu.svg")
self.original_size_view = self.getDefaultSize("ichimatsu.svg")
print(self.original_size_view)
self.original_size_bkg = self.getDefaultSize("ichimatsu.svg")
layout = QGridLayout()
layout.addWidget(self.svg_bkg, 1, 1)
layout.addWidget(self.svg_view, 1, 1)
self.setLayout(layout)
def __init__(self, *args, **kwargs):
kwargs.setdefault('width', 2)
avatar = kwargs.setdefault('avatar', 'tuga')
self.size = kwargs.pop('size', 45)
self.validate_avatar(avatar)
self.graphics_item = cursor = QtSvg.QGraphicsSvgItem()
# Loads from turtleart.svg
cursor.setSharedRenderer(svg_renderer)
cursor.setElementId(avatar)
# Define local transforms
rect = cursor.sceneBoundingRect()
curr_width, curr_height = rect.width(), rect.height()
cursor.setTransform(QtGui.QTransform(
1.00, 0.00,
0.00, 1.00,
-curr_width / 2, -curr_height / 2)
)
cursor.setTransformOriginPoint(0.5 * curr_width, 0.5 * curr_height)
cursor.setScale(self.size / curr_width)
cursor.setZValue(1.0)
self.pen = QtGui.QPen(QtGui.QColor(0, 0, 0))
self.brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
super().__init__(*args, **kwargs)
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 s_enter_print(self):
""" Enter print state """
self.current_state = self.machine.property("state")
print("DEBUG", self.current_state)
self.msg.show_msg(self.current_state)
byte_array = self.create_svg()
self.choice = QWidget()
self.choice.setWindowFlags(Qt.FramelessWindowHint)
self.choice.move(Cons.WINDOW_SIZE[0] / 2, Cons.WINDOW_SIZE[1] / 2)
self.editor = QtSvg.QSvgWidget()
self.editor.load(byte_array)
self.buttonPrint = QPushButton('Print', self.choice)
self.buttonPrint.clicked.connect(self.handle_print)
self.buttonPreview = QPushButton('Preview', self.choice)
self.buttonPreview.clicked.connect(self.handle_preview)
self.buttonCancel = QPushButton('Cancel', self.choice)
self.buttonCancel.clicked.connect(self.end_print)
self.scene = QGraphicsScene()
self.scene.addWidget(self.editor)
self.view = QGraphicsView()
self.view.setScene(self.scene)
layout = QGridLayout(self.choice)
layout.addWidget(self.view, 0, 0, 1, 3)
layout.addWidget(self.buttonPrint, 1, 0)
layout.addWidget(self.buttonPreview, 1, 1)
layout.addWidget(self.buttonCancel, 1, 2)
self.choice.show()
self.machine.action_complete.emit()
def __init__(self, procesador):
route = self.route = Routes.Transsiberian(procesador.configuracion)
titulo = "%s (%d)" % (_("Transsiberian Railway"), route.level)
icono = Iconos.Train()
extparam = "transsiberian"
super().__init__(parent=procesador.pantalla,
titulo=titulo,
icono=icono,
extparam=extparam)
self.procesador = procesador
wsvg = QtSvg.QSvgWidget()
x = self.route.get_txt().encode("utf-8")
wsvg.load(QtCore.QByteArray(x))
wsvg.setFixedSize(762, 762.0 * 658.0 / 1148.0)
lySVG = Colocacion.H().relleno(1).control(wsvg).relleno(1)
# Title
lbTit = self.LINE(_("Moscow"), _("Vladivostok"), 14, 500).altoFijo(26)
lbKM = self.KM(route.total_km, 12, 500).altoFijo(26)
self.set_style("White", "#33322C", lbTit, lbKM)
lbKMdone = self.KM(route.km, 12, 500).altoFijo(26)
self.set_border(lbKMdone)
lyTitle = Colocacion.H().control(lbTit).control(lbKM).control(lbKMdone)
if route.is_ended():
self.init_ended(route, lyTitle, lySVG)
else:
self.init_working(route, lyTitle, lySVG)
self.recuperarVideo(siTam=False)
def initUI(self):
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
#visualize board
self.viewer = QtSvg.QSvgWidget()
self.viewer.load("board_init.svg")
self.viewer.show()
# Create textbox
self.textbox = QLineEdit(self)
self.textbox.move(20, 20)
self.textbox.resize(280, 40)
# Create a button in the window
self.button_move = QPushButton('Move', self)
self.button_move.move(20, 80)
self.button_undo = QPushButton('Undo Move', self)
self.button_undo.move(120, 80)
self.button_computer = QPushButton('Computer Move', self)
self.button_computer.move(220, 80)
self.button_fen = QPushButton('Parse FEN', self)
self.button_fen.move(320, 80)
# connect button to function on_click
self.button_move.clicked.connect(self.on_click_move)
self.button_undo.clicked.connect(self.on_click_undo)
self.button_computer.clicked.connect(self.on_click_computer)
self.button_fen.clicked.connect(self.on_click_fen)
self.show()
def __init__(self, parent, message: str):
super().__init__(parent)
self.setWindowFlags(Qt.FramelessWindowHint)
self._label = QtWidgets.QLabel(self)
self._icon = QtSvg.QSvgWidget(
os.path.join(
paths.ICONS_PATH,
'exclamation_mark.svg',
))
self._label.setText(message)
self._label.setWordWrap(True)
self._icon.setFixedSize(20, 20)
self.setFixedSize(300, 150)
self._layout = QtWidgets.QHBoxLayout()
self._layout.addWidget(self._icon, alignment=Qt.AlignTop)
self._layout.addWidget(self._label, alignment=Qt.AlignTop)
self.setLayout(self._layout)
def save_polar_as_SVG(self):
if self.CHART_IS_PRESENT:
self.filename = QtWidgets.QFileDialog.getSaveFileName(
None, "choose save file name", "./plot.svg", "SVG (*.svg)")
if not self.filename[0] == "":
output_size = QtCore.QSize(
int(self.profileChart.size().width()),
int(self.profileChart.size().height()))
output_rect = QtCore.QRectF(QtCore.QPointF(0, 0),
QtCore.QSizeF(output_size))
svg = QtSvg.QSvgGenerator()
svg.setFileName(self.filename[0])
svg.setSize(output_size)
svg.setViewBox(output_rect)
painter = QtGui.QPainter()
painter.begin(svg)
painter.setRenderHint(QtGui.QPainter.Antialiasing)
self.profileChart.scene().render(
painter,
source=output_rect,
target=output_rect,
mode=QtCore.Qt.IgnoreAspectRatio)
painter.end()
else:
return
else:
self.raise_error("No plot is available")
def setupUi(self, MainWindow):
MainWindow.setObjectName("MainWindow")
MainWindow.resize(800, 600)
self.centralwidget = QtWidgets.QWidget(MainWindow)
self.centralwidget.setObjectName("centralwidget")
#
MainWindow.setCentralWidget(self.centralwidget)
self.menubar = QtWidgets.QMenuBar(MainWindow)
# self.menubar.setGeometry(QtCore.QRect(0, 0, 800, 21))
# self.menubar.setObjectName("menubar")
# MainWindow.setMenuBar(self.menubar)
# self.statusbar = QtWidgets.QStatusBar(MainWindow)
# self.statusbar.setObjectName("statusbar")
# MainWindow.setStatusBar(self.statusbar)
#
# self.retranslateUi(MainWindow)
# QtCore.QMetaObject.connectSlotsByName(MainWindow)
#
self.viewer = QtSvg.QSvgWidget()
self.viewer.load('images/castle.svg')
self.viewer.setGeometry(QtCore.QRect(0, 0, 600, 600))
# self.viewer.setAlignment(self.centralwidget)
# set the layout to centralWidget
lay = QtWidgets.QVBoxLayout(self.centralwidget)
# add the viewer to the layout
lay.addWidget(self.viewer)
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 CreateClick(self):
if self.minutesSpan.value() == 0:
QMessageBox.warning(self.Form, "Warning", "you can't use zero minutes")
return
if self.codeText.text() == '':
QMessageBox.warning(self.Form, "Warning", "you can't let code empty")
elif self.codeText.text().__contains__(' '):
QMessageBox.warning(self.Form, "Warning", "you can't use space in code")
else:
self.creator = Creator(self.name, self.codeText.text())
print(self.codeText.text())
if not self.creator.checkCodeIsExists():
QMessageBox.warning(self.Form, "Already exists", "that code is already created for another doctor ")
else:
if self.creator.create():
self.list.setEnabled(True)
self.createButton.setEnabled(False)
self.createButton.setEnabled(False)
self.closeButton.setEnabled(True)
self.showButton.setEnabled(True)
self.svgWidget = QtSvg.QSvgWidget('files/code.svg')
self.svgWidget.setObjectName('svg')
self.svgWidget.setStyleSheet("background:#fff")
self.close = QtWidgets.QPushButton(self.svgWidget)
self.close.setGeometry(10, 10, 181, 63)
self.svgWidget.setGeometry(50, 50, 759, 668)
self.close.setText(self._translate('svg', 'Close'))
self.close.clicked.connect(self.closeSvg)
self.svgWidget.show()
self.TimerSetup()
else:
QMessageBox.warning(self.Form, "Error", "Can't create qrcode please try again after a minute",
buttons=QMessageBox.Cancel)
def addItems(self):
while len(self.scene().items()) < NUM_LAYERS:
layer = random.choice(layers[1:])
path = os.path.join("../static/assets", layer + ".svg")
rot, tx, ty, scale = get_random_orientation()
item = QtSvg.QGraphicsSvgItem(path)
item.layer = layer
item.setPos(WIDTH / 2 + tx, WIDTH / 2 + ty)
item.setScale(scale)
item.setRotation(rot)
self.scene().addItem(item)
if item not in self.scene().items(self.sceneRect(),
QtCore.Qt.ContainsItemShape):
self.scene().removeItem(item)
continue
else:
if item.collidingItems(QtCore.Qt.IntersectsItemBoundingRect):
self.scene().removeItem(item)
continue
removed = False
for item2 in self.scene().items():
if item != item2:
if item.sceneBoundingRect().intersects(
item2.sceneBoundingRect()):
self.scene().removeItem(item)
removed = True
break
if removed:
continue
def __init__(self, parent=None):
#super().__init__()
self.w = QDialog(parent)
label = QLabel()
label.setText("subwindow")
self.view = QtSvg.QSvgWidget("test3.svg")
def initBoardLayout(self):
self.wid = QWidget()
boardLayout = QGridLayout()
self.grid = boardLayout
for r in range(self.rows):
for c in range(self.columns):
boardLayout.addWidget(self.squares[r][c], r,c)
self.barracks = []
barracksLayout = QGridLayout()
for c in range(self.columns):
widget = QtSvg.QSvgWidget(self.get_resource('images/white_rook.svg'))
widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
bsq = BarracksSquare(self.piece_set, BoardSquare.WHITE_ROOK, self.gendrag(c))
self.barracks.append(bsq)
barracksLayout.addWidget(bsq, 0, c)
layout = QVBoxLayout()
layout.addLayout(boardLayout)
layout.addLayout(barracksLayout)
self.wid.setLayout(layout)
self.main_window.setCentralWidget(self.wid)
def __init__(self, file):
super(EdithsMenuButton, self).__init__()
self.setFlat(True)
self.__icon = QtSvg.QSvgWidget('./pix/' + file + '.svg', self)
self.setFixedSize(50, 50)
def __init__(self, parent=None, lineup: list = None):
assert lineup is not None
super(LineupIconsWidget, self).__init__(parent)
self.target = None
self.lineup = lineup
self.setAcceptDrops(True)
self.wg_position = list()
for i in range(24):
layout = QVBoxLayout()
item = QtSvg.QSvgWidget(self)
if i == 0:
path = os.getcwd() + "\\src\\ui\\rsc\\players node keeper.svg"
elif i in lineup:
path = os.getcwd() + "\\src\\ui\\rsc\\players node.svg"
else:
path = os.getcwd() + "\\src\\ui\\rsc\\players node empty.svg"
item.load(path)
item.setFixedSize(32, 32)
layout.addWidget(item)
self.wg_position.append(layout)
item.show()
self.ly_players = QGridLayout(self)
self.ly_players.addLayout(self.wg_position[0], 2, 0)
for i in range(1, 21):
self.ly_players.addLayout(self.wg_position[i], (i - 1) % 5,
(i - 1) // 5 + 1)
self.ly_players.addLayout(self.wg_position[21], 1, 5)
self.ly_players.addLayout(self.wg_position[22], 2, 5)
self.ly_players.addLayout(self.wg_position[23], 3, 5)
self.setLayout(self.ly_players)
def initUI(self):
self.setGeometry(0, 0, QT_WIDTH, QT_HEIGHT)
self.setGeometry(0, 0, QT_WIDTH, QT_HEIGHT)
self.setWindowTitle('collection')
# Set window background color
self.setAutoFillBackground(True)
p = self.palette()
p.setColor(self.backgroundRole(), QtGui.QColor(200, 200, 200))
self.setPalette(p)
SVG_LIMIT = 200
all_svgWidgets = []
# -- not necessary anymore; keeping for fun
svgWidget = QtSvg.QSvgWidget(image_prefix + "temp_sample.svg", self)
svg_x = randint(0, QT_WIDTH - svgWidget.width())
svg_y = randint(0, QT_HEIGHT - svgWidget.height())
svgWidget.setGeometry(svg_x, svg_y, IMG_WIDTH, IMG_HEIGHT)
self.show()
self.timer = QtCore.QTimer()
self.timer.start(2000)
self.timer.timeout.connect(self.grabAndShow)
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 __init__(self):
super().__init__()
self.ui = Ui_StartWidget()
self.ui.setupUi(self)
self.ui.pushButtonSetup.pressed.connect(self.beginSetup.emit)
self.ui.pushButtonRecvResults.pressed.connect(self.recvResults.emit)
self.ui.pushButtonCalibrate.pressed.connect(self.calibrate.emit)
self.ui.pushButtonRawData.pressed.connect(self.processRawData)
self.ui.pushButtonSavedData.pressed.connect(
self.showSavedResultsPressed)
#self.ui.pushButtonCharacterize.pressed.connect()
self.ui.pushButtonPreferences.pressed.connect(
self.editPreferences.emit)
self.ui.pushButtonEditTransducer.pressed.connect(
self.editTransducer.emit)
self.ui.pushButtonAbout.pressed.connect(self.showAbout.emit)
logo = QtSvg.QSvgWidget()
self.ui.widgetLogo.setLayout(QVBoxLayout())
self.ui.widgetLogo.layout().addWidget(logo)
logo.load(
os.path.join(os.path.dirname(sys.argv[0]),
'resources/logo_large.svg'))
def export(self, fname, hideHistograms=True, pngScale=4):
"""
Save fan diagrams to file, with the full image, and color bars on the
alpha/gamma values
:param fname: the fname to save as
hideHistograms - (True) Prevent rendering the histograms, often ncier
for figures/presentations
If fname.endswith(".svg"), it outputs as an SVG. Howver, it's not the
cleanest thing (the files are quite large/unoptimized, and I can't
think of an easy way to correct that). Also, when the svg is
converted to pdf via Inkscape, things get f****d up for some
reasons (axes get thicker, fonts get borked, pixels get messed up).
So, it kinda works, but there's stuff seriously wrong.
One thing to make things cleaner is to use this site:
https://jakearchibald.github.io/svgomg/
which optimizies the svg and makes it a lot easier to work with
:return:
"""
doSvg = fname.endswith(".svg")
if hideHistograms:
# Hide the histogram data (and shrink the plot)
# to avoid confusing people
self.histAlpha.plot.hide()
self.histAlpha.vb.setMaximumWidth(20)
self.histGamma.plot.hide()
self.histGamma.vb.setMaximumWidth(20)
QtWidgets.QApplication.processEvents()
self.histGamma.axis.setRange(-46.75, 46.75)
self.histAlpha.axis.setRange(-94, 94)
width, height = self.width(), self.height()
if doSvg:
from PyQt5 import QtSvg
outputImage = QtSvg.QSvgGenerator()
outputImage.setFileName(fname)
outputImage.setSize(QtCore.QSize(int(width), int(height)))
# I'm not sure why it has to be this, but the axis on the histogrm
# were fuckingup without it
outputImage.setResolution(96)
else:
outputImage = QtGui.QImage(width * pngScale, height * pngScale,
QtGui.QImage.Format_ARGB32)
outputImage.setDevicePixelRatio(pngScale)
outputImage.fill(QtGui.QColor("white"))
outputPainter = QtGui.QPainter(outputImage)
self.render(outputPainter)
if not doSvg:
ret = outputImage.save(fname)
outputPainter.end()
def openFileIMG(self, img_file):
s = self.scene()
if self.backgroundItem:
drawBackground = self.backgroundItem.isVisible()
else:
drawBackground = True
if self.outlineItem:
drawOutline = self.outlineItem.isVisible()
else:
drawOutline = True
if self.TraceImage:
drawOutline = self.outlineItem.isVisible()
else:
drawOutline = True
s.clear()
img = QtGui.QPixmap(img_file)
self.TraceImage = QtWidgets.QGraphicsPixmapItem(img)
self.TraceImage.setFlags(QtWidgets.QGraphicsItem.ItemClipsToShape)
self.TraceImage.setCacheMode(QtWidgets.QGraphicsItem.NoCache)
self.TraceImage.setZValue(1)
effect = QtWidgets.QGraphicsOpacityEffect(self)
self.TraceImage.setGraphicsEffect(effect)
self.setOpacity(self.opacity)
self.TraceImage.setZValue(1)
self.svgItem = QtSvg.QGraphicsSvgItem()
self.svgItem.setFlags(QtWidgets.QGraphicsItem.ItemClipsToShape)
self.svgItem.setCacheMode(QtWidgets.QGraphicsItem.NoCache)
self.svgItem.setZValue(0)
self.backgroundItem = QtWidgets.QGraphicsRectItem(
self.TraceImage.boundingRect())
self.backgroundItem.setBrush(QtCore.Qt.white)
self.backgroundItem.setPen(QtGui.QPen(QtCore.Qt.NoPen))
self.backgroundItem.setVisible(drawBackground)
self.backgroundItem.setZValue(-1)
self.outlineItem = QtWidgets.QGraphicsRectItem(
self.TraceImage.boundingRect())
outline = QtGui.QPen(QtCore.Qt.darkGray, 1.5, QtCore.Qt.SolidLine)
outline.setCosmetic(True)
self.outlineItem.setPen(outline)
self.outlineItem.setBrush(QtGui.QBrush(QtCore.Qt.NoBrush))
self.outlineItem.setVisible(drawOutline)
self.outlineItem.setZValue(2)
s.addItem(self.backgroundItem)
s.addItem(self.svgItem)
s.addItem(self.TraceImage)
s.addItem(self.outlineItem)
s.setSceneRect(self.outlineItem.boundingRect().adjusted(
-10, -10, 10, 10))
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 __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 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, aPlayer1, aPlayer2):
self.player1 = aPlayer1
self.player2 = aPlayer2
self.game = ChessGame(aPlayer1, aPlayer2)
self.app = QApplication(sys.argv)
self.svgWidget = QtSvg.QSvgWidget()
self.svgWidget.setGeometry(50, 50, 400, 400)
self.svgWidget.show()
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 viewer(size, svg_path):
app = QApplication(sys.argv)
svg_widget = QtSvg.QSvgWidget(svg_path)
svg_widget.setGeometry(size[0], size[1], size[0] * 100, size[1] * 100)
# svg_widget.setGeometry(50, 50, 759, 668)
svg_widget.show()
sys.exit(app.exec_())