void HyvesAPI::handleResult(int requestId, ResultDocument result, bool errorOccurred) {
m_d->log->debug(QString("Received response for request #%1").arg(requestId));
if (errorOccurred || result.errorCode() != ResultDocument::RESULT_OK) {
m_d->log->error(QString("An error occurred during API call (request #%3): %1 %2").arg(result.errorCode()).arg(result.errorMessage()).arg(requestId));
emit error(result);
emit error(requestId, result);
return;
}
if (m_d->accessToken == 0) {
GenusApis::OAuthAccessToken *accessToken = result.toAccessToken("auth_accesstokenByDesktoptoken_result");
if (accessToken != 0) {
m_d->log->notice("Got access token from API");
m_d->accessToken = accessToken;
m_d->loginStatus = HyvesAPI::LoggedIn;
emit accessTokenReady();
return;
}
m_d->log->debug("Response received but no access token yet!");
}
emit resultReady(result);
emit resultReady(requestId, result);
}
void FutureWatcher::customEvent(QEvent* event)
{
if(_futureInterface) {
OVITO_ASSERT(static_cast<CallOutEvent*>(event)->_source == _futureInterface.get());
if(event->type() == (QEvent::Type)CallOutEvent::Started)
Q_EMIT started();
else if(event->type() == (QEvent::Type)CallOutEvent::Finished) {
_finished = true;
Q_EMIT finished();
}
else if(event->type() == (QEvent::Type)CallOutEvent::Canceled)
Q_EMIT canceled();
else if(event->type() == (QEvent::Type)CallOutEvent::ResultReady) {
if(!_futureInterface->isCanceled()) {
Q_EMIT resultReady();
}
}
else if(event->type() == (QEvent::Type)CallOutEvent::ProgressValue) {
if(!_futureInterface->isCanceled())
Q_EMIT progressValueChanged(static_cast<CallOutEvent*>(event)->_value);
}
else if(event->type() == (QEvent::Type)CallOutEvent::ProgressText) {
if(!_futureInterface->isCanceled())
Q_EMIT progressTextChanged(static_cast<CallOutEvent*>(event)->_text);
}
else if(event->type() == (QEvent::Type)CallOutEvent::ProgressRange) {
Q_EMIT progressRangeChanged(static_cast<CallOutEvent*>(event)->_value);
}
}
QObject::customEvent(event);
}
void MainWindow::sendData(const QString &data)
{
// Quick error checks before sending
if (data.isEmpty())
{
showError(tr("Can't process audio ;("));
return;
}
ui->label->setText(tr("Sending data..."));
ui->recordButton->setIcon(*iconNetwork);
repaint();
#ifdef USE_LIBECHONEST
QNetworkReply * reply = Echonest::Song::identify(data);
QEventLoop loop;
loop.connect(reply, SIGNAL(finished()), SLOT(quit()));
loop.exec();
QByteArray answer(reply->readAll());
#else
EchoNestRequest request(this, nam, API_KEY, QString("4.11"));
EchoNestSong * song = request.identifySong(data);
#endif
emit(resultReady(song));
}
/** \brief Load a new simulation
*
* Load a new simulation. Be aware that you must free the ressource of
* the old simulation, if it exists, before calling this function.
*/
void MainController::load_configuration(QString& file)
{
mSimulationFilePath = file;
mSimulator = new sim::NBody(sim::RK4);
std::ifstream in_stream(file.toUtf8().data());
mSimulator->lire_valeurs(in_stream);
const std::vector<sim::Body>& bodies = mSimulator->getCorps();
for(std::vector<sim::Body>::const_iterator it = bodies.begin();
it != bodies.end();
it++)
{
eng::Planet* p = eng::PlanetFactory::getPlanet("earth");
mEngine->addPlanet(&(*it), p);
}
mSimulationThread = new SimulatorThread(*this);
connect(mSimulationThread, SIGNAL(resultReady()),
this, SIGNAL(model_updated()));
connect(mSimulationThread, SIGNAL(finished()),
this, SLOT(thread_finished()));
setState(INITIALIZED);
}
void MainWindow::on_Scan4robot_clicked()
{
if(!workerThread.isRunning())
{
debug("searching network for clients");
//start search on new thread
netMap *scanThread = new netMap;
scanThread->moveToThread(&workerThread);
connect(scanThread, SIGNAL(finished()), scanThread, SLOT(deleteLater()));
connect(this, SIGNAL(scanNet(QString)), scanThread, SLOT(scanIps(QString)));
connect(scanThread, SIGNAL(resultReady(QString)), this ,SLOT(handleResIP(QString)));
this->currIp = 0; //start search from ip 0
workerThread.start();
emit this->scanNet(QString::number(this->currIp));
ui->Scan4robot->setText("Cancel");//change search button to cancel button
}
else
{
this->debug("cancelled search, current thread will finish execution before being stoped");
ui->Scan4robot->setText("Scan for Robots"); //change button back to search
workerThread.exit(); //cancel thread
}
}
void CandidateIndexesPage::generateCandidates()
{
if (generator != nullptr) {
return;
}
MainWizard *mainWizard = static_cast<MainWizard*>(wizard());
QProgressDialog *progress = new QProgressDialog(
tr("Generating candidates..."),
tr("Cancel"),
0,
100,
this
);
progress->setModal(true);
progress->setValue(0);
progress->setMinimumDuration(0);
generator = new GenerateCandidateIndexes(mainWizard->project);
connect(generator, SIGNAL(finished()), progress, SLOT(accept()));
connect(generator, SIGNAL(progress(int)), progress, SLOT(setValue(int)));
connect(generator, SIGNAL(resultReady()), this, SLOT(candidatesGenerated()));
connect(progress, SIGNAL(canceled()), generator, SLOT(terminate()));
generator->start();
}
void CManager::CreateNonPtzThread()
{
m_pCamNonPtzThread = PCamNonPtzThread(new CCamNonPtzThread());
connect(m_pCamNonPtzThread.data(), SIGNAL(resultReady(cv::Mat)), this, SLOT(handleNonPTZFrame(cv::Mat)));
// connect(m_pCamNonPtzThread.data(), SIGNAL(finished), m_pCamNonPtzThread.data(), SLOT(&QObject::deleteLater));
m_pCamNonPtzThread->Start();
}
void CommentsModel::getComments(int offset, int count)
{
if (m_session.data() && m_postId) {
auto reply = m_session.data()->getComments(offset, count);
connect(reply, SIGNAL(resultReady(QVariant)), SIGNAL(requestFinished()));
}
}
void faceThread::run()
{
static int eyeFlag = 0;
static float scale = 0.5;
while(true)
{
if(runFlag)
{
switch (MODE)
{
case SLEEP_MODE:
setSleep();
break;
case SMILE_MODE:
setSmile();
break;
case ANGER_MODE:
setAnger();
break;
case TRACK_MODE:
setTrack();
scale = 1;
break;
default:
break;
}
if( eyeFlag == 0 )
{
scale -= CHANGE_SPEED;
if(scale <= LOWBOUND)
{
eyeFlag = 1;
}
}
else
{
scale += CHANGE_SPEED;
if(scale >= UPBOUND)
{
eyeFlag = 0;
if(UPBOUND > 0.8)
{
scale = 0.8;
}
else
{
scale = UPBOUND;
}
}
}
facesketch->reset();
facesketch->setEyeScale(scale);
facesketch->sketchWholeFace();
setRunFlag(false);
emit resultReady();
}
}
}
void LongPoll::requestServer()
{
Q_D(LongPoll);
if (d->isRunning) {
auto reply = d->client->request("messages.getLongPollServer");
connect(reply, SIGNAL(resultReady(QVariant)), SLOT(_q_request_server_finished(QVariant)));
}
}
void NewsFeedModel::getNews(int filters, quint8 count, int offset)
{
if (m_newsFeed.isNull())
return;
auto reply = m_newsFeed.data()->getNews(static_cast<Vreen::NewsFeed::Filters>(filters), count, offset);
connect(reply, SIGNAL(resultReady(QVariant)), SIGNAL(requestFinished()));
}
void
Dynamic::SimpleMatchBias::updateFinished()
{
m_tracksTime = QDateTime::currentDateTime();
m_qm.reset();
debug() << "SimpleMatchBias::"<<name()<<"updateFinished"<<m_tracks.trackCount();
emit resultReady( m_tracks );
}
Reply *Buddy::removeFromFriends()
{
Q_D(Buddy);
QVariantMap args;
args.insert("uid", d->id);
auto reply = d->client->request("friends.delete", args);
connect(reply, SIGNAL(resultReady(QVariant)), this, SLOT(_q_friends_delete_finished(QVariant)));
return reply;
}
void ThreadAnalysis::doMath()
{
qDebug() << "Started Threaded Math";
this->temp->rpm = 1/((500*0.0625*this->inData.currTimePerTic*pow(10,-6))/60);
this->temp->timeStamp = this->inData.lastTimePerTic+this->inData.currTimePerTic*(0.0625)*pow(10,-6);
emit resultReady(this->temp);
this->workerThread.exit();
this->workerThread.terminate();//I AM THE THREAD TERMINATOR
}
void MainWindow::on_learnDicOkBtn_clicked()
{
ui->learnDicOkBtn->setEnabled(false);
ui->saveCfBtn->setEnabled(false);
WorkerThread *workerThread = new WorkerThread();
connect(workerThread, SIGNAL(resultReady()), this, SLOT(updateSisrButtons()));
connect(workerThread, SIGNAL(exceptionOccurs()), this, SLOT(sisrExceptionOccurs()));
workerThread->start();
}
Reply *Buddy::addToFriends(const QString &reason)
{
Q_D(Buddy);
QVariantMap args;
args.insert("uid", d->id);
args.insert("text", reason);
auto reply = d->client->request("friends.add", args);
connect(reply, SIGNAL(resultReady(QVariant)), this, SLOT(_q_friends_add_finished(QVariant)));
return reply;
}
void NewsFeedModel::deleteLike(int postId)
{
int index = findNews(postId);
if (index != -1) {
auto news = m_newsList.at(index);
auto reply = m_client.data()->deleteLike(news.sourceId(),
postId);
connect(reply, SIGNAL(resultReady(QVariant)), SLOT(onDeleteLike(QVariant)));
}
}
void testRequest()
{
VREEN_CREATE_CLIENT();
if (!client.isOnline())
QFAIL("Client is offline!");
Vreen::Reply *reply = client.request("getUserSettings");
connect(reply, SIGNAL(resultReady(QVariant)), &loop, SLOT(quit()));
loop.exec();
QCOMPARE(reply->response().toInt() > 6, true);
}
void NewsFeedModel::addLike(int postId, bool retweet, const QString &message)
{
int index = findNews(postId);
if (index != -1) {
auto news = m_newsList.at(index);
auto reply = m_client.data()->addLike(news.sourceId(),
postId,
retweet,
message);
connect(reply, SIGNAL(resultReady(QVariant)), SLOT(onAddLike(QVariant)));
}
}
void Worker::stopDaemon() {
qDebug("Performing daemon stop...");
//try{
m_Daemon.stop();
qDebug("Daemon stopped.");
emit resultReady(false, "");
/*}catch(std::exception ex){
emit resultReady(true, ex.what());
}catch(...){
emit resultReady(true, QObject::tr("Error: unknown exception"));
}*/
}
void LongPoll::requestData(const QByteArray &timeStamp)
{
Q_D(LongPoll);
if (d->dataRequestReply) {
d->dataRequestReply->disconnect(this, SLOT(_q_request_server_finished(QVariant)));
d->dataRequestReply->deleteLater();
}
QUrl url = d->dataUrl;
url.addQueryItem("ts", timeStamp);
auto reply = d->client->request(url);
connect(reply, SIGNAL(resultReady(QVariant)), this, SLOT(_q_on_data_recieved(QVariant)));
d->dataRequestReply = reply;
}
void Worker::dataLoop()
{
Datagram dg;
unsigned char monitor;
float data;
if (receiveDatagramTimeout(serial, &dg) != -1) {
monitor = dg.id;
data = translateDatagramData(&dg);
emit resultReady(monitor, data);
}
}
Controller::Controller()
{
SegEvolver *worker = new SegEvolver();
std::cout << "Controller Constructor" << std::endl;
worker->moveToThread(&workerThread);
std::cout << "Controller Constructor" << std::endl;
connect(&workerThread, SIGNAL(finished()), worker, SLOT(deleteLater()));
std::cout << "Controller Constructor" << std::endl;
connect(this, SIGNAL(operate(QString)), worker, SLOT(doWork(QString)));
std::cout << "Controller Constructor" << std::endl;
connect(worker, SIGNAL(resultReady(QString)), this, SLOT(handleResults(QString)));
std::cout << "Controller Constructor" << std::endl;
//workerThread.start();
std::cout << "Controller Constructor" << std::endl;
}
void WorkerThread::run()
{
L_FUNC(QString("_id='%1'").arg(_id));
qDebug("WorkerThread::run"); // TODO comment this
msleep(500); // [ms]
QString result = QString("%1: Calculate: 6! = %2").arg(_id).arg(factorial(6));
L_INFO(result);
msleep(250); // [ms]
#if TEST_BURST > 0
burst(10*1000); // queue full at ~49'000 ?!
#endif
msleep(250); // [ms]
emit resultReady(result);
}
void NMTThread::run()
{
QString result;
master_Data.NMTable[this->node_id] = Unknown_state;
QTime time;
time.start();
e_nodeState state = Unknown_state;
while(time.elapsed() < this->timeout_ms)
{
state = getNodeState(&master_Data, this->node_id);
if (state != Unknown_state)
break;
}
switch (state) {
case Initialisation:
result = "Initialisation";
break;
case Disconnected:
result = "Disconnected";
break;
case Connecting:
result = "Connecting";
break;
case Pre_operational:
result = "Pre_operational";
break;
case Operational:
result = "Operational";
break;
case Stopped:
result = "Stopped";
break;
default:
result = "Unknown_state";
break;
}
qDebug()<<result;
emit resultReady(result);
}
void GMinimizerThread::run() {
TypeEstimation estim;
TypeTree treeTmp;
TypeFossilFeature *ff;
ff = sampleFossilInt(fos, tree->size);
treeTmp.time = (double*) malloc(tree->size*sizeof(double));
treeTmp.size = tree->size;
treeTmp.sizeBuf = tree->sizeBuf;
treeTmp.root = tree->root;
treeTmp.node = tree->node;
treeTmp.name = NULL;
treeTmp.comment = NULL;
treeTmp.info = NULL;
treeTmp.parent = NULL;
treeTmp.minTime = tree->minTimeInt.inf+UNIF_RAND*(tree->minTimeInt.sup-tree->minTimeInt.inf);
treeTmp.maxTime = tree->maxTimeInt.inf+UNIF_RAND*(tree->maxTimeInt.sup-tree->maxTimeInt.inf);
for(int n=0; n<tree->size; n++) {
if(tree->node[n].child == NOSUCH) {
switch(fos->status[n]) {
case contempNodeStatus:
treeTmp.time[n] = treeTmp.maxTime;
break;
case extinctNodeStatus:
treeTmp.time[n] = NO_TIME;
break;
case unknownNodeStatus:
treeTmp.time[n] = fos->endTimeTable[fos->endTime[n]].inf+UNIF_RAND*(fos->endTimeTable[fos->endTime[n]].sup-fos->endTimeTable[fos->endTime[n]].inf);
break;
default:
fprintf(stderr, "Node %d has no status\n", n);
return;
}
}
}
if(!minimizeBirthDeathFossilFromTreeFossil(likelihood, &treeTmp, ff, options, &estim)) {
estim.logLikelihood = sqrt(-1);
}
free((void*)treeTmp.time);
if(treeTmp.parent != NULL)
free((void*)treeTmp.parent);
freeFossilFeature(ff);
emit resultReady(estim);
}
void doWork(const QImage &origin) {
QImage newImage(origin);
QRgb *bits = (QRgb *)newImage.bits();
int contrastLookup[256];
int pixels = newImage.height() * newImage.width();
for(int i = 0; i < 256; i++)
{
contrastLookup[i] = qBound(0,(int)((((((qreal)i/255.0)-0.5)*m_contrast)+0.5)*255),255);
}
for(int i = 0; i < pixels; i++){
bits[i] = qRgb(qBound(0, contrastLookup[qRed(bits[i])] + m_brightness, 255),
qBound(0, contrastLookup[qGreen(bits[i])] + m_brightness, 255),
qBound(0, contrastLookup[qBlue(bits[i])] + m_brightness, 255));
}
emit resultReady(newImage);
}
// Start the camera
void Camera::start()
{
if (!mCapture.isOpened())
{
// Loading step
QMovie *movie = new QMovie(":/loading.gif");
viewerMessage->setMovie(movie);
movie->start();
ui->dockWidgetCamera->setWidget(viewerMessage);
ui->dockWidgetCamera->setVisible(true);
ThreadInit *t = new ThreadInit();
connect(t, SIGNAL(resultReady(VideoCapture)), this, SLOT(update(VideoCapture)));
t->start();
}
else
{
ui->statusBar->showMessage(tr("/!\\ Camera is not available"));
}
}
void MainWindow::on_goBtn_clicked()
{
ui->goBtn->setEnabled(false);
//ui->processBtn->setEnabled(false);
ui->loadCfBtn->setEnabled(false);
ImageStorage* imgstore = ImageStorage::getInstance();
if (imgstore->isEmpty())
{
QMessageBox::warning(this, tr("Error"), tr("No image in memory..."));
ui->goBtn->setEnabled(true);
ui->loadCfBtn->setEnabled(true);
return;
}
std::pair<const std::string, Ui::SrcAndRes>* current = imgstore->getCurrent();
int stat = controller->setInputImage(current->first, std::get<1>(current->second));
if (stat == success)
{
//CSisrController *ctrl = dynamic_cast<CSisrController *>(controller);
try{
/*ctrl->process();*/
qRegisterMetaType<std::string>("std::string");
ScaleUpThread *workerThread = new ScaleUpThread();
connect(workerThread, SIGNAL(resultReady(std::string)), this, SLOT(getResultofScaleUp(std::string)));
connect(workerThread, SIGNAL(exceptionOccurs()), this, SLOT(scaleUpException()));
connect(workerThread, SIGNAL(scaleUpImageTooLarge()), this, SLOT(scaleUpImgTooLargeException()));
workerThread->start();
}
catch(cv::Exception e)
{
ASSERT(0);
}
ui->showDiffBtn->setEnabled(false);
}
}
void MainWindow::on_loadCfBtn_clicked()
{
ui->goBtn->setEnabled(false);
ui->loadCfBtn->setEnabled(false);
QString fileName = QFileDialog::getOpenFileName(this, tr("Open File"), QString(),
tr("Config Files (*.xml)"));
if (!fileName.isEmpty()) {
CSisrController *ctrl = dynamic_cast<CSisrController *>(controller);
ctrl->setPath(fileName.toStdString());
/*ctrl->loadConfs();*/
LoadConfThread *workerThread = new LoadConfThread();
connect(workerThread, SIGNAL(resultReady()), this, SLOT(updateGoBtn()));
connect(workerThread, SIGNAL(exceptionOccurs()), this, SLOT(loadConfException()));
workerThread->start();
}
else
{
ui->loadCfBtn->setEnabled(true);
ui->goBtn->setEnabled(true);
}
}
