def actionEmbed(self):
"""Embed external image into veusz document."""
s = self.settings
if s.filename == '{embedded}':
print "Data already embedded"
return
# get data from external file
try:
f = open(s.filename, 'rb')
data = f.read()
f.close()
except EnvironmentError:
print "Could not find file. Not embedding."
return
# convert to base 64 to make it nicer in the saved file
encoded = str(qt4.QByteArray(data).toBase64())
# now put embedded data in hidden setting
ops = [
document.OperationSettingSet(s.get('filename'), '{embedded}'),
document.OperationSettingSet(s.get('embeddedImageData'), encoded)
]
self.document.applyOperation(
document.OperationMultiple(ops, descr=_('embed image')))
def generateDatasetsMime(datasets, document):
"""Generate mime for the list of dataset names given in the document.
Format is:
repr of names
text to recreate dataset 1
...
"""
mimedata = qt4.QMimeData()
# just plain text format
output = []
for name in datasets:
output.append(document.data[name].datasetAsText())
text = '\n'.join(output)
mimedata.setData('text/plain', qt4.QByteArray(text))
textfile = StringIO.StringIO()
for name in datasets:
# get unlinked copy of dataset
ds = document.data[name].returnCopy()
# write into a string file
ds.saveToFile(textfile, name)
mimedata.setData(datamime, textfile.getvalue())
return mimedata
def generateWidgetsMime(widgets):
"""Create mime data describing widget and children.
format is:
numberofwidgets
widgettype1
widgetname1
widgetpath1
numberoflines1
...
texttoreproducewidget
"""
header = [str(len(widgets))]
savetext = []
for widget in widgets:
header.append(widget.typename)
header.append(repr(widget.name))
header.append(repr(widget.path))
save = widget.getSaveText()
header.append(str(save.count('\n')))
savetext.append(save)
header.append('')
text = '\n'.join(header) + ''.join(savetext)
mimedata = qt4.QMimeData()
mimedata.setData(widgetmime, qt4.QByteArray(text))
return mimedata
def pixmapAsHtml(pix):
"""Get QPixmap as html image text."""
ba = qt4.QByteArray()
buf = qt4.QBuffer(ba)
buf.open(qt4.QIODevice.WriteOnly)
pix.toImage().save(buf, "PNG")
b64 = str(buf.data().toBase64())
return '<img src="data:image/png;base64,%s">' % b64
def exportBitmap(self, format):
"""Export to a bitmap format."""
# get size for bitmap's dpi
dpi = self.bitmapdpi
size = self.doc.pageSize(self.pagenumber, dpi=(dpi, dpi))
# create real output image
backqcolor = utils.extendedColorToQColor(self.backcolor)
if format == '.png':
# transparent output
image = qt4.QImage(size[0], size[1],
qt4.QImage.Format_ARGB32_Premultiplied)
else:
# non transparent output
image = qt4.QImage(size[0], size[1], qt4.QImage.Format_RGB32)
backqcolor.setAlpha(255)
image.setDotsPerMeterX(dpi * m_inch)
image.setDotsPerMeterY(dpi * m_inch)
if backqcolor.alpha() == 0:
image.fill(qt4.qRgba(0, 0, 0, 0))
else:
image.fill(backqcolor.rgb())
# paint to the image
painter = qt4.QPainter(image)
painter.setRenderHint(qt4.QPainter.Antialiasing, self.antialias)
painter.setRenderHint(qt4.QPainter.TextAntialiasing, self.antialias)
self.renderPage(size, (dpi, dpi), painter)
# write image to disk
writer = qt4.QImageWriter()
# format below takes extension without dot
writer.setFormat(qt4.QByteArray(format[1:]))
writer.setFileName(self.filename)
if format == 'png':
# min quality for png as it makes no difference to output
# and makes file size smaller
writer.setQuality(0)
else:
writer.setQuality(self.quality)
writer.write(image)
def drawPixmap(self, r, pixmap, sr):
"""Draw pixmap svg item.
This is converted to a bitmap and embedded in the output
"""
# convert pixmap to textual data
data = qt4.QByteArray()
buf = qt4.QBuffer(data)
buf.open(qt4.QBuffer.ReadWrite)
pixmap.save(buf, self.imageformat.upper(), 0)
buf.close()
attrb = [
'x="%s" y="%s" ' % (fltStr(r.x() * scale), fltStr(r.y() * scale)),
'width="%s" ' % fltStr(r.width() * scale),
'height="%s" ' % fltStr(r.height() * scale),
'xlink:href="data:image/%s;base64,' % self.imageformat,
str(data.toBase64()), '" preserveAspectRatio="none"'
]
SVGElement(self.celement, 'image', ''.join(attrb))
def drawPixmap(self, r, pixmap, sr):
"""Draw pixmap to display."""
# convert pixmap to BMP format
bytes = qt4.QByteArray()
buffer = qt4.QBuffer(bytes)
buffer.open(qt4.QIODevice.WriteOnly)
pixmap.save(buffer, "BMP")
# chop off bmp header to get DIB
bmp = str(buffer.data())
dib = bmp[0xe:]
hdrsize, = struct.unpack('<i', bmp[0xe:0x12])
dataindex, = struct.unpack('<i', bmp[0xa:0xe])
datasize, = struct.unpack('<i', bmp[0x22:0x26])
epix = pyemf._EMR._STRETCHDIBITS()
epix.rclBounds_left = r.left() * scale
epix.rclBounds_top = r.top() * scale
epix.rclBounds_right = r.right() * scale
epix.rclBounds_bottom = r.bottom() * scale
epix.xDest = r.left() * scale
epix.yDest = r.top() * scale
epix.cxDest = r.width() * scale
epix.cyDest = r.height() * scale
epix.xSrc = sr.left()
epix.ySrc = sr.top()
epix.cxSrc = sr.width()
epix.cySrc = sr.height()
epix.dwRop = 0xcc0020 # SRCCOPY
epix.offBmiSrc = epix.serializeOffset()
epix.cbBmiSrc = hdrsize
epix.offBitsSrc = epix.serializeOffset() + dataindex - 0xe
epix.cbBitsSrc = datasize
epix.iUsageSrc = 0x0 # DIB_RGB_COLORS
epix.unhandleddata = dib
self.emf._append(epix)