bool QNonContiguousByteDeviceIoDeviceImpl::advanceReadPointer(qint64 amount)
{
totalAdvancements += amount;
// normal advancement
currentReadBufferPosition += amount;
if (size() == -1)
emit readProgress(totalAdvancements, totalAdvancements);
else
emit readProgress(totalAdvancements, size());
// advancing over that what has actually been read before
if (currentReadBufferPosition > currentReadBufferAmount) {
qint64 i = currentReadBufferPosition - currentReadBufferAmount;
while (i > 0) {
if (device->getChar(0) == false) {
emit readProgress(totalAdvancements - i, size());
return false; // ### FIXME handle eof
}
i--;
}
currentReadBufferPosition = 0;
currentReadBufferAmount = 0;
}
return true;
}
// FIXME we should scrap this whole implementation and instead change the ByteArrayImpl to be able to cope with sub-arrays?
QNonContiguousByteDeviceBufferImpl::QNonContiguousByteDeviceBufferImpl(QBuffer *b) : QNonContiguousByteDevice()
{
buffer = b;
byteArray = QByteArray::fromRawData(buffer->buffer().constData() + buffer->pos(), buffer->size() - buffer->pos());
arrayImpl = new QNonContiguousByteDeviceByteArrayImpl(&byteArray);
arrayImpl->setParent(this);
connect(arrayImpl, SIGNAL(readyRead()), SIGNAL(readyRead()));
connect(arrayImpl, SIGNAL(readProgress(qint64,qint64)), SIGNAL(readProgress(qint64,qint64)));
}
/* virtual */
void XMLerLoadFileThread::run ()
{
QFile xml( fileName() );
if ( !xml.exists() ) {
emit error ( tr("File %1 does not exists.").arg( fileName() ) );
return;
}
/* QMap<QString, QString> info = getInformationFromFile(); */
QXmlSimpleReader reader;
XMLerInputSource *source = new XMLerInputSource ( &xml );
/* connect source to slots in model */
connect ( source, SIGNAL(beginRead(qint64)), this, SLOT(on_beginProgress(qint64)) );
connect ( source, SIGNAL(readProgress(qint64)), this, SLOT(on_progress(qint64)) );
connect ( source, SIGNAL(endRead()), this, SLOT(on_endProgress()) );
reader.setContentHandler ( handler );
reader.setErrorHandler ( handler );
bool parseResult = reader.parse ( source, true );
/* FIXME: this is partial read */
if ( parseResult ) {
bool partResult = parseResult;
while ( partResult )
partResult = reader.parseContinue();
}
if ( !parseResult ) {
checkExceptionInHandler();
on_endProgress();
return;
}
/* set addition data (information) in document */
if ( handler->document() )
handler->document()->setFileName( fileName() );
/* CLEANIT
if ( !info.isEmpty() ) {
if ( info.contains ( "encoding" ) )
handler->document()->setCodec ( info.value ( "encoding" ) );
if ( info.contains ( "version" ) )
handler->document()->setVersion ( info.value ( "version" ) );
}*/
emit done ( handler->document() );
checkExceptionInHandler ();
/* clean */
disconnect ( source, SIGNAL(beginRead(qint64)) );
disconnect ( source, SIGNAL(readProgress(qint64)) );
disconnect ( source, SIGNAL(endRead()) );
delete source;
}
const char* QNonContiguousByteDeviceIoDeviceImpl::readPointer(qint64 maximumLength, qint64 &len)
{
if (eof == true) {
len = -1;
return 0;
}
if (currentReadBuffer == 0)
currentReadBuffer = new QByteArray(currentReadBufferSize, '\0'); // lazy alloc
if (maximumLength == -1)
maximumLength = currentReadBufferSize;
if (currentReadBufferAmount - currentReadBufferPosition > 0) {
len = currentReadBufferAmount - currentReadBufferPosition;
return currentReadBuffer->data() + currentReadBufferPosition;
}
qint64 haveRead = device->read(currentReadBuffer->data(), qMin(maximumLength, currentReadBufferSize));
if ((haveRead == -1) || (haveRead == 0 && device->atEnd() && !device->isSequential())) {
eof = true;
len = -1;
// size was unknown before, emit a readProgress with the final size
if (size() == -1)
emit readProgress(totalAdvancements, totalAdvancements);
return 0;
}
currentReadBufferAmount = haveRead;
currentReadBufferPosition = 0;
len = haveRead;
return currentReadBuffer->data();
}
QNonContiguousByteDevice* QNetworkAccessBackend::createUploadByteDevice()
{
QNonContiguousByteDevice* device = 0;
if (reply->outgoingDataBuffer)
device = QNonContiguousByteDeviceFactory::create(reply->outgoingDataBuffer);
else if (reply->outgoingData) {
device = QNonContiguousByteDeviceFactory::create(reply->outgoingData);
} else {
return 0;
}
bool bufferDisallowed =
reply->request.attribute(QNetworkRequest::DoNotBufferUploadDataAttribute,
QVariant(false)) == QVariant(true);
if (bufferDisallowed)
device->disableReset();
// make sure we delete this later
device->setParent(this);
connect(device, SIGNAL(readProgress(qint64,qint64)), this, SLOT(emitReplyUploadProgress(qint64,qint64)));
return device;
}
void SceneFileHandlerBase::updateReadProgress(void)
{
if(_readProgressFP == NULL)
return;
if(_useProgressThread)
return;
readProgress(NULL);
}
QNonContiguousByteDevice* QNetworkAccessBackend::createUploadByteDevice()
{
if (reply->outgoingDataBuffer)
uploadByteDevice = QNonContiguousByteDeviceFactory::createShared(reply->outgoingDataBuffer);
else if (reply->outgoingData) {
uploadByteDevice = QNonContiguousByteDeviceFactory::createShared(reply->outgoingData);
} else {
return 0;
}
// We want signal emissions only for normal asynchronous uploads
if (!isSynchronous())
connect(uploadByteDevice.data(), SIGNAL(readProgress(qint64,qint64)), this, SLOT(emitReplyUploadProgress(qint64,qint64)));
return uploadByteDevice.data();
}
void MusicScanner::scan(const QString &folder, const QString &cacheFile, bool readCache, const QSet<FileOnlySong> &existingSongs)
{
lastCacheProg=-1;
if (!cacheFile.isEmpty() && readCache) {
MusicLibraryItemRoot *lib=new MusicLibraryItemRoot;
MusicLibraryModel::convertCache(cacheFile);
readProgress(0.0);
if (lib->fromXML(cacheFile, QDateTime(), folder)) {
lib->applyGrouping();
if (!stopRequested) {
emit libraryUpdated(lib);
} else {
delete lib;
}
return;
} else {
delete lib;
}
}
if (stopRequested) {
return;
}
count=0;
lastUpdate=0;
MusicLibraryItemRoot *library = new MusicLibraryItemRoot;
QString topLevel=Utils::fixPath(QDir(folder).absolutePath());
QSet<FileOnlySong> existing=existingSongs;
scanFolder(library, topLevel, topLevel, existing, 0);
if (!stopRequested) {
library->applyGrouping();
if (!cacheFile.isEmpty()) {
writeProgress(0.0);
library->toXML(cacheFile, QDateTime(), this);
}
emit libraryUpdated(library);
} else {
delete library;
}
}
QNonContiguousByteDevice* QNetworkAccessBackend::createUploadByteDevice()
{
if (reply->outgoingDataBuffer)
uploadByteDevice = QSharedPointer<QNonContiguousByteDevice>(QNonContiguousByteDeviceFactory::create(reply->outgoingDataBuffer));
else if (reply->outgoingData) {
uploadByteDevice = QSharedPointer<QNonContiguousByteDevice>(QNonContiguousByteDeviceFactory::create(reply->outgoingData));
} else {
return 0;
}
bool bufferDisallowed =
reply->request.attribute(QNetworkRequest::DoNotBufferUploadDataAttribute,
QVariant(false)) == QVariant(true);
if (bufferDisallowed)
uploadByteDevice->disableReset();
// We want signal emissions only for normal asynchronous uploads
if (!isSynchronous())
connect(uploadByteDevice.data(), SIGNAL(readProgress(qint64,qint64)), this, SLOT(emitReplyUploadProgress(qint64,qint64)));
return uploadByteDevice.data();
}
// --- DOWNLOAD CONTENT ---
// Download the content provided in a QNetworkReply in a separate thread.
void MainWindow::downloadContent(QNetworkReply* reply) {
// Ask for path to save to.
QString path = QFileDialog::getSaveFileName(this, tr("Save to..."), savedir.path());
if (path.isEmpty()) {
reply->deleteLater();
return;
}
savedir.setPath(path);
// Launch download dialogue
QProgressDialog* progress = new QProgressDialog(tr("Downloading %1").arg(reply->url().path()), tr("Cancel"), 0, reply->size());
IOFile* file = new IOFile;
file->setFileName(path);
file->open(QIODevice::WriteOnly);
connect(reply, SIGNAL(finished()), progress, SLOT(hide()));
connect(reply, SIGNAL(finished()), progress, SLOT(deleteLater()));
connect(reply, SIGNAL(readyRead()), file, SLOT(readFromReply()));
connect(reply, SIGNAL(downloadProgress(qint64,qint64)), file, SLOT(readProgress(qint64,qint64)));
connect(reply, SIGNAL(finished()), file, SLOT(terminate()));
connect(reply, SIGNAL(finished()), reply, SLOT(deleteLater()));
connect(file, SIGNAL(progress(int)), progress, SLOT(setValue(int)));
connect(progress, SIGNAL(canceled()), file, SLOT(cancel()));
}
void MusicScanner::scan(const QString &folder, const QString &cacheFile, bool readCache, const QSet<FileOnlySong> &existingSongs)
{
if (!cacheFile.isEmpty() && readCache) {
MusicLibraryItemRoot *lib=new MusicLibraryItemRoot;
readProgress(0.0);
if (lib->fromXML(cacheFile, 0, 0, folder)) {
if (!stopRequested) {
emit libraryUpdated(lib);
} else {
delete lib;
}
return;
} else {
delete lib;
}
}
if (stopRequested) {
return;
}
count=0;
MusicLibraryItemRoot *library = new MusicLibraryItemRoot;
QString topLevel=Utils::fixPath(QDir(folder).absolutePath());
QSet<FileOnlySong> existing=existingSongs;
timer.start();
scanFolder(library, topLevel, topLevel, existing, 0);
if (!stopRequested) {
if (!cacheFile.isEmpty()) {
writeProgress(0.0);
library->toXML(cacheFile, 0, false, this);
}
emit libraryUpdated(library);
} else {
delete library;
}
}
bool QNonContiguousByteDeviceRingBufferImpl::advanceReadPointer(qint64 amount)
{
currentPosition += amount;
emit readProgress(currentPosition, size());
return true;
}
AniseCommunicator::~AniseCommunicator() {
disconnect(anise_process, SIGNAL(readyRead()), this, SLOT(readProgress()));
disconnect(anise_process, SIGNAL(finished(int)), this, SLOT(finished(int)));
delete anise_process;
}
AniseCommunicator::AniseCommunicator() {
onProgress = false;
connect(anise_process, SIGNAL(readyRead()), this, SLOT(readProgress()));
connect(anise_process, SIGNAL(finished(int)), this, SLOT(finished(int)));
}
