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);
}
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 ScProcess::onIpcData()
{
mIpcData.append(mIpcSocket->readAll());
while (mIpcData.size()) {
QBuffer receivedData ( &mIpcData );
receivedData.open ( QIODevice::ReadOnly );
QDataStream in ( &receivedData );
in.setVersion ( QDataStream::Qt_4_6 );
QString selector, message;
in >> selector;
if ( in.status() != QDataStream::Ok )
return;
in >> message;
if ( in.status() != QDataStream::Ok )
return;
mIpcData.remove ( 0, receivedData.pos() );
onResponse(selector, message);
emit response(selector, message);
}
}
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();
}
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
CollectionScanner::ScanningState::readFull()
{
if( !isValid() )
return;
QBuffer buffer;
QDataStream in(&buffer);
m_sharedMemory->lock();
buffer.setData((char*)m_sharedMemory->constData(), m_sharedMemory->size());
buffer.open(QBuffer::ReadOnly);
in >> m_lastDirectory;
in >> m_directories;
in >> m_badFiles;
m_lastFilePos = buffer.pos();
in >> m_lastFile;
m_sharedMemory->unlock();
}
//--------------------------------------------------------------------
void tst_QIODevice::unget()
{
#if defined(Q_OS_WINCE) && defined(WINCE_EMULATOR_TEST)
QSKIP("Networking tests in a WinCE emulator are unstable", SkipAll);
#endif
QBuffer buffer;
buffer.open(QBuffer::ReadWrite);
buffer.write("ZXCV");
buffer.seek(0);
QCOMPARE(buffer.read(4), QByteArray("ZXCV"));
QCOMPARE(buffer.pos(), qint64(4));
buffer.ungetChar('a');
buffer.ungetChar('b');
buffer.ungetChar('c');
buffer.ungetChar('d');
QCOMPARE(buffer.pos(), qint64(0));
char buf[6];
QCOMPARE(buffer.readLine(buf, 5), qint64(4));
QCOMPARE(buffer.pos(), qint64(4));
QCOMPARE(static_cast<const char*>(buf), "dcba");
buffer.ungetChar('a');
buffer.ungetChar('b');
buffer.ungetChar('c');
buffer.ungetChar('d');
QCOMPARE(buffer.pos(), qint64(0));
for (int i = 0; i < 5; ++i) {
buf[0] = '@';
buf[1] = '@';
QTest::ignoreMessage(QtWarningMsg,
"QIODevice::readLine: Called with maxSize < 2");
QCOMPARE(buffer.readLine(buf, 1), qint64(-1));
QCOMPARE(buffer.readLine(buf, 2), qint64(i < 4 ? 1 : -1));
switch (i) {
case 0:
QCOMPARE(buf[0], 'd');
break;
case 1:
QCOMPARE(buf[0], 'c');
break;
case 2:
QCOMPARE(buf[0], 'b');
break;
case 3:
QCOMPARE(buf[0], 'a');
break;
case 4:
QCOMPARE(buf[0], '\0');
break;
}
QCOMPARE(buf[1], i < 4 ? '\0' : '@');
}
buffer.ungetChar('\n');
QCOMPARE(buffer.readLine(), QByteArray("\n"));
buffer.seek(1);
buffer.readLine(buf, 3);
QCOMPARE(static_cast<const char*>(buf), "XC");
buffer.seek(4);
buffer.ungetChar('Q');
QCOMPARE(buffer.readLine(buf, 3), qint64(1));
for (int i = 0; i < 2; ++i) {
QTcpSocket socket;
QIODevice *dev;
QByteArray result;
const char *lineResult;
if (i == 0) {
dev = &buffer;
result = QByteArray("ZXCV");
lineResult = "ZXCV";
} else {
socket.connectToHost(QtNetworkSettings::serverName(), 80);
socket.write("GET / HTTP/1.0\r\n\r\n");
QVERIFY(socket.waitForReadyRead());
dev = &socket;
result = QByteArray("HTTP");
lineResult = "Date";
}
char ch, ch2;
dev->seek(0);
dev->getChar(&ch);
dev->ungetChar(ch);
QCOMPARE(dev->peek(4), result);
dev->getChar(&ch);
dev->getChar(&ch2);
dev->ungetChar(ch2);
dev->ungetChar(ch);
QCOMPARE(dev->read(1), result.left(1));
QCOMPARE(dev->read(3), result.right(3));
if (i == 0)
dev->seek(0);
else
dev->readLine();
dev->getChar(&ch);
dev->ungetChar(ch);
dev->readLine(buf, 5);
QCOMPARE(static_cast<const char*>(buf), lineResult);
if (i == 1)
socket.close();
}
}
bool loadMetaInfo()
{
LOG("mFormatHint" << mFormatHint);
QBuffer buffer;
buffer.setBuffer(&mData);
buffer.open(QIODevice::ReadOnly);
#ifdef KDCRAW_FOUND
if (KDcrawIface::KDcraw::rawFilesList().contains(QString(mFormatHint))) {
QByteArray previewData;
// if the image is in format supported by dcraw, fetch its embedded preview
mJpegContent.reset(new JpegContent());
// use KDcraw for getting the embedded preview
// KDcraw functionality cloned locally (temp. solution)
bool ret = KDcrawIface::KDcraw::loadEmbeddedPreview(previewData, buffer);
QImage originalImage;
if (!ret || !originalImage.loadFromData(previewData) || qMin(originalImage.width(), originalImage.height()) < MIN_PREV_SIZE) {
// if the embedded preview loading failed or gets just a small image, load
// half preview instead. That's slower but it works even for images containing
// small (160x120px) or none embedded preview.
if (!KDcrawIface::KDcraw::loadHalfPreview(previewData, buffer)) {
qWarning() << "unable to get half preview for " << q->document()->url().fileName();
return false;
}
}
buffer.close();
// now it's safe to replace mData with the jpeg data
mData = previewData;
// need to fill mFormat so gwenview can tell the type when trying to save
mFormat = mFormatHint;
} else {
#else
{
#endif
QImageReader reader(&buffer, mFormatHint);
mImageSize = reader.size();
if (!reader.canRead()) {
qWarning() << "QImageReader::read() using format hint" << mFormatHint << "failed:" << reader.errorString();
if (buffer.pos() != 0) {
qWarning() << "A bad Qt image decoder moved the buffer to" << buffer.pos() << "in a call to canRead()! Rewinding.";
buffer.seek(0);
}
reader.setFormat(QByteArray());
// Set buffer again, otherwise QImageReader won't restart from scratch
reader.setDevice(&buffer);
if (!reader.canRead()) {
qWarning() << "QImageReader::read() without format hint failed:" << reader.errorString();
return false;
}
qWarning() << "Image format is actually" << reader.format() << "not" << mFormatHint;
}
mFormat = reader.format();
if (mFormat == "jpg") {
// if mFormatHint was "jpg", then mFormat is "jpg", but the rest of
// Gwenview code assumes JPEG images have "jpeg" format.
mFormat = "jpeg";
}
}
LOG("mFormat" << mFormat);
GV_RETURN_VALUE_IF_FAIL(!mFormat.isEmpty(), false);
Exiv2ImageLoader loader;
if (loader.load(mData)) {
mExiv2Image = loader.popImage();
}
if (mFormat == "jpeg" && mExiv2Image.get()) {
mJpegContent.reset(new JpegContent());
}
if (mJpegContent.get()) {
if (!mJpegContent->loadFromData(mData, mExiv2Image.get()) &&
!mJpegContent->loadFromData(mData)) {
qWarning() << "Unable to use preview of " << q->document()->url().fileName();
return false;
}
// Use the size from JpegContent, as its correctly transposed if the
// image has been rotated
mImageSize = mJpegContent->size();
mCmsProfile = Cms::Profile::loadFromExiv2Image(mExiv2Image.get());
}
LOG("mImageSize" << mImageSize);
if (!mCmsProfile) {
mCmsProfile = Cms::Profile::loadFromImageData(mData, mFormat);
}
return true;
}
void loadImageData()
{
QBuffer buffer;
buffer.setBuffer(&mData);
buffer.open(QIODevice::ReadOnly);
QImageReader reader(&buffer, mFormat);
LOG("mImageDataInvertedZoom=" << mImageDataInvertedZoom);
if (mImageSize.isValid()
&& mImageDataInvertedZoom != 1
&& reader.supportsOption(QImageIOHandler::ScaledSize)
) {
// Do not use mImageSize here: QImageReader needs a non-transposed
// image size
QSize size = reader.size() / mImageDataInvertedZoom;
if (!size.isEmpty()) {
LOG("Setting scaled size to" << size);
reader.setScaledSize(size);
} else {
LOG("Not setting scaled size as it is empty" << size);
}
}
bool ok = reader.read(&mImage);
if (!ok) {
LOG("QImageReader::read() failed");
return;
}
if (mJpegContent.get() && GwenviewConfig::applyExifOrientation()) {
Gwenview::Orientation orientation = mJpegContent->orientation();
QMatrix matrix = ImageUtils::transformMatrix(orientation);
mImage = mImage.transformed(matrix);
}
if (reader.supportsAnimation()
&& reader.nextImageDelay() > 0 // Assume delay == 0 <=> only one frame
) {
/*
* QImageReader is not really helpful to detect animated gif:
* - QImageReader::imageCount() returns 0
* - QImageReader::nextImageDelay() may return something > 0 if the
* image consists of only one frame but includes a "Graphic
* Control Extension" (usually only present if we have an
* animation) (Bug #185523)
*
* Decoding the next frame is the only reliable way I found to
* detect an animated gif
*/
LOG("May be an animated image. delay:" << reader.nextImageDelay());
QImage nextImage;
if (reader.read(&nextImage)) {
LOG("Really an animated image (more than one frame)");
mAnimated = true;
} else {
qWarning() << q->document()->url() << "is not really an animated image (only one frame)";
}
}
}
void Server::riceviMessaggio()
{
QTcpSocket* socket;
QBuffer* buffer;
QByteArray line;
socket = (QTcpSocket*)(sender());
buffer = buffers.value(socket);
qint64 bytes = buffer->write(socket->readAll()); //Per la ricezione del messaggio.
buffer->seek(buffer->pos() - bytes);
while (buffer->canReadLine()) //Leggo fino a quando sono presenti linee di testo.
{
line = buffer->readLine();
if(line.startsWith('#')) //Richiesta di autenticazione.
{
db = QSqlDatabase::addDatabase("QSQLITE");
db.setDatabaseName("./users.sqldb");
if (!db.open()) {
socket->write("#false");
}
QSqlQuery s;
QString nome;
QString password;
QList<QByteArray> nomepassword;
nomepassword = line.split('/');
nome = nomepassword[1];
password = nomepassword[2];
password = password.remove("\n");
s.prepare("SELECT Username FROM Utenti WHERE Username = '******' AND Password = '******'");
s.exec();
s.next();
QString username = s.value(0).toString();
if(username != "")
{
socket->write("#true\n");
}
else
{
socket->write("#false\n");
}
db.close();
}
else if(line.startsWith('!')) //Richiesta di iscrizione.
{
QString nome;
QString password;
QList<QByteArray> nomepassword = line.split('/');
db = QSqlDatabase::addDatabase("QSQLITE");
db.setDatabaseName("./users.sqldb");
db.open();
QSqlQuery s;
nome = nomepassword[1];
password = nomepassword[2];
password = password.remove("\n");
s.prepare("INSERT INTO Utenti VALUES ('" + nome + "', '" + password + "')");
s.exec();
db.close();
}
else
foreach (QTcpSocket* connection, connections)
{
connection->write(line); //Invio il testo ricevuto a un'altra connessione.
}
}
