Example #1
0
void QVX_Sim::IntegrateMT(IntegrationType Integrator)
{
	switch (Integrator){
		case I_EULER: {
			QFuture<void> res = QtConcurrent::map(BondArray.begin(), BondArray.end(), QVX_Sim::BondCalcForce);
			res.waitForFinished();
	

			////Update Forces...
			//int iT = NumBond();
			//for (int i=0; i<iT; i++){
			//	QFuture<void> future = QtConcurrent::run(BondCalcForce, &BondArray[i]);
			//	//BondArray[i].CalcForce();
			//}

			OptimalDt = CalcMaxDt();
			dt = DtFrac*OptimalDt;

			res = QtConcurrent::map(VoxArray.begin(), VoxArray.end(), QVX_Sim::VoxEulerStep);
			res.waitForFinished();

			//Update positions... need to do thises seperately if we're going to do damping in the summing forces stage.
	//		int iT = NumVox();
	//		for (int i=0; i<iT; i++) VoxArray[i].EulerStep();

		}
		break;
	}
}
Example #2
0
void CmdSandboxMeshLoaderFuture::activated(int iMsg)
{
    // use current path as default
    QStringList filter;
    filter << QObject::tr("All Mesh Files (*.stl *.ast *.bms *.obj)");
    filter << QObject::tr("Binary STL (*.stl)");
    filter << QObject::tr("ASCII STL (*.ast)");
    filter << QObject::tr("Binary Mesh (*.bms)");
    filter << QObject::tr("Alias Mesh (*.obj)");
    filter << QObject::tr("Inventor V2.1 ascii (*.iv)");
    //filter << "Nastran (*.nas *.bdf)";
    filter << QObject::tr("All Files (*.*)");

    // Allow multi selection
    QStringList fn = Gui::FileDialog::getOpenFileNames(Gui::getMainWindow(),
        QObject::tr("Import mesh"), QString(), filter.join(QLatin1String(";;")));

    QFuture< Base::Reference<Mesh::MeshObject> > future = QtConcurrent::mapped
        (fn, loadMesh);

    QFutureWatcher< Base::Reference<Mesh::MeshObject> > watcher;
    watcher.setFuture(future);

    // keep it responsive during computation
    QEventLoop loop;
    QObject::connect(&watcher, SIGNAL(finished()), &loop, SLOT(quit()));
    loop.exec();

    App::Document* doc = App::GetApplication().getActiveDocument();
    for (QFuture< Base::Reference<Mesh::MeshObject> >::const_iterator it = future.begin(); it != future.end(); ++it) {
        Mesh::Feature* mesh = static_cast<Mesh::Feature*>(doc->addObject("Mesh::Feature","Mesh"));
        mesh->Mesh.setValuePtr((Mesh::MeshObject*)(*it));
        mesh->purgeTouched();
    }
}
Example #3
0
void ImageWidget::updateImage(bool zoom, const QImage &image, bool valuesPresent[], int values[])
{
    if(zoom) {
        QImage imageNew = scaleImage(image);
        if(imageNew.isNull()) return;

#ifndef QT_NO_CONCURRENT
        QFuture<QImage> future = QtConcurrent::run(this, &ImageWidget::scaleImage, image);
        imageNew = future.result();
#else
        QImage imageNew = scaleImage(image);

#endif

        pixmap = QPixmap::fromImage(imageNew);
    } else {
        pixmap = QPixmap::fromImage(image);
    }
    for(int i=0; i<4; i++) {
        drawValues[i] = valuesPresent[i];
        if(drawValues[i]) geoValues[i] = values[i];
        else geoValues[i] = 0;
    }
    update();
}
Example #4
0
void Integration::initEgl()
{
    Q_ASSERT(m_eglDisplay == EGL_NO_DISPLAY);
    // This variant uses Wayland as the EGL platform
    qputenv("EGL_PLATFORM", "wayland");
    m_eglDisplay = eglGetDisplay(waylandServer()->internalClientConection()->display());
    if (m_eglDisplay == EGL_NO_DISPLAY) {
        return;
    }
    // call eglInitialize in a thread to not block
    QFuture<bool> future = QtConcurrent::run([this] () -> bool {
        EGLint major, minor;
        if (eglInitialize(m_eglDisplay, &major, &minor) == EGL_FALSE) {
            return false;
        }
        EGLint error = eglGetError();
        if (error != EGL_SUCCESS) {
            return false;
        }
        return true;
    });
    // TODO: make this better
    while (!future.isFinished()) {
        waylandServer()->internalClientConection()->flush();
        QCoreApplication::processEvents(QEventLoop::WaitForMoreEvents);
    }
    if (!future.result()) {
        eglTerminate(m_eglDisplay);
        m_eglDisplay = EGL_NO_DISPLAY;
    }
}
void SemanticHighlighter::clearExtraAdditionalFormatsUntilEnd(
        SyntaxHighlighter *highlighter,
        const QFuture<HighlightingResult> &future)
{
    // find block number of last result
    int lastBlockNumber = 0;
    for (int i = future.resultCount() - 1; i >= 0; --i) {
        const HighlightingResult &result = future.resultAt(i);
        if (result.line) {
            lastBlockNumber = result.line - 1;
            break;
        }
    }

    QTextDocument *doc = highlighter->document();

    const int firstBlockToClear = lastBlockNumber + 1;
    if (firstBlockToClear <= doc->blockCount())
        return;

    QTextBlock b = doc->findBlockByNumber(firstBlockToClear);

    while (b.isValid()) {
        QVector<QTextLayout::FormatRange> noFormats;
        highlighter->setExtraFormats(b, noFormats);
        b = b.next();
    }
}
void SettingsUnLinkStoreDevice::tryToDisassociate()
{
        qDebug() << "--->" << Q_FUNC_INFO;
        disconnectWifiObserverUnlinkBtn();
        Screen::getInstance()->queueUpdates();
        SelectionDialog* confirmDialog = new SelectionDialog(this,tr("Do you want to unlink the device? This will delete all your personal account data"));
        Screen::getInstance()->setMode(Screen::MODE_SAFE,true, FLAG_FULLSCREEN_UPDATE,Q_FUNC_INFO);
        Screen::getInstance()->setUpdateScheme(Screen::SCHEME_MERGE, true);
        Screen::getInstance()->flushUpdates();
        confirmDialog->exec();
        bool result = confirmDialog->result();
        delete confirmDialog;
        if(!result)
            return;

        disconnect(Storage::getInstance(), SIGNAL(partitionMounted(StoragePartition*)), QBookApp::instance(), SLOT(handlePartitionMounted(StoragePartition*)));
        PowerManagerLock* powerLock = PowerManager::getNewLock(this);
        powerLock->activate();
        QBookApp::instance()->cancelSync();
        //Screen::getInstance()->queueUpdates();
        InfoDialog *dialog = new InfoDialog(this,tr("This process can take a few minutes. At the end, the device will be powered off"));
        dialog->show();
        Screen::getInstance()->setMode(Screen::MODE_SAFE,true, FLAG_FULLSCREEN_UPDATE,Q_FUNC_INFO);
        //Screen::getInstance()->setUpdateScheme(Screen::SCHEME_MERGE, true);
        //Screen::getInstance()->flushUpdates();

#ifndef HACKERS_EDITION
        bqDeviceServices* services = QBookApp::instance()->getDeviceServices();
        services->unlink();
#endif
        
        if (true)
        {
            QBookApp::instance()->disableUserEvents();
            QBookApp::instance()->getSyncHelper()->SetServerTimestamp(0);
            QBookApp::instance()->syncModel();
            QBookApp::instance()->showRestoringImage();

            Screen::getInstance()->queueUpdates();
            // Remove private books from model
            QBookApp::instance()->getModel()->removeDir(Storage::getInstance()->getPrivatePartition()->getMountPoint());

                QFuture<void> future = QtConcurrent::run(this, &SettingsUnLinkStoreDevice::restoreSettinsAndPartitions, dialog);
                if (!future.isFinished())
                    dialog->exec();
            Screen::getInstance()->setMode(Screen::MODE_SAFE, true, FLAG_FULLSCREEN_UPDATE, Q_FUNC_INFO);
            PowerManager::powerOffDevice(true);
        }
        else
        {

            InfoDialog *unlinkFailedDialog = new InfoDialog(this,tr("Service unavailable. Please try again in a few minutes"));
            Screen::getInstance()->setMode(Screen::MODE_SAFE,true,Q_FUNC_INFO);
            unlinkFailedDialog->hideSpinner();
            unlinkFailedDialog->showForSpecifiedTime();
            delete unlinkFailedDialog;
            powerLock->release();
            delete powerLock;
        }
}
Example #7
0
void MeshCurvature::ComputePerFace(bool parallel)
{
    Base::Vector3f rkDir0, rkDir1, rkPnt;
    Base::Vector3f rkNormal;
    myCurvature.clear();
    MeshRefPointToFacets search(myKernel);
    FacetCurvature face(myKernel, search, myRadius, myMinPoints);

    if (!parallel) {
        Base::SequencerLauncher seq("Curvature estimation", mySegment.size());
        for (std::vector<unsigned long>::iterator it = mySegment.begin(); it != mySegment.end(); ++it) {
            CurvatureInfo info = face.Compute(*it);
            myCurvature.push_back(info);
            seq.next();
        }
    }
    else {
        QFuture<CurvatureInfo> future = QtConcurrent::mapped
            (mySegment, boost::bind(&FacetCurvature::Compute, &face, _1));
        QFutureWatcher<CurvatureInfo> watcher;
        watcher.setFuture(future);
        watcher.waitForFinished();
        for (QFuture<CurvatureInfo>::const_iterator it = future.begin(); it != future.end(); ++it) {
            myCurvature.push_back(*it);
        }
    }
}
void PlayListImageThumbnailHistogramGrouper::group(ImageList::iterator begin, ImageList::iterator end)
{
    std::vector<QSharedPointer<ImageHistogram> > hists;

    // Load thumbnail and compute thumbnail histograms
    QFuture<QSharedPointer<ImageHistogram> > f = QtConcurrent::mapped(begin, end, computeImageHistogram);
    f.waitForFinished();
    for (QSharedPointer<ImageHistogram> hist : f) {
        hists.push_back(hist);
    }

    // Partition
    std::vector<int> labels;
    int groupCount = cv::partition(hists, labels, isHistSame);

    m_groupNames.clear();
    for (int i = 0; i < groupCount; i++) {
        m_groupNames << QStringLiteral("Group %1").arg(i);
    }

    for (auto it = begin; it != end; it++) {
        m_imageGroups[it->data()] = labels[it - begin];
    }

    // Sort by group
    std::sort(begin, end, [this](const ImagePtr &left, const ImagePtr &right) -> bool {
        int leftLabel = this->m_imageGroups[left.data()];
        int rightLabel = this->m_imageGroups[right.data()];
        if (leftLabel != rightLabel) {
            return leftLabel < rightLabel;
        } else {
            return ImageNameLessThan(left->name(), right->name()); 
        }
    });
}
Example #9
0
void DocsetRegistry::_runQuery(const QString &query)
{
    m_cancellationToken.reset();

    QList<Docset *> enabledDocsets;

    const SearchQuery searchQuery = SearchQuery::fromString(query);
    if (searchQuery.hasKeywords()) {
        for (Docset *docset : qAsConst(m_docsets)) {
            if (searchQuery.hasKeywords(docset->keywords()))
                enabledDocsets << docset;
        }
    } else {
        enabledDocsets = docsets();
    }

    QFuture<QList<SearchResult>> queryResultsFuture
            = QtConcurrent::mappedReduced(enabledDocsets,
                                          std::bind(&Docset::search,
                                                    std::placeholders::_1,
                                                    searchQuery.query(),
                                                    std::ref(m_cancellationToken)),
                                          &MergeQueryResults);
    QList<SearchResult> results = queryResultsFuture.result();

    if (m_cancellationToken.isCanceled())
        return;

    std::sort(results.begin(), results.end());

    if (m_cancellationToken.isCanceled())
        return;

    emit searchCompleted(results);
}
QNetworkReply::NetworkError NetworkServiceAccessor::get(const QNetworkRequest &request, QByteArray &replyData, QList<QNetworkReply::RawHeaderPair> &headers) const
{
    QNetworkReply::NetworkError result = QNetworkReply::NoError;
    QFuture<void> future = QtConcurrent::run(QThreadPool::globalInstance(), [&](){
        QEventLoop loop;

        QNetworkAccessManager networkAccessManager;

        QNetworkReply *reply = networkAccessManager.get(request);
        connect(reply, SIGNAL(finished()), &loop, SLOT(quit()));
        LoggingManager::getSingleton().log() << "NetworkService Get: " << request.url().toString();
        qDebug() << "NetworkService Get:" << request.url().toString();
        loop.exec();

        result = reply->error();
        if (result != QNetworkReply::NoError)
        {
            qDebug() << "Network Service Accessor Error: " << reply->errorString();
            qDebug() << "error code:" << reply->error();
            LoggingManager::getSingleton().log() << "NetworkService: " << reply->errorString();
        }

        headers = reply->rawHeaderPairs();
        replyData = reply->readAll();
        qDebug() << replyData;
        reply->deleteLater();});

    future.waitForFinished();
    return result;
}
QNetworkReply::NetworkError NetworkServiceAccessor::post(const QNetworkRequest &request, const QByteArray &data, QByteArray &replyData) const
{
    QNetworkReply::NetworkError result = QNetworkReply::NoError;
    QFuture<void> future = QtConcurrent::run(QThreadPool::globalInstance(), [&](){
        QEventLoop loop;
        QNetworkAccessManager networkAccessManager;
        QNetworkReply *reply = networkAccessManager.post(request, data);

        connect(reply, SIGNAL(finished()), &loop, SLOT(quit()));
        LoggingManager::getSingleton().log() << "NetworkService Post: " << request.url().toString();
        qDebug() << "NetworkService Post: " << request.url().toString();
        LoggingManager::getSingleton().log() << "Payload: " << QString::fromUtf8(data);
        qDebug() << "Payload: " << QString::fromUtf8(data);
        loop.exec();

        result = reply->error();

        if (result != QNetworkReply::NoError)
        {
            qDebug() << "Network Service Accessor Error: " << reply->errorString();
            LoggingManager::getSingleton().log() << "NetworkService: " << reply->errorString();
        }

        replyData = reply->readAll();
        qDebug() << replyData;
        reply->deleteLater();
    });

    future.waitForFinished();
    return result;
}
Example #12
0
void auto_expand_image::run()
{
    //qRegisterMetaType<QPainterPath >("QPainterPath");
    //! =============== begin
    running_text_left+=running_text_left_add;//滚动字幕
    if(running_text_left>=image_width)running_text_left=-running_text.textWidth();

    percent_finish=1.0*(image_running_step%image_running_step_total)/(image_running_step_total-1);
    if(image_running_step%image_running_step_total==0){
        image_switch_step++;
        //获取上一个图片的path
        if(draw_pixmap_paths.count() > 0)
            draw_pixmap_path_pre=draw_pixmap_paths[(image_switch_step-1)%draw_pixmap_paths.count()];
    }
    //当前绘制的pixmap
    draw_pixmap_path_cur=draw_pixmap_paths[image_switch_step%draw_pixmap_paths.count()];
    image_running_step++;//图片切换
    //! =============== end
    QFuture<void> future = QtConcurrent::run(POP_INTERVAL_IMAGE,
                                             this,
                                             paint_rotate,
                                             percent_finish,
                                             polygon_vect,
                                             draw_pixmap_path_cur
                                             );
    future.waitForFinished();

}
Example #13
0
CC_FILE_ERROR BinFilter::loadFile(const char* filename, ccHObject& container, bool alwaysDisplayLoadDialog/*=true*/, bool* coordinatesShiftEnabled/*=0*/, double* coordinatesShift/*=0*/)
{
	ccLog::Print("[BIN] Opening file '%s'...",filename);


	//opening file
	QFile in(filename);
	if (!in.open(QIODevice::ReadOnly))
		return CC_FERR_READING;

	uint32_t firstBytes = 0;
	if (in.read((char*)&firstBytes,4)<0)
		return CC_FERR_READING;
	bool v1 = (strncmp((char*)&firstBytes,"CCB2",4) != 0);

	if (v1)
	{
		return LoadFileV1(in,container,static_cast<unsigned>(firstBytes),alwaysDisplayLoadDialog); //firstBytes == number of scans for V1 files!
	}
	else
	{
		if (alwaysDisplayLoadDialog)
		{
			QProgressDialog pDlg(QString("Loading: %1").arg(QFileInfo(filename).fileName()),QString(),0,0/*static_cast<int>(in.size())*/);
			pDlg.setWindowTitle("BIN file");
			pDlg.show();

			//concurrent call in a separate thread
			s_file = &in;
			s_container = &container;

			QFuture<CC_FILE_ERROR> future = QtConcurrent::run(_LoadFileV2);

			while (!future.isFinished())
			{
	#if defined(CC_WINDOWS)
				::Sleep(500);
	#else
				usleep(500 * 1000);
	#endif
				if (alwaysDisplayLoadDialog)
				{
					pDlg.setValue(pDlg.value()+1);
					//pDlg.setValue(static_cast<int>(in.pos())); //DGM: in fact, the file reading part is just half of the work!
					QApplication::processEvents();
				}
			}
	
			s_file = 0;
			s_container = 0;

			return future.result();
		}
		else
		{
			return BinFilter::LoadFileV2(in,container);
		}
	}
}
Example #14
0
void TestRunFunction::runHeavyFunction()
{
    qDebug("starting function");
    QFuture<void> future = run(F(heavy));
    qDebug("waiting");
    future.waitForFinished();
    qDebug("done");
}
void tst_QtConcurrentRun::runLightFunction()
{
    qDebug("starting function");
    QFuture<void> future = run(F(light));
    qDebug("waiting");
    future.waitForFinished();
    qDebug("done");
}
int main(int argc, char *argv[])
{
    QCoreApplication app(argc, argv);
    QFuture<void> future = QtConcurrent::run(hello);
    qDebug() << "hello from GUI thread " << QThread::currentThread();
    future.waitForFinished();
    return 0;
}
Example #17
0
bool QThreadFutureMap::isAlive(const QString &id)
{
  QFuture<void> *future = getFuture(id);
  if (future != NULL) {
    return !future->isFinished();
  }

  return false;
}
void tst_QtConcurrentRun::runHeavyFunction()
{
    QThreadPool pool;
    qDebug("starting function");
    QFuture<void> future = run(&pool, heavy);
    qDebug("waiting");
    future.waitForFinished();
    qDebug("done");
}
void tst_QtConcurrentIterateKernel::multipleResults()
{
    QFuture<int> f = startThreadEngine(new MultipleResultsFor(0, 10)).startAsynchronously();
    QCOMPARE(f.results().count() , 10);
    QCOMPARE(f.resultAt(0), 0);
    QCOMPARE(f.resultAt(5), 5);
    QCOMPARE(f.resultAt(9), 9);
    f.waitForFinished();
}
QList<LocatorFilterEntry> BasicLocatorFilterTest::matchesFor(const QString &searchText)
{
    doBeforeLocatorRun();
    const QList<ILocatorFilter *> filters = QList<ILocatorFilter *>() << m_filter;
    QFuture<LocatorFilterEntry> locatorSearch = QtConcurrent::run(Core::Internal::runSearch,
                                                           filters, searchText);
    locatorSearch.waitForFinished();
    doAfterLocatorRun();
    return locatorSearch.results();
}
void tst_QtConcurrentThreadEngine::multipleResults()
{
    MultipleResultsUser *engine =  new MultipleResultsUser();
    QFuture<int> f = engine->startAsynchronously();
    QCOMPARE(f.results().count() , 10);
    QCOMPARE(f.resultAt(0), 0);
    QCOMPARE(f.resultAt(5), 5);
    QCOMPARE(f.resultAt(9), 9);
    f.waitForFinished();
}
Example #22
0
void tst_iteratekernel::cancel()
{
    {
        QFuture<void> f = startThreadEngine(new SleepPrintFor(0, 40)).startAsynchronously();
        f.cancel();
        f.waitForFinished();
        QVERIFY(f.isCanceled());
        QVERIFY(int(iterations) <= QThread::idealThreadCount()); // the threads might run one iteration each before they are canceled.
    }
}
bool CatalogConnector::loadDataThreaded(IlwisObject *obj, const IOOptions &options){
    kernel()->issues()->log(QString(TR("Scanning %1")).arg(source().url(true).toString()),IssueObject::itMessage);
    QVector<std::pair<CatalogExplorer *, IOOptions>> explorers;
    for(const auto& explorer : _dataProviders){
       explorers.push_back({explorer.get(), options});
    }
    QFuture<std::vector<Resource>> res = QtConcurrent::mappedReduced(explorers,loadExplorerData, gatherData);
    res.waitForFinished();
    mastercatalog()->addItems(res.result());
    return true;
}
Example #24
0
void RunConcurrentMapExample()
{
  QStringList strings;
  strings << "foo" <<  "bar" <<  "baz";

  QFuture<void> res = QtConcurrent::map(strings,UpcaseString());
  res.waitForFinished();

  for(QStringList::iterator i = strings.begin(); i != strings.end(); ++i)
	qDebug("%s",qPrintable(*i));
}
Example #25
0
QList<LocatorFilterEntry> BasicLocatorFilterTest::matchesFor(const QString &searchText)
{
    doBeforeLocatorRun();
    const QList<ILocatorFilter *> filters = QList<ILocatorFilter *>() << m_filter;
    m_filter->prepareSearch(searchText);
    QFuture<LocatorFilterEntry> locatorSearch = Utils::runAsync(&Internal::runSearch, filters,
                                                                searchText);
    locatorSearch.waitForFinished();
    doAfterLocatorRun();
    return locatorSearch.results();
}
Example #26
0
void tst_QFuture::progressText()
{
    QFutureInterface<void> i;
    i.reportStarted();
    QFuture<void> f = i.future();

    QCOMPARE(f.progressText(), QLatin1String(""));
    i.setProgressValueAndText(1, QLatin1String("foo"));
    QCOMPARE(f.progressText(), QLatin1String("foo"));
    i.reportFinished();
}
void tst_QtConcurrentIterateKernel::cancel()
{
    {
        QFuture<void> f = startThreadEngine(new SleepPrintFor(0, 40)).startAsynchronously();
        f.cancel();
        f.waitForFinished();
        QVERIFY(f.isCanceled());
         // the threads might run one iteration each before they are canceled.
        QVERIFY2(iterations.load() <= QThread::idealThreadCount(),
                 (QByteArray::number(iterations.load()) + ' ' + QByteArray::number(QThread::idealThreadCount())));
    }
}
Example #28
0
int BaseFilter::start()
{   
	if (s_computing)
	{
		throwError(-32);
		return -1;
	}

	QProgressDialog progressCb("Operation in progress",QString(),0,0);

	if (m_show_progress)
    {
		progressCb.setWindowTitle(getFilterName());
		progressCb.show();
		QApplication::processEvents();
	}

	s_computeStatus = -1;
	s_filter = this;
	s_computing = true;
	int progress = 0;

	QFuture<void> future = QtConcurrent::run(doCompute);
	while (!future.isFinished())
	{
#if defined(CC_WINDOWS)
		::Sleep(500);
#else
		usleep(500 * 1000);
#endif
		if (m_show_progress)
			progressCb.setValue(++progress);
	}
	
	int is_ok = s_computeStatus;
	s_filter = 0;
	s_computing = false;

	if (m_show_progress)
	{
        progressCb.close();
        QApplication::processEvents();
	}

	if (is_ok < 0)
	{
		throwError(is_ok);
		return -1;
	}

	return 1;
}
void windowLoadMiRNAF::on_buttonChooseMirnaF_clicked()
{
    fileNameMiRNA=QFileDialog::getOpenFileName(
                this,
                tr("Choose File"),
                "",
                "FASTA files (*.fasta);;Text files (*.txt);;All files (*)"
                );
    if(!fileNameMiRNA.isEmpty()){
        ui->progressBar->show();
        try
        {
            QFuture<bool> future = QtConcurrent::run(&QtExceptionWrapper::targetFinder_getMiRNAs,m_oTF,fileNameMiRNA.toStdString());
            //m_oTF->getMiRNAs(fileNameMiRNA.toStdString());
            this->FutureWatcher.setFuture(future);
            future.result();
            //make visible  labelFileSelectedMirna
            ui->labelFileSelectedMirna->setVisible(true);
            //change the value of labelFileSelectedMirna
            ui->labelFileSelectedMirna->setText(tr("Mirna File selected : ")+fileNameMiRNA);
            //make the button next accessible
            ui->NextAnalyzeResults->setEnabled(true);

            this->ui->progressBar->setMaximum(100);
            this->ui->progressBar->setValue(100);
        }catch(MyException const& e)
        {
            QMessageBox::warning(this,tr("Loading error"),e.what());
            //hiding labelFileSelectedMirna
            ui->labelFileSelectedMirna->setVisible(false);
            //change the value of labelFileSelectedMirna
            ui->labelFileSelectedMirna->setText(tr(""));
            //make the button next disabled
            ui->NextAnalyzeResults->setEnabled(false);
            this->ui->progressBar->hide();
        }catch(std::string const& e2)
        {
            QMessageBox::warning(this,tr("Loading error"),QString::fromStdString(e2));
            //hiding labelFileSelectedMirna
            ui->labelFileSelectedMirna->setVisible(false);
            //change the value of labelFileSelectedMirna
            ui->labelFileSelectedMirna->setText(tr(""));
            //make the button next disabled
            ui->NextAnalyzeResults->setEnabled(false);
            this->ui->progressBar->hide();
        }
    }
    else{
        QMessageBox::warning(this,tr("File selected"),tr("No file selected"));
    }

}
void tst_QtConcurrentThreadEngine::runDirectly()
{
    {
        PrintUser engine;
        engine.startSingleThreaded();
        engine.startBlocking();
    }
    {
        PrintUser *engine = new PrintUser();
        QFuture<void> f = engine->startAsynchronously();
        f.waitForFinished();
    }
}