def testVoidPtr(self):
# Creating a VoidPtr object requires an address of
# a C++ object, a wrapped Shiboken Object type,
# an object implementing the Python Buffer interface,
# or another VoidPtr object.
# Original content
b = b"Hello world"
ba = QByteArray(b)
vp = VoidPtr(ba, ba.size())
self.assertIsInstance(vp, shiboken.VoidPtr)
# Create QByteArray from voidptr byte interpretation
nba = QByteArray.fromRawData(vp.toBytes())
# Compare original bytes to toBytes()
self.assertTrue(b, vp.toBytes())
# Compare original with new QByteArray data
self.assertTrue(b, nba.data())
# Convert original and new to str
self.assertTrue(str(b), str(nba))
# Modify nba through a memoryview of vp
mv = memoryview(vp)
self.assertFalse(mv.readonly)
mv[6:11] = b'void*'
self.assertEqual(str(ba), str(b"Hello void*"))
def get_thumbNail(self, f, thumbname='thumbnailimage'):
"""
Extract the (jpg) thumbnail from an image or sidecar file
and returns it as a QImage.
@param f: path to image or sidecar file
@type f: str
@param thumbname: tag name
@type thumbname: str
@return: thumbnail
@rtype: QImage
"""
thumbnail = self.readBinaryData(f, tagname=thumbname)
return QImage.fromData(QByteArray.fromRawData(thumbnail), 'JPG')
def retrieveData(self, mime_type, var_type):
logger.debug("retrieveData(%r, %r)", mime_type, var_type)
if mime_type not in self.formats():
logger.debug("unsupported type requested")
return None
if mime_type == "application/x-sampledrawer-lib-items":
result = []
for item in self._items:
result.append({
"name": item.name,
"md5": item.md5,
"path": item.path
})
return json.dumps(result)
paths = self._paths
if paths is None:
paths = []
for item in self._items:
path = self._app.library.get_pretty_path(item, timeout=60)
paths.append(path)
self._paths = paths
if mime_type == "text/plain":
return " ".join(paths)
elif mime_type == "text/uri-list":
uris = []
for path in paths:
uri = urlunsplit(("file", "localhost", path, None, None))
uris.append(uri.encode("utf-8"))
# text/uri-list is defined to use CR LF line endings
return QByteArray.fromRawData(b"\r\n".join(uris) + b"\r\n")
else:
path = paths[0]
with open(path, "rb") as data_f:
data = data_f.read()
return QByteArray.fromRawData(data)
def push_data(self):
logger.debug("push_data() start")
if not self.output_dev:
logger.debug("no output device")
return
frame_size = self.output.format().bytesPerFrame()
while True:
logger.debug("push_data...")
buf = self.current_buffer
if buf is not None:
length = buf.byteCount()
else:
length = 0
if buf is None or self.current_buffer_pos >= length:
if not self.decoder.bufferAvailable():
logger.debug("No buffer available")
break
buf = self.decoder.read()
logger.debug("New buffer acquired: %r", buf)
length = buf.byteCount()
self.current_buffer = buf
self.current_buffer_pos = 0
data = buf.constData()
logger.debug("data: 0x%016X, length: %i", int(data), length)
data_ptr = ffi.cast("void *", int(data))
data_bytes = ffi.buffer(data_ptr, length)[self.current_buffer_pos:]
to_write = len(data_bytes)
data_arr = QByteArray.fromRawData(data_bytes)
bytes_written = self.output_dev.write(data_arr)
if bytes_written > frame_size:
self.last_frame = data_arr[bytes_written -
frame_size:bytes_written].data()
logger.debug("Last frame: %r", self.last_frame)
self.current_buffer_pos += bytes_written
self.bytes_written = bytes_written
logger.debug("%i of %i bytes written, pos: %i", bytes_written,
to_write, self.current_buffer_pos)
if self.current_buffer_pos >= length:
self.current_buffer = None
if bytes_written < to_write:
break
def clientSend(self, data):
bytesArray = bytes(data, 'utf-8')
message = QByteArray.fromRawData(bytesArray)
self.tcpClientSocket.write(message)
self.tcpClientSocket.flush()
return
def testIt(self):
data = py3k.b("foobar")
a = QByteArray.fromRawData(data)
self.assertEqual(type(a), QByteArray)
self.assertEqual(a.data(), data)
def testIt(self):
data = py3k.b("foobar")
a = QByteArray.fromRawData(data)
self.assertEqual(type(a), QByteArray)
self.assertEqual(a.data(), data)
