void VCProperties_Test::loadXMLInput()
{
QBuffer buffer;
buffer.open(QIODevice::ReadWrite | QIODevice::Text);
QXmlStreamWriter xmlWriter(&buffer);
xmlWriter.writeStartElement("Input");
xmlWriter.writeAttribute("Universe", "3");
xmlWriter.writeAttribute("Channel", "78");
xmlWriter.writeEndElement();
xmlWriter.writeEndDocument();
xmlWriter.setDevice(NULL);
buffer.seek(0);
QXmlStreamReader xmlReader(&buffer);
xmlReader.readNextStartElement();
quint32 universe = 0;
quint32 channel = 0;
QVERIFY(VCProperties::loadXMLInput(xmlReader, &universe, &channel) == true);
QCOMPARE(universe, quint32(3));
QCOMPARE(channel, quint32(78));
buffer.close();
QByteArray bData = buffer.data();
bData.replace("<Input", "<Inputt");
buffer.setData(bData);
buffer.open(QIODevice::ReadOnly | QIODevice::Text);
buffer.seek(0);
xmlReader.setDevice(&buffer);
xmlReader.readNextStartElement();
universe = channel = 0;
QVERIFY(VCProperties::loadXMLInput(xmlReader, &universe, &channel) == false);
QCOMPARE(universe, quint32(0));
QCOMPARE(channel, quint32(0));
QBuffer buffer2;
buffer2.open(QIODevice::ReadWrite | QIODevice::Text);
xmlWriter.setDevice(&buffer2);
xmlWriter.writeStartElement("Input");
xmlWriter.writeEndElement();
xmlWriter.writeEndDocument();
xmlWriter.setDevice(NULL);
buffer2.seek(0);
xmlReader.setDevice(&buffer2);
xmlReader.readNextStartElement();
universe = channel = 0;
QVERIFY(VCProperties::loadXMLInput(xmlReader, &universe, &channel) == false);
QCOMPARE(universe, InputOutputMap::invalidUniverse());
QCOMPARE(channel, QLCChannel::invalid());
}
bool QSvgIOHandlerPrivate::load(QIODevice *device)
{
if (loaded)
return true;
if (q->format().isEmpty())
q->canRead();
// # The SVG renderer doesn't handle trailing, unrelated data, so we must
// assume that all available data in the device is to be read.
bool res = false;
QBuffer *buf = qobject_cast<QBuffer *>(device);
if (buf) {
const QByteArray &ba = buf->data();
res = r.load(QByteArray::fromRawData(ba.constData() + buf->pos(), ba.size() - buf->pos()));
buf->seek(ba.size());
} else if (q->format() == "svgz") {
res = r.load(device->readAll());
} else {
xmlReader.setDevice(device);
res = r.load(&xmlReader);
}
if (res) {
defaultSize = QSize(r.viewBox().width(), r.viewBox().height());
loaded = true;
}
return loaded;
}
void VCProperties_Test::loadXMLSad()
{
QBuffer buffer;
buffer.open(QIODevice::ReadWrite | QIODevice::Text);
QXmlStreamWriter xmlWriter(&buffer);
xmlWriter.writeStartElement("VirtualConsole");
xmlWriter.writeStartElement("Properties");
xmlWriter.writeEndElement();
xmlWriter.writeStartElement("Frame");
xmlWriter.writeEndElement();
xmlWriter.writeStartElement("Foo");
xmlWriter.writeEndElement();
xmlWriter.writeEndDocument();
xmlWriter.setDevice(NULL);
buffer.seek(0);
QXmlStreamReader xmlReader(&buffer);
xmlReader.readNextStartElement();
VCProperties p;
QVERIFY(p.loadXML(xmlReader) == false);
}
QVariant QJson::parse(const QByteArray& jsonString, bool* ok) {
QBuffer buffer;
buffer.open(QBuffer::ReadWrite);
buffer.write(jsonString);
buffer.seek(0);
return parse (&buffer, ok);
}
void TestScanner::scanTokens() {
QFETCH(QByteArray, input);
QFETCH(bool, allowSpecialNumbers);
QFETCH(bool, skipFirstToken);
QFETCH(int, expectedResult);
QFETCH(QVariant, expectedYylval);
QFETCH(int, expectedLocationBeginLine);
QFETCH(int, expectedLocationBeginColumn);
QFETCH(int, expectedLocationEndLine);
QFETCH(int, expectedLocationEndColumn);
QBuffer buffer;
buffer.open(QBuffer::ReadWrite);
buffer.write(input);
buffer.seek(0);
JSonScanner scanner(&buffer);
scanner.allowSpecialNumbers(allowSpecialNumbers);
QVariant yylval;
yy::position position(YY_NULL, 1, 0);
yy::location location(position, position);
int result = scanner.yylex(&yylval, &location);
if (skipFirstToken) {
result = scanner.yylex(&yylval, &location);
}
QCOMPARE(result, expectedResult);
QCOMPARE(yylval, expectedYylval);
QCOMPARE(location.begin.line, (uint)expectedLocationBeginLine);
QCOMPARE(location.begin.column, (uint)expectedLocationBeginColumn);
QCOMPARE(location.end.line, (uint)expectedLocationEndLine);
QCOMPARE(location.end.column, (uint)expectedLocationEndColumn);
}
void TestKeePass1Reader::reopenDatabase(Database* db, const QString& password, const QString& keyfileName)
{
QBuffer buffer;
buffer.open(QIODevice::ReadWrite);
KeePass2Writer writer;
writer.writeDatabase(&buffer, db);
QVERIFY(!writer.hasError());
QVERIFY(buffer.seek(0));
CompositeKey key;
if (!password.isNull()) {
key.addKey(PasswordKey(password));
}
if (!keyfileName.isEmpty()) {
FileKey fileKey;
QVERIFY(fileKey.load(keyfileName));
key.addKey(fileKey);
}
KeePass2Reader reader;
Database* newDb = reader.readDatabase(&buffer, key);
QVERIFY(newDb);
QVERIFY(!reader.hasError());
delete newDb;
}
void MT_CntVersitMyCardPlugin::importContact()
{
//import
QBuffer input;
input.open(QBuffer::ReadWrite);
QByteArray inputVCard =
"BEGIN:VCARD\r\nVERSION:2.1\r\nFN:John\r\nEND:VCARD\r\n";
input.write(inputVCard);
input.seek(0);
QVersitReader reader;
reader.setDevice(&input);
reader.startReading();
reader.waitForFinished();
// Use the resulting document(s)...
QVersitContactImporter importer;
QList<QVersitDocument> versitDocuments = reader.results();
importer.importDocuments(versitDocuments);
QList<QContact> contacts = importer.contacts();
QVERIFY(1 == contacts.count());
// Check if MyCard detail is found
QList<QContactDetail> details = contacts.first().details(MYCARD_DEFINTION_NAME);
QVERIFY(details.count()==0);
}
Map* FileFormatTest::saveAndLoadMap(Map* input, const FileFormat* format)
{
try {
QBuffer buffer;
buffer.open(QIODevice::ReadWrite);
Exporter* exporter = format->createExporter(&buffer, input, NULL);
if (!exporter)
return NULL;
exporter->doExport();
delete exporter;
buffer.seek(0);
Map* out = new Map;
Importer* importer = format->createImporter(&buffer, out, NULL);
if (!importer)
return NULL;
importer->doImport(false);
importer->finishImport();
delete importer;
buffer.close();
return out;
}
catch (std::exception& e)
{
return NULL;
}
}
void sendDataToDev2(const QByteArray& data) {
qint64 pos = mDevice2.pos();
mDevice2.write(data);
mDevice2.seek(pos);
// Return to qt event loop to allow it process asincronious signals
QTest::qWait(1);
}
void flacStreamEncoderMetadataCallback( const FLAC__StreamEncoder *,
const FLAC__StreamMetadata * _metadata,
void * _client_data )
{
QBuffer * b = static_cast<QBuffer *>( _client_data );
b->seek( 0 );
b->write( (const char *) _metadata, sizeof( *_metadata ) );
}
/*!
Registers the SDP service record \a record for this Bluetooth service
and returns the service record handle of the newly registered service.
Returns zero if the registration failed.
\sa unregisterRecord()
*/
quint32 QBluetoothAbstractService::registerRecord(const QBluetoothSdpRecord &record)
{
QBuffer buffer;
buffer.open(QIODevice::ReadWrite);
QSdpXmlGenerator::generate(record, &buffer);
buffer.seek(0);
return m_data->registerRecord(QString::fromUtf8(buffer.readAll()));
}
qint64 Request::writeData(const char* data, qint64 maxSize)
{
if(m_responseState == WaitingForResponseHeaders)
{
m_headerBuffer.append(data, maxSize);
// We need to buffer the headers, so we can use the STATUS header appropriately
QBuffer buffer;
buffer.setData(m_headerBuffer);
buffer.open(QIODevice::ReadOnly);
buffer.seek(m_headerBufferPosition);
while(buffer.canReadLine())
{
const QByteArray line = buffer.readLine().trimmed();
if(line.isEmpty())
{
Q_ASSERT(m_responseHeaders.contains("STATUS"));
Q_ASSERT(m_requestHeaders.contains("SERVER_PROTOCOL"));
m_responseState = WaitingForResponseBody;
const QByteArray status = m_responseHeaders.take("STATUS");
m_socket->write(m_requestHeaders.value("SERVER_PROTOCOL"));
m_socket->write(" ", 1);
m_socket->write(status);
m_socket->write("\r\n", 2);
//qDebug() << Q_FUNC_INFO << m_requestHeaders << m_responseHeaders;
for(
HeaderMap::ConstIterator it = m_responseHeaders.constBegin();
it != m_responseHeaders.constEnd();
++it
)
{
m_socket->write(it.key());
m_socket->write(": ");
m_socket->write(it.value());
m_socket->write("\r\n");
}
m_socket->write("\r\n");
m_socket->write(buffer.readAll());
buffer.close();
m_headerBuffer.clear();
return maxSize;
}
const int lengthOfName = line.indexOf(':');
const QByteArray name = line.left(lengthOfName);
const QByteArray value = line.mid(lengthOfName + 2); // ": " after the name == 2 chars
m_responseHeaders.insertMulti(name, value);
}
m_headerBufferPosition = buffer.pos();
buffer.close();
return maxSize;
}
Q_ASSERT(m_responseState == WaitingForResponseBody);
return m_socket->write(data, maxSize);
}
void TSoundOutputDeviceImp::play(const TSoundTrackP &st, TINT32 s0, TINT32 s1,
bool loop, bool scrubbing) {
if (!doSetStreamFormat(st->getFormat())) return;
MyData *myData = new MyData();
myData->imp = shared_from_this();
myData->totalPacketCount = s1 - s0;
myData->fileByteCount = (s1 - s0) * st->getSampleSize();
myData->entireFileBuffer = new char[myData->fileByteCount];
memcpy(myData->entireFileBuffer, st->getRawData() + s0 * st->getSampleSize(),
myData->fileByteCount);
m_isPlaying = true;
myData->isLooping = loop;
QAudioFormat format;
QAudioDeviceInfo info(QAudioDeviceInfo::defaultOutputDevice());
format.setSampleSize(st->getBitPerSample());
format.setCodec("audio/pcm");
format.setChannelCount(st->getChannelCount());
format.setByteOrder(QAudioFormat::LittleEndian);
format.setSampleType(st->getFormat().m_signedSample
? QAudioFormat::SignedInt
: QAudioFormat::UnSignedInt);
format.setSampleRate(st->getSampleRate());
QList<QAudioFormat::Endian> sbos = info.supportedByteOrders();
QList<int> sccs = info.supportedChannelCounts();
QList<int> ssrs = info.supportedSampleRates();
QList<QAudioFormat::SampleType> sstypes = info.supportedSampleTypes();
QList<int> ssss = info.supportedSampleSizes();
QStringList supCodes = info.supportedCodecs();
if (!info.isFormatSupported((format))) {
format = info.nearestFormat(format);
int newChannels = format.channelCount();
int newBitsPerSample = format.sampleSize();
int newSampleRate = format.sampleRate();
QAudioFormat::SampleType newSampleType = format.sampleType();
QAudioFormat::Endian newBo = format.byteOrder();
}
int test = st->getSampleCount() / st->getSampleRate();
QByteArray *data =
new QByteArray(myData->entireFileBuffer, myData->fileByteCount);
QBuffer *newBuffer = new QBuffer;
newBuffer->setBuffer(data);
newBuffer->open(QIODevice::ReadOnly);
newBuffer->seek(0);
if (m_audioOutput == NULL) {
m_audioOutput = new QAudioOutput(format, NULL);
}
m_audioOutput->start(newBuffer);
m_audioOutput->setVolume(m_volume);
}
void TestScanner::scanSpecialNumbers() {
QFETCH(QByteArray, input);
QFETCH(bool, isInfinity);
QFETCH(bool, isNegative);
QFETCH(bool, isNan);
QFETCH(int, expectedLocationBeginLine);
QFETCH(int, expectedLocationBeginColumn);
QFETCH(int, expectedLocationEndLine);
QFETCH(int, expectedLocationEndColumn);
QBuffer buffer;
buffer.open(QBuffer::ReadWrite);
buffer.write(input);
buffer.seek(0);
JSonScanner scanner(&buffer);
scanner.allowSpecialNumbers(true);
QVariant yylval;
yy::position position(YY_NULL, 1, 0);
yy::location location(position, position);
int result = scanner.yylex(&yylval, &location);
QCOMPARE(result, TOKEN(NUMBER));
QVERIFY(yylval.type() == QVariant::Double);
double doubleResult = yylval.toDouble();
#if defined(Q_OS_SYMBIAN) || defined(Q_OS_ANDROID) || defined(Q_OS_BLACKBERRY)
QCOMPARE(bool(isinf(doubleResult)), isInfinity);
#else
// skip this test for MSVC, because there is no "isinf" function.
#ifndef Q_CC_MSVC
QCOMPARE(bool(std::isinf(doubleResult)), isInfinity);
#endif
#endif
QCOMPARE(doubleResult<0, isNegative);
#if defined(Q_OS_SYMBIAN) || defined(Q_OS_ANDROID) || defined(Q_OS_BLACKBERRY)
QCOMPARE(bool(isnan(doubleResult)), isNan);
#else
// skip this test for MSVC, because there is no "isinf" function.
#ifndef Q_CC_MSVC
QCOMPARE(bool(std::isnan(doubleResult)), isNan);
#endif
#endif
QCOMPARE(location.begin.line, (uint)expectedLocationBeginLine);
QCOMPARE(location.begin.column, (uint)expectedLocationBeginColumn);
QCOMPARE(location.end.line, (uint)expectedLocationEndLine);
QCOMPARE(location.end.column, (uint)expectedLocationEndColumn);
}
void completeExample()
{
// Create the input vCard
//! [Complete example - create]
QBuffer input;
input.open(QBuffer::ReadWrite);
QByteArray inputVCard =
"BEGIN:VCARD\r\nVERSION:2.1\r\nFN:John Citizen\r\nN:Citizen;John;Q;;\r\nEND:VCARD\r\n";
input.write(inputVCard);
input.seek(0);
//! [Complete example - create]
// Parse the input into QVersitDocuments
//! [Complete example - read]
// Note: we could also use the more convenient QVersitReader(QByteArray) constructor.
QVersitReader reader;
reader.setDevice(&input);
reader.startReading(); // Remember to check the return value
reader.waitForFinished();
QList<QVersitDocument> inputDocuments = reader.results();
//! [Complete example - read]
// Convert the QVersitDocuments to QContacts
//! [Complete example - import]
QVersitContactImporter importer;
if (!importer.importDocuments(inputDocuments))
return;
QList<QContact> contacts = importer.contacts();
// Note that the QContacts are not saved yet.
// Use QContactManager::saveContacts() for saving if necessary
//! [Complete example - import]
// Export the QContacts back to QVersitDocuments
//! [Complete example - export]
QVersitContactExporter exporter;
if (!exporter.exportContacts(contacts, QVersitDocument::VCard30Type))
return;
QList<QVersitDocument> outputDocuments = exporter.documents();
//! [Complete example - export]
// Encode the QVersitDocument back to a vCard
//! [Complete example - write]
// Note: we could also use the more convenient QVersitWriter(QByteArray*) constructor.
QBuffer output;
output.open(QBuffer::ReadWrite);
QVersitWriter writer;
writer.setDevice(&output);
writer.startWriting(outputDocuments); // Remember to check the return value
writer.waitForFinished();
// output.buffer() now contains a vCard
//! [Complete example - write]
}
static void setBuffer_snippet()
{
//! [4]
QByteArray byteArray("abc");
QBuffer buffer;
buffer.setBuffer(&byteArray);
buffer.open(QIODevice::WriteOnly);
buffer.seek(3);
buffer.write("def", 3);
buffer.close();
// byteArray == "abcdef"
//! [4]
}
void WebResourceProvider::updateDatabase()
{
QBuffer indexBuffer;
indexBuffer.open( QBuffer::ReadWrite );
download( url() + "/WebResources/Index", &indexBuffer );
indexBuffer.seek( 0 );
QDomDocument doc;
doc.setContent( &indexBuffer );
importNodeIntoDB( doc.firstChildElement( "webresources" ),
database()->topLevelNode() );
}
void Load_Vcard::addNewContacts()
{
QFETCH(QString, vcard);
QFETCH(QString, result);
QList<QContact> contacts;
QString res = QString("1");
QContactManager *cm = new QContactManager();
QContactSaveRequest *m_contactSaveRequest = new QContactSaveRequest();
m_contactSaveRequest->setManager(cm);
//connect(&m_contactSaveRequest, SIGNAL(resultsAvailable()), this,
// SLOT(contactsSaved()));
QFile file(vcard);
if (file.exists()) {
QByteArray cardArr;
if (file.open(QFile::ReadOnly)) {
while (!file.atEnd()) {
cardArr.append(file.readLine());
}
}
QBuffer input;
input.open(QBuffer::ReadWrite);
input.write(cardArr);
input.seek(0);
QVersitReader reader(cardArr);
reader.startReading();
reader.waitForFinished();
QList<QVersitDocument> inputDocuments = reader.results();
QVersitContactImporter importer;
if (importer.importDocuments(inputDocuments)) {
contacts = importer.contacts();
m_contactSaveRequest->setContacts(contacts);
m_contactSaveRequest->start();
m_contactSaveRequest->waitForFinished();
res = QString("0");
}
input.close();
file.close();
}
delete m_contactSaveRequest;
delete cm;
QCOMPARE(res, result);
}
/**
* Convert to Pvl for project files. This stores all of the data associated
* with all of the properties (but not what is supported). This also stores
* the cube filename.
*/
PvlObject DisplayProperties::toPvl() const {
PvlObject output("DisplayProperties");
output += PvlKeyword("DisplayName", displayName());
QBuffer dataBuffer;
dataBuffer.open(QIODevice::ReadWrite);
QDataStream propsStream(&dataBuffer);
propsStream << *m_propertyValues;
dataBuffer.seek(0);
output += PvlKeyword("Values", QString(dataBuffer.data().toHex()));
return output;
}
static void main_snippet()
{
//! [0]
QBuffer buffer;
char ch;
buffer.open(QBuffer::ReadWrite);
buffer.write("Qt rocks!");
buffer.seek(0);
buffer.getChar(&ch); // ch == 'Q'
buffer.getChar(&ch); // ch == 't'
buffer.getChar(&ch); // ch == ' '
buffer.getChar(&ch); // ch == 'r'
//! [0]
}
void tst_QPoint::stream()
{
QFETCH(QPoint, point);
QBuffer tmp;
QVERIFY(tmp.open(QBuffer::ReadWrite));
QDataStream stream(&tmp);
// Ensure that stream returned is the same stream we inserted into.
QDataStream &insertionStreamRef(stream << point);
QVERIFY(&insertionStreamRef == &stream);
tmp.seek(0);
QPoint pointFromStream;
QDataStream &extractionStreamRef(stream >> pointFromStream);
QVERIFY(&extractionStreamRef == &stream);
QCOMPARE(pointFromStream, point);
}
void VCProperties_Test::loadXMLHappy()
{
QBuffer buffer;
buffer.open(QIODevice::ReadWrite | QIODevice::Text);
QXmlStreamWriter xmlWriter(&buffer);
xmlWriter.writeStartElement("Properties");
// Size
xmlWriter.writeStartElement("Size");
xmlWriter.writeAttribute("Width", "10");
xmlWriter.writeAttribute("Height", "20");
xmlWriter.writeEndElement();
// Grand Master
xmlWriter.writeStartElement("GrandMaster");
xmlWriter.writeAttribute("ChannelMode", "All");
xmlWriter.writeAttribute("ValueMode", "Limit");
xmlWriter.writeStartElement("Input");
xmlWriter.writeAttribute("Universe", "2");
xmlWriter.writeAttribute("Channel", "15");
xmlWriter.writeEndElement();
xmlWriter.writeEndElement();
// Extra crap
xmlWriter.writeStartElement("Foo");
xmlWriter.writeEndElement();
xmlWriter.writeEndDocument();
xmlWriter.setDevice(NULL);
buffer.seek(0);
QXmlStreamReader xmlReader(&buffer);
xmlReader.readNextStartElement();
qDebug() << "Buffer:" << buffer.data();
VCProperties p;
QVERIFY(p.loadXML(xmlReader) == true);
QCOMPARE(p.size(), QSize(10, 20));
QCOMPARE(p.grandMasterChannelMode(), GrandMaster::AllChannels);
QCOMPARE(p.grandMasterValueMode(), GrandMaster::Limit);
QCOMPARE(p.grandMasterInputUniverse(), quint32(2));
QCOMPARE(p.grandMasterInputChannel(), quint32(15));
}
void ControlDisplayProperties::save(QXmlStreamWriter &stream, const Project *project,
FileName newProjectRoot) const {
stream.writeStartElement("displayProperties");
stream.writeAttribute("displayName", displayName());
// Get hex-encoded data
QBuffer dataBuffer;
dataBuffer.open(QIODevice::ReadWrite);
QDataStream propsStream(&dataBuffer);
propsStream << *m_propertyValues;
dataBuffer.seek(0);
stream.writeCharacters(dataBuffer.data().toHex());
stream.writeEndElement();
}
bool SevenzImageSource::open()
{
QBuffer *buffer = new QBuffer();
buffer->open(QIODevice::ReadWrite);
// Compute hash
// Thread id should be taken into account because we internally take
// advantage of `outBuffer` as cache and it SHOULD NOT be shared among
// threads.
QString hash;
QTextStream hashBuilder(&hash);
long long threadId = reinterpret_cast<long long>(QThread::currentThreadId());
hashBuilder << QString::number(threadId, 16)
<< "#" << m_packagePath;
SevenzImageSourceFactory *factory =
static_cast<SevenzImageSourceFactory *>(m_factory);
factory->m_mutex.lock();
QSharedPointer<Qt7zPackage> pkg = factory->m_packageCache.find(hash);
if (pkg.isNull()) {
pkg = QSharedPointer<Qt7zPackage>(new Qt7zPackage(m_packagePath));
pkg->open();
if (pkg->isOpen()) {
factory->m_packageCache.insert(hash, pkg);
}
}
factory->m_mutex.unlock();
if (!pkg->isOpen()) {
delete buffer;
return false;
}
if (!pkg->extractFile(m_name, buffer)) {
delete buffer;
return false;
}
buffer->seek(0);
m_device.reset(buffer);
return true;
}
int main(int argc, char ** argv) {
QCoreApplication a(argc, argv);
QBuffer buffer;
buffer.open(QBuffer::ReadWrite);
// write test data into the biffer
QDataStream out(&buffer);
quint8 ival = 42;
QString sval = "Qt";
out << ival;
out << sval;
// read back data
buffer.seek(0);
myFunc(out);
return a.exec();
}
void tst_QNetworkCacheMetaData::stream()
{
QNetworkCacheMetaData data;
data.setUrl(QUrl(EXAMPLE_URL));
QNetworkCacheMetaData::RawHeaderList headers;
headers.append(QNetworkCacheMetaData::RawHeader("foo", "Bar"));
data.setRawHeaders(headers);
data.setLastModified(QDateTime::currentDateTime());
data.setExpirationDate(QDateTime::currentDateTime());
data.setSaveToDisk(false);
QBuffer buffer;
buffer.open(QIODevice::ReadWrite);
QDataStream stream(&buffer);
stream << data;
buffer.seek(0);
QNetworkCacheMetaData data2;
stream >> data2;
QCOMPARE(data2, data);
}
/**
* \warning The caller has to delete the archive's underlying device
*/
KTar* ModelManager::archiveFromBuffer(const QByteArray& input)
{
// safely remove the const qualifier as the buffer is only opened read-only
QBuffer buffer(const_cast<QByteArray*>(&input));
if (!buffer.open(QIODevice::ReadOnly))
return 0;
QIODevice *uncompressed = KFilterDev::device(&buffer, "application/x-gzip", false);
if (!uncompressed || !uncompressed->open(QIODevice::ReadOnly))
return 0;
//seeking doesn't work properly in kfilterdevs, which trips up KTar. Instead, decompress
//completely before passing it on to KTar
QBuffer *uncompressedBuffer = new QBuffer;
if (!uncompressedBuffer->open(QIODevice::ReadWrite))
return 0;
uncompressedBuffer->write(uncompressed->readAll());
uncompressedBuffer->seek(0);
delete uncompressed;
return new KTar(uncompressedBuffer);
}
/*!
* Store contact
*/
CArrayFixFlat<TUid>* CNsmlContactsDataStoreExtensionPrivate::ImportContactsL( const TDesC8 &contactbufbase )
{
_DBG_FILE("CNsmlContactsDataStoreExtensionPrivate::ImportContactsL: BEGIN");
DBG_DUMP((void*)contactbufbase.Ptr(), contactbufbase.Length(),
_S8("CNsmlContactsDataStoreExtensionPrivate::ImportContactsL: To DB :"));
TBool ret( ETrue );
CArrayFixFlat<TUid>* contactItems = new(ELeave) CArrayFixFlat<TUid>(4);
QBuffer contactsbuf;
contactsbuf.open(QBuffer::ReadWrite);
QByteArray bytearray((char*)contactbufbase.Ptr());
contactsbuf.write(bytearray);
contactsbuf.seek(0);
mReader->setDevice(&contactsbuf);
if (mReader->startReading() && mReader->waitForFinished())
{
DBG_ARGS(_S("CNsmlContactsDataStoreExtensionPrivate::Buffer Count: %d"), mReader->results().count() );
QList<QContact> contacts;
if ( mImporter->importDocuments( mReader->results() ) )
{
contacts = mImporter->contacts();
QMap<int, QContactManager::Error> errorMap;
ret = mContactManager->saveContacts( &contacts, &errorMap );
DBG_ARGS(_S("CNsmlContactsDataStoreExtensionPrivate::Import Status: %d"), ret );
}
if( ret )
{
foreach (QContact contact, contacts )
{
TUint contactid = contact.id().localId();
DBG_ARGS(_S("CNsmlContactsDataStoreExtensionPrivate::Contact ID: %d"), contactid );
contactItems->AppendL( TUid::Uid( contactid ) );
}
}
void KdbxXmlWriter::writeBinaries()
{
m_xml.writeStartElement("Binaries");
QHash<QByteArray, int>::const_iterator i;
for (i = m_idMap.constBegin(); i != m_idMap.constEnd(); ++i) {
m_xml.writeStartElement("Binary");
m_xml.writeAttribute("ID", QString::number(i.value()));
QByteArray data;
if (m_db->compressionAlgorithm() == Database::CompressionGZip) {
m_xml.writeAttribute("Compressed", "True");
QBuffer buffer;
buffer.open(QIODevice::ReadWrite);
QtIOCompressor compressor(&buffer);
compressor.setStreamFormat(QtIOCompressor::GzipFormat);
compressor.open(QIODevice::WriteOnly);
qint64 bytesWritten = compressor.write(i.key());
Q_ASSERT(bytesWritten == i.key().size());
Q_UNUSED(bytesWritten);
compressor.close();
buffer.seek(0);
data = buffer.readAll();
} else {
data = i.key();
}
if (!data.isEmpty()) {
m_xml.writeCharacters(QString::fromLatin1(data.toBase64()));
}
m_xml.writeEndElement();
}
m_xml.writeEndElement();
}
void ScreenPacket::setImage(const QImage& image){
/*
QPainter painter;
painter.begin(&image);
painter.fillRect(0, 0, 30, image.height()-10, Qt::white);
painter.setPen(Qt::red);
painter.setFont(QFont("Courier new", 12));
painter.drawText(5, 10, QString::number(QTime::currentTime().second()));
painter.end();
*/
QBuffer buffer;
buffer.setBuffer(&_buffer);
buffer.open(QBuffer::WriteOnly);
buffer.seek(0);
QImageWriter writer(&buffer, "JPEG");
writer.setQuality(32);
writer.setCompression(1);
_pixmapGenerated = writer.write(image);
_buffer = qCompress(_buffer, 9);
//_pixmap = pixmap;
_pixmap = QPixmap::fromImage(image);
}
