def __init__(self, main_view):
super().__init__()
self.board_svg = QSvgRenderer("assets/boards/blue.svg")
self.main_view = main_view
self.board = chess.Board()
self.piece_images = {}
self.ranks = "87654321"
self.files = "abcdefgh"
self.move = WHITE
self.board_size = 0
self.tile_size = 0
self.selected = None
self.engine_handler = EngineHandler(self)
self.best_move = None
self.show_best_move = True
self.move_history = []
self.arrows = []
self.dragging = False
self.dragX = 0
self.dragY = 0
for c in "QRPBNK":
self.piece_images[WHITE + c] = QSvgRenderer("assets/pieces/w" + c +
".svg")
self.piece_images[BLACK + c] = QSvgRenderer("assets/pieces/b" + c +
".svg")
def init(self):
self.m_backgroundRenderer = QSvgRenderer("images/"+self.m_skin+"/background.svg", self)
self.m_needleShadowRenderer = QSvgRenderer("images/"+self.m_skin+"/needle_shadow.svg", self)
self.m_needleRenderer = QSvgRenderer("images/"+self.m_skin+"/needle.svg", self)
self.m_overlayRenderer = QSvgRenderer("images/"+self.m_skin+"/overlay.svg", self)
self.updateGeometry()
self.update()
def get_png_image( input_svg_file, newWidth = None, verify = True ):
assert( os.path.basename( input_svg_file ).endswith( '.svg' ) or
os.path.basename( input_svg_file ).endswith( '.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' ) }
else:
r = QSvgRenderer( input_svg_file )
files = { 'file' : open( input_svg_file, 'rb' ) }
width = r.defaultSize().width()
height = r.defaultSize().height()
apiKey = get_cloudconvert_api_key( )
params = { 'apikey' : apiKey,
'input' : 'upload',
'inputformat' : 'svg',
'outputformat' : 'png',
}
if newWidth is not None:
assert( isinstance( newWidth, int ) )
assert( newWidth > 10 )
newHeight = int( height * 1.0 * newWidth / width )
params['converteroptions[resize]'] = '%dx%d' % ( newWidth, newHeight )
#
##
response = requests.post( "https://api.cloudconvert.com/convert", params = params,
files = files, verify = verify )
if response.status_code != 200:
raise ValueError("Error, could not upload and convert SVG file %s." % input_svg_file )
img = Image.open( StringIO( response.content ) )
return img
def __init__(self, player, visible, parent = None): super(BoardView, self).__init__(parent) self.player = player self.visible = visible self.panel = QSvgRenderer(self.PANEL, self) self.hit = QSvgRenderer(self.HIT, self) self.miss = QSvgRenderer(self.MISS, self) self.ship = [QSvgRenderer(filename, self) for filename in self.SHIPS] self.moving, self.x0, self.y0, self.dx, self.dy = None, 0, 0, 0, 0
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, 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 rasterize_svg(self, elem, width=0, height=0, format='PNG'):
view_box = elem.get('viewBox', elem.get('viewbox', None))
sizes = None
logger = self.oeb.logger
if view_box is not None:
try:
box = [
float(x) for x in filter(None, re.split('[, ]', view_box))
]
sizes = [box[2] - box[0], box[3] - box[1]]
except (TypeError, ValueError, IndexError):
logger.warn(
'SVG image has invalid viewBox="%s", ignoring the viewBox'
% view_box)
else:
for image in elem.xpath(
'descendant::*[local-name()="image" and '
'@height and contains(@height, "%")]'):
logger.info(
'Found SVG image height in %, trying to convert...')
try:
h = float(image.get('height').replace('%', '')) / 100.
image.set('height', str(h * sizes[1]))
except:
logger.exception(
'Failed to convert percentage height:',
image.get('height'))
data = QByteArray(xml2str(elem, with_tail=False))
svg = QSvgRenderer(data)
size = svg.defaultSize()
if size.width() == 100 and size.height() == 100 and sizes:
size.setWidth(sizes[0])
size.setHeight(sizes[1])
if width or height:
size.scale(width, height, Qt.KeepAspectRatio)
logger.info('Rasterizing %r to %dx%d' %
(elem, size.width(), size.height()))
image = QImage(size, QImage.Format_ARGB32_Premultiplied)
image.fill(QColor("white").rgb())
painter = QPainter(image)
svg.render(painter)
painter.end()
array = QByteArray()
buffer = QBuffer(array)
buffer.open(QIODevice.WriteOnly)
image.save(buffer, format)
return str(array)
def __init__(self, parent):
self._descriptionWidgets = []
self._descriptionActiveRects = [
QRect(), QRect(), QRect()
] # descriptions will be visible if mouse cursor is in the rect
VispaWidget.__init__(self, parent)
self._filenewIcon = QIcon(QPixmap(":/resources/filenew.svg"))
self._fileopenIcon = QIcon(QPixmap(":/resources/fileopen.svg"))
self.setImage(
QSvgRenderer(":/resources/startup_development_cycle.svg"))
self.setDragable(False)
self.setMouseTracking(
True) # receive mouse events even if no button is pressed
self._hideDescriptions = False
self.createPrototypingWidget()
self.createExecutionWidget()
self.createVerifyingWidget()
def paintEvent(self, e):
"""This event handler is reimplemented in this subclass to receive
paint events passed in event. A paint event is a request to repaint all
or part of a widget. It can happen for one of the following reasons:
repaint() or update() was invoked,the widget was obscured and has
now been uncovered, or many other reasons. """
qp = QPainter()
qp.begin(self)
# if no steos have been receive draw last_diagram_bytes
if not self.steps and self.last_diagram_bytes:
diagram_bytes = self.last_diagram_bytes
else:
diagram = self.build_graph()
diagram_bytes = diagram.pipe('svg')
self.last_diagram_bytes = diagram_bytes
svg = QSvgRenderer(diagram_bytes)
svg.render(qp)
qp.end()
def _get_composer_svg_image(self, width, height, dpi):
# from qgscomposer.cpp, QgsComposer::on_mActionExportAsSVG_triggered,
# near end of function
svgpath = getTempfilePath('svg')
temp_size = os.path.getsize(svgpath)
svg_g = QSvgGenerator()
# noinspection PyArgumentList
svg_g.setTitle(QgsProject.instance().title())
svg_g.setFileName(svgpath)
svg_g.setSize(QSize(width, height))
svg_g.setViewBox(QRect(0, 0, width, height))
svg_g.setResolution(dpi)
sp = QPainter(svg_g)
self._c.renderPage(sp, 0)
sp.end()
if temp_size == os.path.getsize(svgpath):
return False, ''
image = QImage(width, height,
self._TestMapSettings.outputImageFormat())
image.fill(QColor(152, 219, 249).rgb())
image.setDotsPerMeterX(dpi / 25.4 * 1000)
image.setDotsPerMeterY(dpi / 25.4 * 1000)
svgr = QSvgRenderer(svgpath)
p = QPainter(image)
p.setRenderHint(
QPainter.Antialiasing,
self._TestMapSettings.testFlag(QgsMapSettings.Antialiasing))
p.setRenderHint(QPainter.TextAntialiasing)
svgr.render(p)
p.end()
filepath = getTempfilePath('png')
res = image.save(filepath, 'png')
if not res:
os.unlink(filepath)
filepath = ''
# TODO: remove .svg file as well?
return res, filepath
def rasterize_external(self, elem, style, item, svgitem):
width = style['width']
height = style['height']
width = (width / 72) * self.profile.dpi
height = (height / 72) * self.profile.dpi
data = QByteArray(str(svgitem))
svg = QSvgRenderer(data)
size = svg.defaultSize()
size.scale(width, height, Qt.KeepAspectRatio)
key = (svgitem.href, size.width(), size.height())
if key in self.images:
href = self.images[key]
else:
logger = self.oeb.logger
logger.info('Rasterizing %r to %dx%d' %
(svgitem.href, size.width(), size.height()))
image = QImage(size, QImage.Format_ARGB32_Premultiplied)
image.fill(QColor("white").rgb())
painter = QPainter(image)
svg.render(painter)
painter.end()
array = QByteArray()
buffer = QBuffer(array)
buffer.open(QIODevice.WriteOnly)
image.save(buffer, 'PNG')
data = str(array)
manifest = self.oeb.manifest
href = os.path.splitext(svgitem.href)[0] + '.png'
id, href = manifest.generate(svgitem.id, href)
manifest.add(id, href, PNG_MIME, data=data)
self.images[key] = href
elem.tag = XHTML('img')
for attr in elem.attrib:
if attr not in KEEP_ATTRS:
del elem.attrib[attr]
elem.attrib['src'] = item.relhref(href)
if elem.text:
elem.attrib['alt'] = elem.text
elem.text = None
for child in elem:
elem.remove(child)
def qt_svg_to_png_renderer(impact_report, component):
"""Render SVG into PNG.
:param impact_report: ImpactReport contains data about the report that is
going to be generated.
:type impact_report: safe.report.impact_report.ImpactReport
:param component: Contains the component metadata and context for
rendering the output.
:type component:
safe.report.report_metadata.QgisComposerComponentsMetadata
:return: Whatever type of output the component should be.
.. versionadded:: 4.0
"""
context = component.context
filepath = context['filepath']
width = component.extra_args['width']
height = component.extra_args['height']
image_format = QImage.Format_ARGB32
qimage = QImage(width, height, image_format)
qimage.fill(0x00000000)
renderer = QSvgRenderer(filepath)
painter = QPainter(qimage)
renderer.render(painter)
# Should call painter.end() so that QImage is not used
painter.end()
# in case output folder not specified
if impact_report.output_folder is None:
impact_report.output_folder = mkdtemp(dir=temp_dir())
output_path = impact_report.component_absolute_output_path(
component.key)
qimage.save(output_path)
component.output = output_path
return component.output
def renderer(self):
"""initialise the svg renderer with the selected svg file"""
if self.__renderer is None:
self.__renderer = QSvgRenderer(self.__graphicspath)
if not self.__renderer.isValid():
logException(TileException( \
m18n('file <filename>%1</filename> contains no valid SVG'), self.__graphicspath))
distance = 0
if self.desktopFileName == 'classic':
distance = 2
distanceSize = QSizeF(distance, distance)
self.faceSize = self.__renderer.boundsOnElement('BAMBOO_1').size()+distanceSize
self.tileSize = self.__renderer.boundsOnElement('TILE_2').size()+distanceSize
if not Internal.scaleScene:
self.faceSize /= 2
self.tileSize /= 2
shW = self.shadowWidth()
shH = self.shadowHeight()
self.__shadowOffsets = [[(-shW, 0), (0, 0), (0, shH), (-shH, shW)],
[(0, 0), (shH, 0), (shW, shH), (0, shW)],
[(0, -shH), (shH, -shW), (shW, 0), (0, 0)],
[(-shW, -shH), (0, -shW), (0, 0), (-shH, 0)]]
return self.__renderer
def save_png(filename, sc, background=(255, 255, 255, 0)):
"""Create a png image from a scene
:Parameters:
- `filename` (str) - name to write the image
- `sc` (SVGScene)
- `background` (int, int, int, int) - background color
as (R, G, B, alpha) 0-255 tuple
"""
qapp = QApplication.instance()
if qapp is None:
qapp = QApplication([])
r = QSvgRenderer(None)
data = QByteArray(str(to_xml(sc)))
r.load(data)
pix = QPixmap(r.defaultSize())
pix.fill(QColor(*background))
painter = QPainter(pix)
r.render(painter)
painter.end()
pix.save(filename)
def pixmap(self, size):
"""returns a background pixmap or None for isPlain"""
self.__pmap = None
if not self.isPlain:
width = size.width()
height = size.height()
if self.tiled:
width = self.imageWidth
height = self.imageHeight
cachekey = QString("%1W%2H%3") \
.arg(self.name).arg(width).arg(height)
self.__pmap = QPixmapCache.find(cachekey)
if not self.__pmap:
renderer = QSvgRenderer(self.__graphicspath)
if not renderer.isValid():
logException(BackgroundException( \
m18n('file <filename>%1</filename> contains no valid SVG', self.__graphicspath)))
self.__pmap = QPixmap(width, height)
self.__pmap.fill(Qt.transparent)
painter = QPainter(self.__pmap)
renderer.render(painter)
QPixmapCache.insert(cachekey, self.__pmap)
return self.__pmap
def __init__(self, canvas):
QgsMapCanvasItem.__init__(self, canvas)
self.canvas = canvas
self.size = 24
self.map_pos = QgsPoint(0.0, 0.0)
self.svgrender = QSvgRenderer(":/icons/gps_marker")
def __init__(self, dataDir="", parent=None):
QWidget.__init__(self, parent)
self.renderer = QSvgRenderer(dataDir + "poker.svg")
self.scene = QGraphicsScene()
self.chat = QGraphicsSimpleTextItem()
self.table = QGraphicsSvgItem(dataDir + "poker.svg")
self.table.setSharedRenderer(self.renderer)
self.table.setElementId("table")
self.table.setMatrix(self.renderer.matrixForElement("transform_table"))
self.scene.addItem(self.chat)
self.scene.addItem(self.table)
self.board = []
for i in range(5):
card = AnimatedGraphicsSvgItem(dataDir + "svg-cards.svg",
self.table)
card.setElementId("back")
parent = self.renderer.matrixForElement("transform_table")
child = self.renderer.matrixForElement("transform_card%i" % i)
cardMatrix = child.translate(-parent.dx(), -parent.dy())
card.setMatrix(cardMatrix)
#card.setFlag(QGraphicsSvgItem.ItemIsMovable, True)
card.scale(0.5, 0.5)
card.hide()
self.scene.addItem(card)
self.board.append(card)
self.seats = []
self.names = []
self.moneys = []
self.bets = []
for i in range(10):
seat = SeatItem()
def seatClickedEvent(seat=i):
seatClickedCallback = self.seatClicked
seatClickedCallback(seat)
seat.event = seatClickedEvent
seat.setSharedRenderer(self.renderer)
seat.setElementId("seat")
seat.setMatrix(
self.renderer.matrixForElement("transform_seat%i" % i))
self.scene.addItem(seat)
self.seats.append(seat)
name = QGraphicsSimpleTextItem(seat)
name.setMatrix(self.renderer.matrixForElement("seat_name"))
self.scene.addItem(name)
self.names.append(name)
money = QGraphicsSimpleTextItem(seat)
money.setMatrix(self.renderer.matrixForElement("seat_money"))
self.scene.addItem(money)
self.moneys.append(money)
bet = QGraphicsSimpleTextItem()
bet.setMatrix(self.renderer.matrixForElement("transform_bet%i" %
i))
self.scene.addItem(bet)
self.bets.append(bet)
self.pots = []
for i in range(9):
pot = QGraphicsSimpleTextItem()
pot.setMatrix(self.renderer.matrixForElement("transform_pot%i" %
i))
self.scene.addItem(pot)
self.pots.append(pot)
self.view = QGraphicsView(self)
self.view.setScene(self.scene)
self.view.resize(800, 600)
self.fold = ActionItem()
self.fold.setText("fold")
self.fold.setPos(0, 550)
self.scene.addItem(self.fold)
self.fold.event = lambda: self.foldClicked()
self.check = ActionItem()
self.check.setText("check")
self.check.setPos(50, 550)
self.scene.addItem(self.check)
self.check.event = lambda: self.checkClicked()
self.call = ActionItem()
self.call.setText("call")
self.call.setPos(100, 550)
self.scene.addItem(self.call)
self.call.event = lambda: self.callClicked()
self.bet = ActionItem()
self.bet.setText("bet")
self.bet.setPos(150, 550)
self.scene.addItem(self.bet)
self.bet.event = lambda: self.betClicked()
