void WriteSharedMemory::write( )
{
QString text = read();
QBuffer buffer;
text = text + "C://project//projectFile" + QString::number(num) + ".txt;";
buffer.open( QBuffer::ReadWrite );
QDataStream out( &buffer );
out << text;
int size = buffer.size();
if(sharedMem.size()<size)
{
qDebug() << "¹²ÏíÄÚ´æ¿Õ¼ä²»¹»£¡";
return ;
}
num++;
freeSystemSem.acquire();
// Write into the shared memory
sharedMem.lock();
char *to = (char*)sharedMem.data();
const char *from = buffer.data().data();
memcpy( to, from, qMin( sharedMem.size(), size ) );
sharedMem.unlock();
usedSystemSem.release();
ui.textEdit_2->append(text);
qDebug() << "WriteSharedMemory:: Write:" << text;
}
// Tool fucntions
QByteArray getHeadImage(QString name)
{
QImage img(name);
QBuffer buffer;
img.save(&buffer,"png");
return buffer.data();
}
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();
}
QJsonDocument Api::get(const QString& path, CancellationToken cancellationToken) const
{
qInfo() << "Executing GET " << path;
ApiConnectionSettings connectionSettings = defaultConnectionSettings();
ApiConnectionStrategy strategy(connectionSettings, Config::minConnectionTimeoutMsec, Config::maxConnectionTimeoutMsec);
QBuffer buffer;
buffer.open(QIODevice::WriteOnly);
if (!strategy.execute(m_dataSource, path, buffer, cancellationToken))
{
throw ApiConnectionError("Failed to connect to the api.");
}
auto data = buffer.data();
QJsonParseError parseError;
auto doc = QJsonDocument::fromJson(data, &parseError);
if (parseError.error != QJsonParseError::NoError)
{
throw InvalidFormatException(parseError.errorString());
}
return doc;
}
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);
}
}
void
CollectionScanner::ScanningState::writeFull()
{
if( !isValid() )
return;
QBuffer buffer;
QDataStream out(&buffer);
m_sharedMemory->lock();
buffer.open(QBuffer::WriteOnly);
out << m_lastDirectory;
out << m_directories;
out << m_badFiles;
m_lastFilePos = buffer.pos();
out << m_lastFile;
int size = buffer.size();
if( size < m_sharedMemory->size() )
{
char *to = (char*)m_sharedMemory->data();
const char *from = buffer.data().data();
memcpy(to, from, size);
}
m_sharedMemory->unlock();
}
void
CollectionScanner::ScanningState::setLastFile( const QString &file )
{
if( file == m_lastFile )
return;
m_lastFile = file;
if( !isValid() )
return;
QBuffer buffer;
QDataStream out(&buffer);
buffer.open(QBuffer::WriteOnly);
out << m_lastFile;
int size = buffer.size();
if( size + m_lastFilePos < m_sharedMemory->size() )
{
char *to = (char*)m_sharedMemory->data();
const char *from = buffer.data().data();
memcpy(to + m_lastFilePos, from, size);
}
m_sharedMemory->unlock();
}
bool KDcraw::loadHalfPreview(QByteArray& imgData, const QBuffer& inBuffer)
{
QString rawFilesExt(KDcrawIface::KDcraw::rawFiles());
LibRaw raw;
QByteArray inData = inBuffer.data();
int ret = raw.open_buffer((void*) inData.data(), (size_t) inData.size());
if (ret != LIBRAW_SUCCESS)
{
kDebug() << "LibRaw: failed to run dcraw_make_mem_image: " << libraw_strerror(ret);
raw.recycle();
return false;
}
QImage image;
if (!Private::loadHalfPreview(image, raw))
{
kDebug() << "KDcraw: failed to get half preview: " << libraw_strerror(ret);
return false;
}
QBuffer buffer(&imgData);
buffer.open(QIODevice::WriteOnly);
image.save(&buffer, "JPG");
return true;
}
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();
}
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();
}
QString Api::tryGetCountryCode(CancellationToken cancellationToken) const
{
qInfo() << "Getting the country code";
try
{
ApiConnectionSettings connectionSettings(Config::geolocationApiUrl, QStringList());
ApiConnectionStrategy strategy(connectionSettings, Config::geolocationTimeout, Config::geolocationTimeout);
QString path = "v1/country";
QBuffer buffer;
if (!strategy.execute(m_dataSource, path, buffer, cancellationToken))
{
throw ApiConnectionError("Failed to connect to the api.");
}
auto document = QJsonDocument::fromBinaryData(buffer.data());
return document.object()["country"].toString();
}
catch (ApiConnectionError&)
{
return QString();
}
}
QByteArray FSTReader::writeMapping(const QVariantHash& mapping) {
static const QStringList PREFERED_ORDER = QStringList() << NAME_FIELD << TYPE_FIELD << SCALE_FIELD << FILENAME_FIELD
<< TEXDIR_FIELD << JOINT_FIELD << FREE_JOINT_FIELD
<< BLENDSHAPE_FIELD << JOINT_INDEX_FIELD;
QBuffer buffer;
buffer.open(QIODevice::WriteOnly);
for (auto key : PREFERED_ORDER) {
auto it = mapping.find(key);
if (it != mapping.constEnd()) {
if (key == FREE_JOINT_FIELD) { // writeVariant does not handle strings added using insertMulti.
for (auto multi : mapping.values(key)) {
buffer.write(key.toUtf8());
buffer.write(" = ");
buffer.write(multi.toByteArray());
buffer.write("\n");
}
} else {
writeVariant(buffer, it);
}
}
}
for (auto it = mapping.constBegin(); it != mapping.constEnd(); it++) {
if (!PREFERED_ORDER.contains(it.key())) {
writeVariant(buffer, it);
}
}
return buffer.data();
}
void CyclopsMaster::replyFromSlave(int id, bool error) {
// should identify which request we're replying to
QTcpSocket* client = _slaveToClient.take(id);
QBuffer* slaveBuffer = _slaveReplies.take(id);
QByteArray slaveReply = slaveBuffer->data();
// we can now clear all the connection setup for this (slave, request)
delete slaveBuffer;
QHttp* slaveRequest = (QHttp*)sender();
slaveRequest->deleteLater();
if (error) {
// should get the error string from the QHttp pointer...
clog() << "There seems to be problem with one of the slaves... Exiting...";
emit quit();
return;
}
_pendingRequests[client].replies.append(yaml::load(slaveReply).mapping());
// if we're the last of the slaves to respond, we need to send back the answer to the client
sendReadyReply(client);
}
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);
}
QByteArray CChecksumList::ConvertImageToByteArray(QImage aImage) {
QBuffer vBuffer;
QImageWriter vWriter(&vBuffer, "JPG");
vWriter.write(aImage); // unikniecie vWriter.write(*(*vIterator));
return vBuffer.data();
}
//! [1]
void Dialog::loadFromFile()
{
if (sharedMemory.isAttached())
detach();
ui.label->setText(tr("Select an image file"));
QString fileName = QFileDialog::getOpenFileName(0, QString(), QString(),
tr("Images (*.png *.xpm *.jpg)"));
QImage image;
if (!image.load(fileName)) {
ui.label->setText(tr("Selected file is not an image, please select another."));
return;
}
ui.label->setPixmap(QPixmap::fromImage(image));
//! [1] //! [2]
// load into shared memory
QBuffer buffer;
buffer.open(QBuffer::ReadWrite);
QDataStream out(&buffer);
out << image;
int size = buffer.size();
if (!sharedMemory.create(size)) {
ui.label->setText(tr("Unable to create shared memory segment."));
return;
}
sharedMemory.lock();
char *to = (char*)sharedMemory.data();
const char *from = buffer.data().data();
memcpy(to, from, qMin(sharedMemory.size(), size));
sharedMemory.unlock();
}
void Dialog::loadFromFile()
{
if (sharedMemory.isAttached())
detach();
ui->label->setText(tr("选择一个图片文件！"));
QString fileName = QFileDialog::getOpenFileName(0, QString(), QString(),
tr("Images (*.png *.jpg)"));
QImage image;
if (!image.load(fileName)) {
ui->label->setText(tr("选择的文件不是图片，请选择图片文件！"));
return;
}
ui->label->setPixmap(QPixmap::fromImage(image));
// 将图片加载到共享内存
QBuffer buffer;
buffer.open(QBuffer::ReadWrite);
QDataStream out(&buffer);
out << image;
int size = buffer.size();
if (!sharedMemory.create(size)) {
ui->label->setText(tr("无法创建共享内存段！"));
return;
}
sharedMemory.lock();
char *to = (char*)sharedMemory.data();
const char *from = buffer.data().data();
memcpy(to, from, qMin(sharedMemory.size(), size));
sharedMemory.unlock();
}
void tst_QtWidgets::snapshot()
{
QSKIP("This test doesn't do anything useful at the moment.", SkipAll);
StyleWidget widget(0, Qt::X11BypassWindowManagerHint);
widget.show();
QPixmap pix = QPixmap::grabWidget(&widget);
QVERIFY(!pix.isNull());
QBuffer buf;
pix.save(&buf, "PNG");
QVERIFY(buf.size() > 0);
QString filename = "qtwidgets_" + QHostInfo::localHostName() + "_" + QDateTime::currentDateTime().toString("yyyy.MM.dd_hh.mm.ss") + ".png";
QFtp ftp;
ftp.connectToHost("qt-test-server.qt-test-net");
ftp.login("ftptest", "password");
ftp.cd("qtest/pics");
ftp.put(buf.data(), filename, QFtp::Binary);
ftp.close();
int i = 0;
while (i < 100 && ftp.hasPendingCommands()) {
QCoreApplication::instance()->processEvents();
QTest::qWait(250);
++i;
}
QVERIFY2(ftp.error() == QFtp::NoError, ftp.errorString().toLocal8Bit().constData());
QVERIFY(!ftp.hasPendingCommands());
}
void ChecksumTests::TestCheckFileChecksum() {
gRepository.SetSettings("sqlite3", "database=:memory:");
gRepository.Connect();
gRepository.PopulateDatabase();
Q_INIT_RESOURCE(server_resources); // Use resources from diffrent project
QImage vAddedImage {QImage(":/sample_photo.jpg", "JPG")};
// Part adding image
QBuffer vBufferToStoreData;
QImageWriter vWriter(&vBufferToStoreData, "JPG");
vWriter.write(vAddedImage);
QByteArray vAddedData {vBufferToStoreData.data()};
uint16_t vChecksumAddImage = CalculateChecksumHelper::CalculateFileDataChecksum(
vAddedData);
CStorePhotoTransaction vStoreTransaction(
vAddedData, vAddedData.size(), vChecksumAddImage);
vStoreTransaction.Execute();
CChecksumList *vChecksumList {gRepository.GetChecksumList()};
QVERIFY(vChecksumList->CheckFileChecksum(vChecksumAddImage));
}
void RemoteConnection::sendCommand(const RemoteCommand& command)
{
protocolDebug() << qPrintable(QTime::currentTime().toString(QString::fromUtf8("hh:mm:ss.zzz")))
<< ": Sending " << QString::number((int) command.commandType());
Q_ASSERT(QThread::currentThread() == qApp->thread());
if (!isConnected())
return;
// Stream into a buffer so we can send length of buffer over
// this is to ensure the remote side gets all data before it
// starts to demarshal the data.
QBuffer buffer;
buffer.open(QIODevice::WriteOnly);
QDataStream stream(&buffer);
// stream a placeholder for the length
stream << (qint32) 0;
// Steam the id and the data
stream << (qint32) command.commandType();
command.encode(stream);
// Wind back and stream the length
stream.device()->seek(0);
stream << (qint32) buffer.size();
// Send the data.
socket()->write(buffer.data());
socket()->flush();
}
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;
}
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());
}
bool CoverUtils::saveImage(const QImage &image, Album *album) {
QImage scaledImage = maybeScaleImage(image);
QBuffer buffer;
scaledImage.save(&buffer, "JPG");
album->setPhoto(buffer.data());
return true;
}
void XMLSaveVisitor::saveForm(std::string path, std::string projectName, QImage & picture){
std::fstream file(path.c_str(),std::fstream::out);
file << "<project name=\""<< projectName << "\" ver=\"1.0\">" << std::endl;
file << "<monofin>" << std::endl;
file << _surface;
file << "<layers>" << std::endl;
file << "</layers>" << std::endl;
file << "</monofin>" << std::endl;
file << "<config>" << std::endl;
file << "<layerConfig>" << std::endl;
file << "</layerConfig>" << std::endl;
file << "</config>" << std::endl;
QBuffer test;
test.open(QIODevice::WriteOnly);
picture.save(&test,"XBM");
QString sauvegarde(test.data());
file << "<picture data=\"" << sauvegarde.toStdString() << "\"/>" << std::endl;
file << "</project>" << std::endl;
file.close();
}
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());
}
QByteArray Clip::toBuffer(const Clip::ConstPointer& clip) {
QBuffer buffer;
if (buffer.open(QFile::Truncate | QFile::WriteOnly)) {
clip->duplicate()->write(buffer);
buffer.close();
}
return buffer.data();
}
QJsonValue jsonValFromPixmap(const QPixmap & p) {
QByteArray data;
QBuffer buffer { &data };
buffer.open(QIODevice::WriteOnly);
p.save(&buffer, "PNG");
auto encoded = buffer.data().toBase64();
return QJsonValue(QString::fromLatin1(encoded));
}
void PrivateStorage::setXml(const QXmppElement &element)
{
QBuffer buffer;
buffer.open(QIODevice::WriteOnly);
QXmlStreamWriter writer(&buffer);
element.toXml(&writer);
m_data = QString::fromUtf8(buffer.data());
}
QString RFileCache::getContents(const QString& fileName, bool forceReload) {
QBuffer* buffer = getBuffer(fileName, forceReload);
if (buffer==NULL) {
return QString();
}
return QString::fromUtf8((const char*)buffer->data());
}
void ShiftCoreTest::serialisationJsonTest()
{
TestDatabase db;
auto rootA = db.addChild<Shift::Entity>();
buildTestData(rootA);
QBuffer buffer;
Shift::SaveBuilder builder;
Shift::JSONSaver writer;
writer.setAutoWhitespace(true);
QBENCHMARK {
buffer.setData(QByteArray());
buffer.open(QIODevice::ReadWrite);
Eks::String data;
auto block = writer.beginWriting(&data);
builder.save(rootA, false, &writer);
buffer.write(data.data(), data.size());
buffer.close();
}
#define SAVE_OUTPUTx
#ifdef SAVE_OUTPUT
{
QFileInfo path("./SerialisationTest.json");
qDebug() << path.absoluteFilePath();
QFile output(path.absoluteFilePath());
QCOMPARE(output.open(QFile::WriteOnly), true);
output.write(buffer.data());
}
#endif
QFile expected(":/Serialisation/SerialisationTest.json");
QCOMPARE(expected.open(QFile::ReadOnly), true);
QString savedOutput(buffer.data());
QString expectedOutput(expected.readAll());
QCOMPARE(checkStrings(savedOutput, expectedOutput), true);
}
