// watcher void CoverArtCache::coverLoaded() { QFutureWatcher<FutureResult>* watcher; watcher = reinterpret_cast<QFutureWatcher<FutureResult>*>(sender()); FutureResult res = watcher->result(); if (sDebug) { kLogger.debug() << "coverLoaded" << res.cover; } // Don't cache full size covers (resizedToWidth = 0) // Large cover art wastes space in our cache and will likely // uncache a lot of the small covers we need in the library // table. // Full size covers are used in the Skin Widgets, which are // loaded with an artificial delay anyway and an additional // re-load delay can be accepted. // Create pixmap, GUI thread only QPixmap pixmap = QPixmap::fromImage(res.cover.image); if (!pixmap.isNull() && res.cover.resizedToWidth != 0) { // we have to be sure that res.cover.hash is unique // because insert replaces the images with the same key QString cacheKey = pixmapCacheKey( res.cover.hash, res.cover.resizedToWidth); QPixmapCache::insert(cacheKey, pixmap); } m_runningRequests.remove(qMakePair(res.pRequestor, res.cover.hash)); if (res.signalWhenDone) { emit(coverFound(res.pRequestor, res.cover, pixmap, false)); } }
void KWin::Script::slotScriptLoadedFromFile() { QFutureWatcher<QByteArray> *watcher = dynamic_cast< QFutureWatcher< QByteArray>* >(sender()); if (!watcher) { // not invoked from a QFutureWatcher return; } if (watcher->result().isNull()) { // do not load empty script deleteLater(); watcher->deleteLater(); return; } QScriptValue optionsValue = m_engine->newQObject(options, QScriptEngine::QtOwnership, QScriptEngine::ExcludeSuperClassContents | QScriptEngine::ExcludeDeleteLater); m_engine->globalObject().setProperty(QStringLiteral("options"), optionsValue, QScriptValue::Undeletable); m_engine->globalObject().setProperty(QStringLiteral("QTimer"), constructTimerClass(m_engine)); QObject::connect(m_engine, SIGNAL(signalHandlerException(QScriptValue)), this, SLOT(sigException(QScriptValue))); KWin::MetaScripting::supplyConfig(m_engine); installScriptFunctions(m_engine); QScriptValue ret = m_engine->evaluate(QString::fromUtf8(watcher->result())); if (ret.isError()) { sigException(ret); deleteLater(); } watcher->deleteLater(); setRunning(true); m_starting = false; }
void PatternManager::thresholdImageFinished() { QFutureWatcher<cv::Mat*>* watcher = static_cast<QFutureWatcher<cv::Mat*>*>(QObject::sender()); this->m_thresholdedPatterns.push_back(watcher->result()); qDebug() << "Image thresholded " << watcher->result()->depth(); delete watcher; emit imgThresholded(this->m_thresholdedPatterns.size()); if(this->m_thresholdedPatterns.size() == patternSetSize) { emit originalPatternsThresholded(); qDebug("All images thresholded"); } }
void EditTagDialog::SetSongsFinished() { QFutureWatcher<QList<Data> >* watcher = dynamic_cast<QFutureWatcher<QList<Data> >*>(sender()); if (!watcher) return; watcher->deleteLater(); if (!SetLoading(QString())) return; data_ = watcher->result(); if (data_.count() == 0) { // If there were no valid songs, disable everything ui_->song_list->setEnabled(false); ui_->tab_widget->setEnabled(false); // Show a summary with empty information UpdateSummaryTab(Song()); ui_->tab_widget->setCurrentWidget(ui_->summary_tab); SetSongListVisibility(false); return; } // Add the filenames to the list for (const Data& data : data_) { ui_->song_list->addItem(data.current_.basefilename()); } // Select all ui_->song_list->setCurrentRow(0); ui_->song_list->selectAll(); // Hide the list if there's only one song in it SetSongListVisibility(data_.count() != 1); }
void downloadFile() { QTemporaryFile file; file.setAutoRemove(false); if (file.open()) { const QString filename = file.fileName(); QInstaller::blockingWrite(&file, QByteArray(scLargeSize, '1')); file.close(); DownloadFileTask fileTask(QLatin1String("file:///") + filename); QFutureWatcher<FileTaskResult> watcher; QSignalSpy started(&watcher, SIGNAL(started())); QSignalSpy finished(&watcher, SIGNAL(finished())); QSignalSpy progress(&watcher, SIGNAL(progressValueChanged(int))); watcher.setFuture(QtConcurrent::run(&DownloadFileTask::doTask, &fileTask)); watcher.waitForFinished(); QTest::qWait(10); // Spin the event loop to deliver queued signals. QCOMPARE(started.count(), 1); QCOMPARE(finished.count(), 1); FileTaskResult result = watcher.result(); QCOMPARE(watcher.future().resultCount(), 1); QVERIFY(QFile(result.target()).exists()); QCOMPARE(file.size(), QFile(result.target()).size()); QCOMPARE(result.checkSum().toHex(), QByteArray("85304f87b8d90554a63c6f6d1e9cc974fbef8d32")); } }
void SpellCheckerCore::futureFinished() { /* Get the watcher from the sender() of the signal that invoked this slot. * reinterpret_cast is used since qobject_cast is not valid of template * classes since the template class does not have the Q_OBJECT macro. */ QFutureWatcher<WordList>* watcher = reinterpret_cast<QFutureWatcher<WordList>*>( sender() ); if( watcher == nullptr ) { return; } if( d->shuttingDown == true ) { /* Application shutting down, should not try something */ return; } if( watcher->isCanceled() == true ) { /* Application is shutting down */ return; } /* Get the list of words with spelling mistakes from the future. */ WordList checkedWords = watcher->result(); QMutexLocker locker( &d->futureMutex ); /* Recheck again after getting the lock. */ if( d->shuttingDown == true ) { return; } /* Get the file name associated with this future and the misspelled * words. */ FutureWatcherMapIter iter = d->futureWatchers.find( watcher ); if( iter == d->futureWatchers.end() ) { return; } QString fileName = iter.value(); /* Remove the watcher from the list of running watchers and the file that * kept track of the file getting spell checked. */ d->futureWatchers.erase( iter ); d->filesInProcess.removeAll( fileName ); /* Check if the file was scheduled for a re-check. As discussed previously, * if a spell check was requested for a file that had a future already in * progress, it was scheduled for a re-check as soon as the in progress one * completes. If it was scheduled, restart it using the normal slot. */ QHash<QString, WordList>::iterator waitingIter = d->filesWaitingForProcess.find( fileName ); if( waitingIter != d->filesWaitingForProcess.end() ) { WordList wordsToSpellCheck = waitingIter.value(); /* remove the file and words from the scheduled list. */ d->filesWaitingForProcess.erase( waitingIter ); locker.unlock(); /* Invoke the method to make sure that it gets called from the main thread. * This will most probably be already in the main thread, but to make sure * it is done like this. */ this->metaObject()->invokeMethod( this , "spellcheckWordsFromParser" , Qt::QueuedConnection , Q_ARG( QString, fileName ) , Q_ARG( SpellChecker::WordList, wordsToSpellCheck ) ); } locker.unlock(); watcher->deleteLater(); /* Add the list of misspelled words to the mistakes model */ addMisspelledWords( fileName, checkedWords ); }
void DocsetRegistry::loadDocset(const QString &path) { QFutureWatcher<Docset *> *watcher = new QFutureWatcher<Docset *>(); connect(watcher, &QFutureWatcher<Docset *>::finished, this, [this, watcher] { QScopedPointer<QFutureWatcher<Docset *>, QScopedPointerDeleteLater> guard(watcher); Docset *docset = watcher->result(); // TODO: Emit error if (!docset->isValid()) { qWarning("Could not load docset from '%s'. Reinstall the docset.", qPrintable(docset->path())); delete docset; return; } docset->setFuzzySearchEnabled(m_fuzzySearchEnabled); const QString name = docset->name(); if (m_docsets.contains(name)) { unloadDocset(name); } m_docsets[name] = docset; emit docsetLoaded(name); }); watcher->setFuture(QtConcurrent::run([path] { return new Docset(path); })); }
QVariant ThumbnailModel::data(const QModelIndex &index, int role) const { if (role == Qt::DecorationRole && index.isValid()) { QString id = itemId(index).toString(); QFutureWatcher<QImage> *future = cache.object(id); if (!future) { future = new QFutureWatcher<QImage>; QString path = imagePath(index); if (!path.isEmpty()) { future->setFuture(QtConcurrent::run(ThumbnailModel::load, path)); connect(future, SIGNAL(finished()), this, SLOT(thumbnailLoaded())); } cache.insert(id, future); } return !future->isCanceled() ? future->result() : QVariant(); } else { return QGalleryQueryModel::data(index, role); } }
void Fix8Log::finishedReadingDataFileSlot() { qDebug() << "Finishded future reading.."; QFutureWatcher<FutureReadData *> *watcher = (QFutureWatcher<FutureReadData *> *)sender(); FutureReadData *frd = watcher->result(); }
sqlqueryresultlist searchhandler::perform_grep(QString searchtxt, sqlqueryresultlist searchlist, bool exactmatch) { QVector<QString> strvec; sqlqueryresultlist resultlist; QFutureWatcher<sqlqueryresultlist> futureWatcher; QProgressDialog dialog; unsigned int n = searchlist.resultlist.size(); if (n == 0) return resultlist; strvec.resize(n); for (unsigned int i=0; i < n; i++) { strvec.replace(i, str2qt(searchlist.resultlist[i].filepath)); } dialog.setAutoReset(false); dialog.setLabelText(QString("Grep ").append(QString(tr("in progress"))).append(QString(" ..."))); dialog.setCancelButtonText(tr("Cancel")); QObject::connect(&futureWatcher, SIGNAL(finished()), &dialog, SLOT(reset())); QObject::connect(&dialog, SIGNAL(canceled()), &futureWatcher, SLOT(cancel())); QObject::connect(&futureWatcher, SIGNAL(progressRangeChanged(int,int)), &dialog, SLOT(setRange(int,int))); QObject::connect(&futureWatcher, SIGNAL(progressValueChanged(int)), &dialog, SLOT(setValue(int))); m_grepExactMatch = exactmatch; (*m_grepRegExp) = QRegExp(searchtxt.toAscii().data(), Qt::CaseInsensitive); m_grepRegExp->setPatternSyntax(QRegExp::RegExp2); futureWatcher.setFuture(QtConcurrent::mappedReduced(strvec, doGrep, collateGrep, QtConcurrent::SequentialReduce)); dialog.exec(); futureWatcher.waitForFinished(); if (futureWatcher.isCanceled() == false) resultlist = futureWatcher.result(); return resultlist; }
void tst_QFutureWatcher::resultAt() { QFutureWatcher<int> futureWatcher; futureWatcher.setFuture((new IntTask())->start()); futureWatcher.waitForFinished(); QCOMPARE(futureWatcher.result(), 10); QCOMPARE(futureWatcher.resultAt(0), 10); }
void TagCompleter::ModelReady() { QFutureWatcher<TagCompletionModel*>* watcher = dynamic_cast<QFutureWatcher<TagCompletionModel*>*>(sender()); if (!watcher) return; TagCompletionModel* model = watcher->result(); setModel(model); setCaseSensitivity(Qt::CaseInsensitive); editor_->setCompleter(this); }
void AttachDialog::updateProcessesFinished() { QFutureWatcher<ProcDataList>* watcher = dynamic_cast<QFutureWatcher<ProcDataList>*>(sender()); Q_ASSERT(watcher); ui.stackedWidget->setCurrentWidget(ui.listViewPage); const int oldPid = pid(); m_model->mergeProcesses(watcher->result()); if (oldPid != pid()) { ui.view->setCurrentIndex(QModelIndex()); } watcher->deleteLater(); }
void PrettyImage::ImageScaled() { QFutureWatcher<QImage>* watcher = reinterpret_cast<QFutureWatcher<QImage>*>(sender()); if (!watcher) return; watcher->deleteLater(); thumbnail_ = QPixmap::fromImage(watcher->result()); state_ = State_Finished; updateGeometry(); update(); emit Loaded(); }
void PatternManager::fileLoadFinished() { qDebug("file loaded signal"); //QProgressBar* watcher2 = qobject_cast<QProgressBar*>(QObject::sender()); QFutureWatcher<cv::Mat*>* watcher = static_cast<QFutureWatcher<cv::Mat*>*>(QObject::sender()); this->m_originalPatterns.push_back(watcher->result()); //Do I need to delete the watcher now??? delete watcher; emit fileLoaded(this->m_originalPatterns.size()); if(this->m_originalPatterns.size() == patternSetSize) { emit originalPatternsLoaded(); } }
void AccountsWorker::createAccount(const User *user) { qDebug() << "create account " << user; Q_EMIT requestFrameAutoHide(false); QFutureWatcher<CreationResult*> *watcher = new QFutureWatcher<CreationResult*>(this); connect(watcher, &QFutureWatcher<CreationResult*>::finished, [this, watcher] { CreationResult *result = watcher->result(); Q_EMIT accountCreationFinished(result); Q_EMIT requestFrameAutoHide(true); watcher->deleteLater(); }); QFuture<CreationResult*> future = QtConcurrent::run(this, &AccountsWorker::createAccountInternal, user); watcher->setFuture(future); }
void DownloadSizeFinder::watcherFinished() { QFutureWatcher<DownloadFile>* w = static_cast< QFutureWatcher<DownloadFile>*>(sender()); DownloadFile r = w->result(); this->mutex.lock(); if (r.error.isEmpty()) this->files.insert(r.url, QString::number(r.size)); else this->files.insert(r.url, "*" + r.error); this->mutex.unlock(); emit this->downloadCompleted(r.url, r.size, r.error); w->deleteLater(); }
int main(int argc, char **argv) { QCoreApplication application(argc, argv); if(application.arguments().count() < 4+1) { qDebug() << "Usage:" << argv[0] << "order" << "width" << "height" << "output"; return 0; } // ///////////////////////////////////////////////////////////////// // Single concurrent run preprocessing // ///////////////////////////////////////////////////////////////// qtrRenderer::newtonOrder = application.arguments().value(1).toInt(); qtrTile tile; tile.setWholeRect(QRect(0, 0, application.arguments().value(2).toInt(), application.arguments().value(3).toInt())); tile.setTileRect(QRect(0, 0, application.arguments().value(2).toInt(), application.arguments().value(3).toInt())); // ///////////////////////////////////////////////////////////////// // Single concurrent run // ///////////////////////////////////////////////////////////////// QFuture<QImage> future = QtConcurrent::run(qtrRenderer::newtonImage, tile); QFutureWatcher<QImage> watcher; watcher.setFuture(future); watcher.waitForFinished(); // ///////////////////////////////////////////////////////////////// // Single concurrent run postprocessing // ///////////////////////////////////////////////////////////////// watcher.result().save(application.arguments().value(4)); return 0; }
void PluginEffectLoader::queryAndLoadAll() { if (m_queryConnection) { return; } // perform querying for the services in a thread QFutureWatcher<QVector<KPluginMetaData>> *watcher = new QFutureWatcher<QVector<KPluginMetaData>>(this); m_queryConnection = connect(watcher, &QFutureWatcher<QVector<KPluginMetaData>>::finished, this, [this, watcher]() { const auto effects = watcher->result(); for (const auto &effect : effects) { const LoadEffectFlags flags = readConfig(effect.pluginId(), effect.isEnabledByDefault()); if (flags.testFlag(LoadEffectFlag::Load)) { m_queue->enqueue(qMakePair(effect, flags)); } } watcher->deleteLater(); m_queryConnection = QMetaObject::Connection(); }, Qt::QueuedConnection); watcher->setFuture(QtConcurrent::run(this, &PluginEffectLoader::findAllEffects)); }
// watcher void CoverArtCache::coverLoaded() { QFutureWatcher<FutureResult>* watcher; watcher = reinterpret_cast<QFutureWatcher<FutureResult>*>(sender()); FutureResult res = watcher->result(); if (sDebug) { qDebug() << "CoverArtCache::coverLoaded" << res.cover; } QString cacheKey = CoverArtUtils::pixmapCacheKey(res.cover.info.hash, res.desiredWidth); QPixmap pixmap; if (!QPixmapCache::find(cacheKey, &pixmap) && !res.cover.image.isNull()) { pixmap.convertFromImage(res.cover.image); QPixmapCache::insert(cacheKey, pixmap); } m_runningRequests.remove(qMakePair(res.pRequestor, res.requestReference)); if (res.signalWhenDone) { emit(coverFound(res.pRequestor, res.requestReference, res.cover.info, pixmap, false)); } }
bool FileManager::removeRecursively(const QString &path) { qCDebug(log, "Removing '%s'...", qPrintable(path)); if (!QFileInfo(path).isDir()) { qCWarning(log, "'%s' is not a directory.", qPrintable(path)); return false; } const QString deletePath = QStringLiteral("%1.%2.deleteme") .arg(path, QString::number(QDateTime::currentMSecsSinceEpoch())); if (!QDir().rename(path, deletePath)) { qCWarning(log, "Failed to rename '%s' to '%s'.", qPrintable(path), qPrintable(deletePath)); return false; } else { qCDebug(log, "Renamed '%s' to '%s'.", qPrintable(path), qPrintable(deletePath)); } QFutureWatcher<bool> *watcher = new QFutureWatcher<bool>(); connect(watcher, &QFutureWatcher<bool>::finished, [=] { if (!watcher->result()) { qCWarning(log, "Failed to remove '%s'.", qPrintable(deletePath)); } else { qCDebug(log, "Removed '%s'.", qPrintable(deletePath)); } watcher->deleteLater(); }); watcher->setFuture(QtConcurrent::run([deletePath] { return QDir(deletePath).removeRecursively(); })); return true; }
void IcecastService::ParseDirectoryFinished() { QFutureWatcher<IcecastBackend::StationList >* watcher = static_cast<QFutureWatcher<IcecastBackend::StationList>*>(sender()); IcecastBackend::StationList all_stations = watcher->result(); sort(all_stations.begin(), all_stations.end(), StationSorter<IcecastBackend::Station>()); // Remove duplicates by name. These tend to be multiple URLs for the same station. IcecastBackend::StationList::iterator it = unique(all_stations.begin(), all_stations.end(), StationEquality<IcecastBackend::Station>()); all_stations.erase(it, all_stations.end()); // Cluster stations by genre. QMultiHash<QString, IcecastBackend::Station*> genres; // Add stations. for (int i=0 ; i<all_stations.count() ; ++i) { IcecastBackend::Station& s = all_stations[i]; genres.insert(s.genre, &s); } QSet<QString> genre_set = genres.keys().toSet(); // Merge genres with only 1 or 2 stations into "Other". foreach (const QString& genre, genre_set) { if (genres.count(genre) < 3) { const QList<IcecastBackend::Station*>& small_genre = genres.values(genre); foreach (IcecastBackend::Station* s, small_genre) { s->genre = "Other"; } } } backend_->ClearAndAddStations(all_stations); delete watcher; model()->task_manager()->SetTaskFinished(load_directory_task_id_); load_directory_task_id_ = 0; }
void SettingsDialog::removeDocsets(const QStringList &names) { for (const QString &name : names) { const QString title = m_docsetRegistry->docset(name)->title(); m_docsetRegistry->remove(name); const QDir dataDir(m_application->settings()->docsetPath); if (dataDir.exists()) { ui->docsetsProgress->show(); ui->removeDocsetsButton->setEnabled(false); displayProgress(); QFuture<bool> future = QtConcurrent::run([=] { QDir docsetDir(dataDir); return docsetDir.cd(name + QLatin1String(".docset")) && docsetDir.removeRecursively(); }); QFutureWatcher<bool> *watcher = new QFutureWatcher<bool>(); watcher->setFuture(future); connect(watcher, &QFutureWatcher<void>::finished, [=] { if (!watcher->result()) { QMessageBox::warning(this, tr("Error"), QString(tr("Cannot delete docset <b>%1</b>!")).arg(title)); } resetProgress(); QListWidgetItem *listItem = findDocsetListItem(title); if (listItem) listItem->setHidden(false); watcher->deleteLater(); }); } } }
void ClipboardJob::start() { const QString operation = operationName(); // first check for operations not needing an item if (operation == QLatin1String("clearHistory")) { m_klipper->slotAskClearHistory(); setResult(true); emitResult(); return; } else if (operation == QLatin1String("configureKlipper")) { m_klipper->slotConfigure(); setResult(true); emitResult(); return; } // other operations need the item HistoryItemConstPtr item = m_klipper->history()->find(QByteArray::fromBase64(destination().toUtf8())); if (item.isNull()) { setResult(false); emitResult(); return; } if (operation == QLatin1String("select")) { m_klipper->history()->slotMoveToTop(item->uuid()); setResult(true); } else if (operation == QLatin1String("remove")) { m_klipper->history()->remove(item); setResult(true); } else if (operation == QLatin1String("edit")) { connect(m_klipper, &Klipper::editFinished, this, [this, item](HistoryItemConstPtr editedItem, int result) { if (item != editedItem) { // not our item return; } setResult(result); emitResult(); } ); m_klipper->editData(item); return; } else if (operation == QLatin1String("barcode")) { #ifdef HAVE_PRISON int pixelWidth = parameters().value(QStringLiteral("width")).toInt(); int pixelHeight = parameters().value(QStringLiteral("height")).toInt(); Prison::AbstractBarcode *code = nullptr; switch (parameters().value(QStringLiteral("barcodeType")).toInt()) { case 1: { code = Prison::createBarcode(Prison::DataMatrix); const int size = qMin(pixelWidth, pixelHeight); pixelWidth = size; pixelHeight = size; break; } case 2: { code = Prison::createBarcode(Prison::Code39); break; } case 3: { code = Prison::createBarcode(Prison::Code93); break; } case 0: default: { code = Prison::createBarcode(Prison::QRCode); const int size = qMin(pixelWidth, pixelHeight); pixelWidth = size; pixelHeight = size; break; } } if (code) { code->setData(item->text()); QFutureWatcher<QImage> *watcher = new QFutureWatcher<QImage>(this); connect(watcher, &QFutureWatcher<QImage>::finished, this, [this, watcher, code] { setResult(watcher->result()); watcher->deleteLater(); delete code; emitResult(); } ); auto future = QtConcurrent::run(code, &Prison::AbstractBarcode::toImage, QSizeF(pixelWidth, pixelHeight)); watcher->setFuture(future); return; } else { setResult(false); } #else setResult(false); #endif } else if (operation == QLatin1String("action")) { m_klipper->urlGrabber()->invokeAction(item); setResult(true); } else if (operation == s_previewKey) { const int pixelWidth = parameters().value(s_previewWidthKey).toInt(); const int pixelHeight = parameters().value(s_previewHeightKey).toInt(); QUrl url = parameters().value(s_urlKey).toUrl(); qCDebug(KLIPPER_LOG) << "URL: " << url; KFileItem item(url); if (pixelWidth <= 0 || pixelHeight <= 0) { qCWarning(KLIPPER_LOG) << "Preview size invalid: " << pixelWidth << "x" << pixelHeight; iconResult(item); return; } if (!url.isValid() || !url.isLocalFile()) { // no remote files qCWarning(KLIPPER_LOG) << "Invalid or non-local url for preview: " << url; iconResult(item); return; } KFileItemList urls; urls << item; KIO::PreviewJob* job = KIO::filePreview(urls, QSize(pixelWidth, pixelHeight)); job->setIgnoreMaximumSize(true); connect(job, &KIO::PreviewJob::gotPreview, this, [this](const KFileItem &item, const QPixmap &preview) { QVariantMap res; res.insert(s_urlKey, item.url()); res.insert(s_previewKey, preview); res.insert(s_iconKey, false); res.insert(s_previewWidthKey, preview.size().width()); res.insert(s_previewHeightKey, preview.size().height()); setResult(res); emitResult(); } ); connect(job, &KIO::PreviewJob::failed, this, [this](const KFileItem &item) { iconResult(item); } ); job->start(); return; } else { setResult(false); } emitResult(); }