bool FileExporterXSLT::save(QIODevice *iodevice, const QSharedPointer<const Element> element, const File *bibtexfile, QStringList *errorLog)
{
if (!iodevice->isWritable() && !iodevice->open(QIODevice::WriteOnly)) {
qCWarning(LOG_KBIBTEX_IO) << "Output device not writable";
return false;
}
m_cancelFlag = false;
XSLTransform xsltransformer(m_xsltFilename);
FileExporterXML xmlExporter;
QBuffer buffer;
buffer.open(QIODevice::WriteOnly);
if (xmlExporter.save(&buffer, element, bibtexfile, errorLog)) {
buffer.close();
buffer.open(QIODevice::ReadOnly);
const QString xml = QString::fromUtf8(buffer.readAll().constData());
buffer.close();
const QString html = xsltransformer.transform(xml);
if (!html.isEmpty()) {
iodevice->write(html.toUtf8());
iodevice->close();
return !m_cancelFlag;
}
}
iodevice->close();
return false;
}
TEST_F(ProtocolFactory, SelectFragmented)
{
QBuffer device;
QByteArray data1("TEST");
QByteArray data2("TESTDATA1\nOTHER");
MockProtocol mock1;
MockProtocol mock2;
MockProtocol mockOutput;
EXPECT_CALL(mock1, HandshakeSize()).WillRepeatedly(Return(2));
EXPECT_CALL(mock2, HandshakeSize()).WillRepeatedly(Return(10));
EXPECT_CALL(mock1, ConstructIfSuitable(QByteArray("TE"), nullptr)).InSequence(_seq)
.WillOnce(Return(nullptr));
EXPECT_CALL(mock1, ConstructIfSuitable(QByteArray("TE"), nullptr)).InSequence(_seq)
.WillOnce(Return(nullptr));
EXPECT_CALL(mock2, ConstructIfSuitable(QByteArray("TESTDATA1\n"), nullptr)).InSequence(_seq)
.WillOnce(Return(&mockOutput));
_factory.RegisterProtocol(&mock1);
_factory.RegisterProtocol(&mock2);
device.setBuffer(&data1);
device.open(QIODevice::ReadOnly);
EXPECT_EQ(_factory.CreateProtocol(device), nullptr);
EXPECT_EQ(device.read(15), QByteArray("TEST"));
device.close();
device.setBuffer(&data2);
device.open(QIODevice::ReadOnly);
EXPECT_EQ(_factory.CreateProtocol(device), &mockOutput);
EXPECT_EQ(device.read(5), QByteArray("OTHER"));
device.close();
}
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 tst_WebSocketFrame::tst_invalidFrames()
{
QFETCH(int, rsv1);
QFETCH(int, rsv2);
QFETCH(int, rsv3);
QFETCH(quint32, mask);
QFETCH(QWebSocketProtocol::OpCode, opCode);
QFETCH(bool, isFinal);
QFETCH(QByteArray, payload);
QFETCH(QWebSocketProtocol::CloseCode, expectedError);
FrameHelper helper;
helper.setRsv1(rsv1);
helper.setRsv2(rsv2);
helper.setRsv3(rsv3);
helper.setMask(mask);
helper.setOpCode(opCode);
helper.setFinalFrame(isFinal);
helper.setPayload(payload);
QByteArray wireRepresentation = helper.wireRepresentation();
QBuffer buffer;
buffer.setData(wireRepresentation);
buffer.open(QIODevice::ReadOnly);
QWebSocketFrame frame = QWebSocketFrame::readFrame(&buffer);
buffer.close();
QVERIFY(!frame.isValid());
QCOMPARE(frame.closeCode(), expectedError);
}
Element* MTest::writeReadElement(Element* element)
{
//
// write element
//
QBuffer buffer;
buffer.open(QIODevice::WriteOnly);
Xml xml(&buffer);
xml.header();
element->write(xml);
buffer.close();
//
// read element
//
// printf("%s\n", buffer.buffer().data());
QDomDocument doc;
int line, column;
QString err;
if (!doc.setContent(buffer.buffer(), &err, &line, &column)) {
printf("writeReadElement: error reading paste data at line %d column %d: %s\n",
line, column, qPrintable(err));
printf("%s\n", buffer.buffer().data());
return 0;
}
docName = "--";
QDomElement e = doc.documentElement();
QString tag(e.tagName());
element = Element::name2Element(e.tagName(), score);
element->read(e);
return element;
}
void QLCInputProfile_Test::load()
{
QBuffer buffer;
buffer.open(QIODevice::WriteOnly | QIODevice::Text);
QXmlStreamWriter xmlWriter(&buffer);
xmlWriter.writeStartDocument();
xmlWriter.writeDTD("<!DOCTYPE InputProfile>");
xmlWriter.writeStartElement("InputProfile");
xmlWriter.writeTextElement("Manufacturer", "Behringer");
xmlWriter.writeTextElement("Model", "BCF2000");
xmlWriter.writeStartElement("Channel");
xmlWriter.writeAttribute("Number", "492");
xmlWriter.writeTextElement("Name", "Foobar");
xmlWriter.writeTextElement("Type", "Slider");
xmlWriter.writeEndDocument();
xmlWriter.setDevice(NULL);
buffer.close();
buffer.open(QIODevice::ReadOnly | QIODevice::Text);
QXmlStreamReader xmlReader(&buffer);
QLCInputProfile ip;
QVERIFY(ip.loadXML(xmlReader) == true);
QVERIFY(ip.manufacturer() == "Behringer");
QVERIFY(ip.model() == "BCF2000");
QVERIFY(ip.channels().size() == 1);
QVERIFY(ip.channel(492) != NULL);
QVERIFY(ip.channel(492)->name() == "Foobar");
QVERIFY(ip.channel(492)->type() == QLCInputChannel::Slider);
}
void QLCFixtureHead_Test::load()
{
QBuffer buffer;
buffer.open(QIODevice::WriteOnly | QIODevice::Text);
QXmlStreamWriter xmlWriter(&buffer);
xmlWriter.writeStartElement("Head");
xmlWriter.writeTextElement("Channel", "0");
xmlWriter.writeTextElement("Channel", "1");
xmlWriter.writeTextElement("Channel", "15");
xmlWriter.writeTextElement("Foo", "25");
xmlWriter.writeTextElement("Channel", "42");
xmlWriter.writeEndDocument();
xmlWriter.setDevice(NULL);
buffer.close();
buffer.open(QIODevice::ReadOnly | QIODevice::Text);
QXmlStreamReader xmlReader(&buffer);
xmlReader.readNextStartElement();
QLCFixtureHead head;
QVERIFY(head.loadXML(xmlReader));
QCOMPARE(head.channels().size(), 4);
QVERIFY(head.channels().contains(0));
QVERIFY(head.channels().contains(1));
QVERIFY(head.channels().contains(15));
QVERIFY(head.channels().contains(42));
}
void VCProperties_Test::saveXML()
{
VCProperties p;
p.m_size = QSize(33, 44);
p.m_gmChannelMode = GrandMaster::AllChannels;
p.m_gmValueMode = GrandMaster::Limit;
p.m_gmInputUniverse = 3;
p.m_gmInputChannel = 42;
QBuffer buffer;
buffer.open(QIODevice::WriteOnly | QIODevice::Text);
QXmlStreamWriter xmlWriter(&buffer);
QVERIFY(p.saveXML(&xmlWriter) == true);
xmlWriter.setDevice(NULL);
buffer.close();
buffer.open(QIODevice::ReadOnly | QIODevice::Text);
QXmlStreamReader xmlReader(&buffer);
xmlReader.readNextStartElement();
VCProperties p2;
QVERIFY(p2.loadXML(xmlReader) == true);
QCOMPARE(p2.size(), QSize(33, 44));
QCOMPARE(p2.grandMasterChannelMode(), GrandMaster::AllChannels);
QCOMPARE(p2.grandMasterValueMode(), GrandMaster::Limit);
QCOMPARE(p2.grandMasterInputUniverse(), quint32(3));
QCOMPARE(p2.grandMasterInputChannel(), quint32(42));
}
QByteArray BasketModel::modelDataToXML(bool encrypted)
{
QDomDocument doc;
QDomElement root = doc.createElement( "basket-passwords" );
root.setAttribute(QString("ident"), identifier());
setTimeModified(QDateTime::currentDateTime());
//lastDBModified = QDateTime::currentDateTime();
root.setAttribute(QString("modified"), lastDBModified.toString(DATE_TIME_FORMAT));
doc.appendChild( root );
for ( int i = 0; i < rootItem->childCount(); i++ ) {
QDomElement child = convertBasketItemToDomElement(rootItem->childItemAt(i), doc);
root.appendChild(child);
}
QByteArray clearBuffer;
QBuffer clearFile ( &clearBuffer );
if ( !clearFile.open( QIODevice::WriteOnly | QIODevice::Text ) )
return QByteArray();
QTextStream clearStream(&clearFile);
doc.save(clearStream, 4);
clearFile.close();
if ( !encrypted )
return clearBuffer;
BasketUtils butil;
QByteArray encryptedBuffer = butil.crypt(clearBuffer, hash());
return encryptedBuffer;
}
void serializationTest()
{
Tgs::Random::instance()->seed(0);
shared_ptr<KernelEstimationInterpolator> di = buildRandom();
KernelEstimationInterpolator& uut = *di;
uut.setStopDelta(0.0001);
uut.setSigma(0.3);
Tgs::Random::instance()->seed(0);
double error = uut.estimateError();
QBuffer buf;
buf.open(QBuffer::WriteOnly);
uut.writeInterpolator(buf);
buf.close();
buf.open(QBuffer::ReadOnly);
KernelEstimationInterpolator copy;
copy.readInterpolator(buf);
Tgs::Random::instance()->seed(0);
CPPUNIT_ASSERT_DOUBLES_EQUAL(error, copy.estimateError(), 0.0001);
CPPUNIT_ASSERT_DOUBLES_EQUAL(0.3, copy.getSigma(), 0.0001);
CPPUNIT_ASSERT_DOUBLES_EQUAL(0.0001, copy.getStopDelta(), 0.0001);
}
void setExp(const char name[], QMap<QString, int> expValueMap) {
QBuffer buffer;
QDataStream in(&buffer);
QMap<QString, QMap<QString, int> > expMap = readExpMap();
expMap[name] = expValueMap;
buffer.open(QBuffer::ReadWrite);
in << expMap;
if(expShm->isAttached())
expShm->detach();
if (!expShm->create(buffer.size() + sizeof(char))) {
expShm->attach(QSharedMemory::ReadWrite);
}
QBuffer bufferwrite;
QDataStream out(&bufferwrite);
expShm->lock();
bufferwrite.open(QBuffer::ReadWrite);
out << expMap;
bufferwrite.close();
char *to = (char*)expShm->data();
const char *from = bufferwrite.data().data();
memcpy(to, from, qMin(expShm->size(), (int)bufferwrite.size()));
expShm->unlock();
}
QMap<QString, QMap<QString, int> > readExpMap() {
QBuffer buffer;
QDataStream in(&buffer);
QMap<QString, QMap<QString, int> > expMap;
expShm->attach(QSharedMemory::ReadWrite);
if(!expShm->isAttached()) {
return expMap;
}
expShm->lock();
buffer.setData((char*)expShm->constData(), expShm->size());
buffer.open(QBuffer::ReadOnly);
in >> expMap;
buffer.close();
expShm->unlock();
expShm->detach();
return expMap;
}
int CUserInfoXmpp::UpdateUserInfo(const QXmppVCardIq &vCard, QString jid)
{
//if(!vCard.fullName().isEmpty())
// m_szName = vCard.fullName();
m_szNick = vCard.nickName();
m_Birthday = vCard.birthday();
m_szEmail = vCard.email();
m_szDescription = vCard.description();
if(!jid.isEmpty() && m_szJid.isEmpty())
m_szJid = jid;
//保存头像
QByteArray photo = vCard.photo();
QBuffer buffer;
buffer.setData(photo);
buffer.open(QIODevice::ReadOnly);
QImageReader imageReader(&buffer);
m_imgPhoto = imageReader.read();
buffer.close();
//保存头像到本地
QImageWriter imageWriter(CGlobal::Instance()->GetFileUserAvatar(GetId()), "png");
if(!imageWriter.write(GetPhoto()))
LOG_MODEL_ERROR("CUserInfo", "Save avater error, %s", imageWriter.errorString().toStdString().c_str());
return 0;
}
/**
* Sends result(s) to the server in xml format.
* Send authentication information in the header.
*/
void HttpClient::sendResultXml(QString category, double result)
{
qDebug() << "_sendResultXml";
qDebug() << category;
QBuffer *xmlbuffer = new QBuffer();
QUrl qurl("http://www.speedfreak-app.com/results/update/" + category);
qDebug() << qurl.toString();
QNetworkRequest request(qurl);
QNetworkReply *currentDownload;
xmlbuffer->open(QBuffer::ReadWrite);
myXmlwriter->writeResult(xmlbuffer, result);
qDebug() << "carmainwindow: xmlbuffer->data(): " << xmlbuffer->data();
QString credentials = myMainw->settingsDialog->getUserName() + ":" + myMainw->settingsDialog->getPassword();
credentials = "Basic " + credentials.toAscii().toBase64();
request.setRawHeader(QByteArray("Authorization"),credentials.toAscii());
currentDownload = netManager->post(request, ("xml=" + xmlbuffer->data()));
connect(currentDownload,SIGNAL(finished()),this,SLOT(ackOfResult()));
//connect(currentDownload,SIGNAL(error(QNetworkReply::NetworkError)),myMainw,SLOT(errorFromServer(QNetworkReply::NetworkError)));
//Indicating user
if(myMainw->accstart->accRealTimeDialog->resultDialog)
myMainw->accstart->accRealTimeDialog->resultDialog->setLabelInfoToUser("Sending result to server");
xmlbuffer->close();
}
void Workspace::writeGlobalGUIState()
{
QString default_path = "";
QDir dir;
dir.mkpath(dataPath);
default_path = dataPath + "/workspaces";
dir.mkpath(default_path);
default_path += "/global";
dir.mkpath(default_path);
default_path += "/guistate.xml";
QFile default_guistate (default_path);
default_guistate.open(QIODevice::WriteOnly);
if (!default_guistate.exists()) {
writeFailed(default_path);
return;
}
QBuffer cbuf;
cbuf.open(QIODevice::ReadWrite);
XmlWriter xml(gscore, &cbuf);
xml.setClipboardmode(true);
xml.header();
xml.stag("museScore version=\"" MSC_VERSION "\"");
QByteArray state_64 = mscore->saveState().toBase64();
QString state(state_64);
xml.tag("State", state);
xml.etag();
default_guistate.write(cbuf.data());
cbuf.close();
default_guistate.close();
}
QByteArray BasketModel::indexesToXML(const QModelIndexList &indexes) const
{
QDomDocument doc;
QDomElement root = doc.createElement( "basket-passwords-items" );
doc.appendChild( root );
foreach(QModelIndex idx, indexes) {
if ( !idx.isValid() )
continue;
if ( idx.column() != 0 )
continue;
BasketBaseItem *item = static_cast<BasketBaseItem *>(idx.internalPointer());
if ( !item )
continue;
QDomElement child = convertBasketItemToDomElement(item, doc);
root.appendChild(child);
}
QByteArray clearBuffer;
QBuffer clearFile ( &clearBuffer );
if ( !clearFile.open( QIODevice::WriteOnly | QIODevice::Text ) )
return QByteArray();
QTextStream clearStream(&clearFile);
doc.save(clearStream, 4);
clearFile.close();
return clearBuffer;
}
bool QInstaller::VerboseWriter::flush(VerboseWriterOutput *output)
{
stream.flush();
if (logFileName.isEmpty()) // binarycreator
return true;
if (!preFileBuffer.isOpen())
return true;
//if the installer installed nothing - there is no target directory - where the logfile can be saved
if (!QFileInfo(logFileName).absoluteDir().exists())
return true;
QString logInfo;
logInfo += QLatin1String("************************************* Invoked: ");
logInfo += currentDateTimeAsString;
logInfo += QLatin1String("\n");
QBuffer buffer;
buffer.open(QIODevice::WriteOnly);
buffer.write(logInfo.toLocal8Bit());
buffer.write(preFileBuffer.data());
buffer.close();
if (output->write(logFileName, QIODevice::ReadWrite | QIODevice::Append | QIODevice::Text, buffer.data())) {
preFileBuffer.close();
stream.setDevice(nullptr);
return true;
}
return false;
}
void ContactGroupTest::testGroupRoundTrip()
{
// TODO should also test empty group
ContactGroup group( QLatin1String( "TestGroup" ) );
group.append( ContactGroup::ContactReference( QLatin1String( "Xggdjetw" ) ) );
group.append( ContactGroup::ContactGroupReference( QLatin1String( "aaXggdjetw" ) ) );
group.append( ContactGroup::Data( QLatin1String( "Tobias Koenig" ),
QLatin1String( "*****@*****.**" ) ) );
group.append( ContactGroup::Data( QLatin1String( "Kevin Krammer" ),
QLatin1String( "*****@*****.**" ) ) );
QBuffer buffer;
buffer.open( QIODevice::WriteOnly );
QString errorMessage;
bool result = ContactGroupTool::convertToXml( group, &buffer, &errorMessage );
QVERIFY( result );
QVERIFY( errorMessage.isEmpty() );
buffer.close();
QVERIFY( buffer.size() > 0 );
buffer.open( QIODevice::ReadOnly );
ContactGroup group2;
result = ContactGroupTool::convertFromXml( &buffer, group2, &errorMessage );
QVERIFY( result );
QVERIFY( errorMessage.isEmpty() );
QCOMPARE( group, group2 );
}
void Workspace::writeGlobalMenuBar(QMenuBar* mb)
{
QString default_path = "";
QDir dir;
dir.mkpath(dataPath);
default_path = dataPath + "/workspaces";
dir.mkpath(default_path);
default_path += "/global";
dir.mkpath(default_path);
default_path += "/menubar.xml";
QFile default_menubar (default_path);
default_menubar.open(QIODevice::WriteOnly);
if (!default_menubar.exists()) {
writeFailed(default_path);
return;
}
QBuffer cbuf;
cbuf.open(QIODevice::ReadWrite);
XmlWriter xml(gscore, &cbuf);
xml.setClipboardmode(true);
xml.header();
xml.stag("museScore version=\"" MSC_VERSION "\"");
writeMenuBar(xml, mb);
xml.etag();
default_menubar.write(cbuf.data());
cbuf.close();
default_menubar.close();
}
void RunnerView::save()
{
if (m_socket->isWritable()) {
QImage image(grabFramebuffer());
QBuffer buffer;
buffer.open(QBuffer::WriteOnly);
QDataStream out(&buffer);
out << image;
int size(buffer.size());
if (m_shared->isAttached()) {
if (m_shared->size() < size && !m_shared->detach()) {
return;
}
}
if (!m_shared->isAttached()) {
if (!m_shared->create(size)) {
qWarning("RunnerView::save - m_shared create error");
return;
}
}
m_shared->lock();
char* to((char*)m_shared->data());
const char* from(buffer.data().data());
memcpy(to, from, qMin(m_shared->size(), size));
m_shared->unlock();
buffer.close();
Message message(m_appUid, MessageType::Update);
message.write(m_socket);
}
}
Element* MTest::writeReadElement(Element* element)
{
//
// write element
//
QBuffer buffer;
buffer.open(QIODevice::WriteOnly);
Xml xml(&buffer);
xml.header();
element->write(xml);
buffer.close();
//
// read element
//
// printf("===read <%s>===\n", element->name());
// printf("%s\n", buffer.buffer().data());
XmlReader e(buffer.buffer());
e.readNextStartElement();
QString tag(e.name().toString());
// printf("read tag %s\n", qPrintable(tag));
element = Element::name2Element(e.name(), score);
element->read(e);
return element;
}
void dataExport() {
QFETCH(QString, fileIn);
QFETCH(QString, fileOut);
QFETCH(QString, exportPrefix);
QFETCH(QList<QLandmark>, waypoints);
QFETCH(QList<QList<QLandmark> >, tracks);
QFETCH(QList<QList<QLandmark> >, routes);
m_handler->setWaypoints(waypoints);
m_handler->setTracks(tracks);
m_handler->setRoutes(routes);
QBuffer buffer;
buffer.open(QIODevice::WriteOnly);
QVERIFY(m_handler->exportData(&buffer, exportPrefix));
QByteArray dataExported = buffer.buffer();
buffer.close();
QFile file(fileOut);
file.open(QIODevice::ReadOnly);
QByteArray testData = file.readAll();
file.close();
QCOMPARE(dataExported, testData);
}
QString FormTemplateWizardPage::changeUiClassName(const QString &uiXml, const QString &newUiClassName)
{
// Prepare I/O: Sheet
const QString xsltSheet = QString::fromLatin1(classNameChangingSheetFormatC).arg(newUiClassName);
QByteArray xsltSheetBA = xsltSheet.toUtf8();
QBuffer xsltSheetBuffer(&xsltSheetBA);
xsltSheetBuffer.open(QIODevice::ReadOnly);
// Prepare I/O: Xml
QByteArray xmlBA = uiXml.toUtf8();
QBuffer xmlBuffer(&xmlBA);
xmlBuffer.open(QIODevice::ReadOnly);
// Prepare I/O: output
QBuffer outputBuffer;
outputBuffer.open(QIODevice::WriteOnly);
// Run query
QXmlQuery query(QXmlQuery::XSLT20);
query.setFocus(&xmlBuffer);
query.setQuery(&xsltSheetBuffer);
if (!query.evaluateTo(&outputBuffer)) {
qWarning("Unable to change the ui class name in a form template.\n%s\nUsing:\n%s\n",
xmlBA.constData(), xsltSheetBA.constData());
return uiXml;
}
outputBuffer.close();
return QString::fromUtf8(outputBuffer.data());
}
void Fixture_Test::loadWrongID()
{
QBuffer buffer;
buffer.open(QIODevice::WriteOnly | QIODevice::Text);
QXmlStreamWriter xmlWriter(&buffer);
xmlWriter.writeStartElement("Fixture");
xmlWriter.writeTextElement("Channels", "9");
xmlWriter.writeTextElement("Name", "Foobar");
xmlWriter.writeTextElement("Universe", "0");
xmlWriter.writeTextElement("Model", "MAC250+");
xmlWriter.writeTextElement("Mode", "Mode 1");
xmlWriter.writeTextElement("Manufacturer", "Martin");
xmlWriter.writeTextElement("ID", QString::number(Fixture::invalidId()));
xmlWriter.writeTextElement("Address", "21");
xmlWriter.writeEndDocument();
xmlWriter.setDevice(NULL);
buffer.close();
buffer.open(QIODevice::ReadOnly | QIODevice::Text);
QXmlStreamReader xmlReader(&buffer);
xmlReader.readNextStartElement();
Fixture fxi(this);
QVERIFY(fxi.loadXML(xmlReader, m_doc, m_doc->fixtureDefCache()) == false);
}
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 Fixture_Test::loadWrongUniverse()
{
QBuffer buffer;
buffer.open(QIODevice::WriteOnly | QIODevice::Text);
QXmlStreamWriter xmlWriter(&buffer);
xmlWriter.writeStartElement("Fixture");
xmlWriter.writeTextElement("Channels", "18");
xmlWriter.writeTextElement("Name", "Foobar");
xmlWriter.writeTextElement("Universe", "4");
xmlWriter.writeTextElement("Model", "Foobar");
xmlWriter.writeTextElement("Mode", "Foobar");
xmlWriter.writeTextElement("Manufacturer", "Foobar");
xmlWriter.writeTextElement("ID", "42");
xmlWriter.writeTextElement("Address", "25");
xmlWriter.writeEndDocument();
xmlWriter.setDevice(NULL);
buffer.close();
buffer.open(QIODevice::ReadOnly | QIODevice::Text);
QXmlStreamReader xmlReader(&buffer);
xmlReader.readNextStartElement();
Fixture fxi(this);
QVERIFY(fxi.loadXML(xmlReader, m_doc, m_doc->fixtureDefCache()) == true);
QVERIFY(fxi.name() == "Foobar");
QVERIFY(fxi.channels() == 18);
QVERIFY(fxi.address() == 25);
QVERIFY(fxi.universe() == 4);
}
void SaveTask::run()
{
if (!m_image.isNull()) {
QBuffer buffer;
if (m_body.isEmpty()) {
buffer.setBuffer(&m_body);
m_image.save(&buffer, "PNG");
}
Thumbnail thumb;
if (m_size.isValid()) {
thumb.image = ImageCrop::crop(m_image, m_size);
buffer.close();
buffer.setBuffer(&thumb.raw);
thumb.image.save(&buffer, "PNG");
}
emit ready(m_id, m_body, thumb);
}
if (!m_fileName.isEmpty() && !m_body.isEmpty()) {
QDir().mkpath(QFileInfo(m_fileName).absolutePath());
QFile file(m_fileName);
if (file.open(QFile::WriteOnly))
file.write(m_body);
}
}
static void dumpImage(const QImage& image)
{
QBuffer buffer;
buffer.open(QBuffer::WriteOnly);
image.save(&buffer, "PNG");
buffer.close();
const QByteArray& data = buffer.data();
printf("Content-Type: %s\n", "image/png");
printf("Content-Length: %lu\n", static_cast<unsigned long>(data.length()));
const quint32 bytesToWriteInOneChunk = 1 << 15;
quint32 dataRemainingToWrite = data.length();
const char* ptr = data.data();
while (dataRemainingToWrite) {
quint32 bytesToWriteInThisChunk = qMin(dataRemainingToWrite, bytesToWriteInOneChunk);
quint32 bytesWritten = fwrite(ptr, 1, bytesToWriteInThisChunk, stdout);
if (bytesWritten != bytesToWriteInThisChunk)
break;
dataRemainingToWrite -= bytesWritten;
ptr += bytesWritten;
}
fflush(stdout);
}
void CustomerInfoPanel::displayFiche(const QString & fichecontent, bool qtui, const QString & id)
{
Popup * popup = NULL;
for(int i = m_popups.size() - 1; i >= 0; i --) {
if(id == m_popups[i]->id()) {
qDebug() << Q_FUNC_INFO << "fiche id already there" << i << id;
popup = m_popups[i];
break;
}
}
QBuffer * inputstream = new QBuffer(this);
inputstream->open(QIODevice::ReadWrite);
inputstream->write(fichecontent.toUtf8());
inputstream->close();
// Get Data and Popup the profile if ok
if (popup == NULL) {
popup = new Popup(m_autourl_allowed);
m_popups.append(popup);
popup->setId(id);
connect(popup, SIGNAL(destroyed(QObject *)),
this, SLOT(popupDestroyed(QObject *)));
connect(popup, SIGNAL(wantsToBeShown(Popup *)),
this, SLOT(showNewProfile(Popup *)));
connect(popup, SIGNAL(actionFromPopup(const QString &, const QVariant &)),
this, SLOT(actionFromPopup(const QString &, const QVariant &)));
connect(popup, SIGNAL(newRemarkSubmitted(const QString &, const QString &)),
b_engine, SLOT(sendNewRemark(const QString &, const QString &)));
}
void image::sSave()
{
XSqlQuery newImage;
if (__image.isNull())
{
QMessageBox::warning(this, tr("No Image Specified"),
tr("You must load an image before you may save this record.") );
return;
}
if (_mode == cNew)
{
XSqlQuery imageid("SELECT NEXTVAL('image_image_id_seq') AS _image_id");
if (imageid.first())
_imageid = imageid.value("_image_id").toInt();
// ToDo
QImageWriter imageIo;
QBuffer imageBuffer;
QString imageString;
imageBuffer.open(QIODevice::ReadWrite);
imageIo.setDevice(&imageBuffer);
imageIo.setFormat("PNG");
if (!imageIo.write(__image))
{
QMessageBox::critical(this, tr("Error Saving Image"),
tr("There was an error trying to save the image.") );
return;
}
imageBuffer.close();
imageString = QUUEncode(imageBuffer);
newImage.prepare( "INSERT INTO image "
"(image_id, image_name, image_descrip, image_data) "
"VALUES "
"(:image_id, :image_name, :image_descrip, :image_data);" );
newImage.bindValue(":image_id", _imageid);
newImage.bindValue(":image_name", _name->text());
newImage.bindValue(":image_descrip", _descrip->toPlainText());
newImage.bindValue(":image_data", imageString);
}
else if (_mode == cEdit)
{
newImage.prepare( "UPDATE image "
"SET image_name=:image_name, image_descrip=:image_descrip "
"WHERE (image_id=:image_id);" );
newImage.bindValue(":image_id", _imageid);
newImage.bindValue(":image_name", _name->text());
newImage.bindValue(":image_descrip", _descrip->toPlainText());
}
newImage.exec();
done(_imageid);
}
