/******************************************************************************
* Performs the actual analysis. This method is executed in a worker thread.
******************************************************************************/
void CreateBondsModifier::BondsEngine::perform()
{
setProgressText(tr("Generating bonds"));
// Determine maximum cutoff.
FloatType maxCutoff = _uniformCutoff;
if(_particleTypes) {
OVITO_ASSERT(_particleTypes->size() == _positions->size());
for(const auto& innerList : _pairCutoffs)
for(const auto& cutoff : innerList)
if(cutoff > maxCutoff) maxCutoff = cutoff;
}
// Prepare the neighbor list.
CutoffNeighborFinder neighborFinder;
if(!neighborFinder.prepare(maxCutoff, _positions.data(), _simCell, this))
return;
// Generate (half) bonds.
size_t particleCount = _positions->size();
setProgressRange(particleCount);
if(!_particleTypes) {
for(size_t particleIndex = 0; particleIndex < particleCount; particleIndex++) {
for(CutoffNeighborFinder::Query neighborQuery(neighborFinder, particleIndex); !neighborQuery.atEnd(); neighborQuery.next()) {
_bonds->push_back({ neighborQuery.unwrappedPbcShift(), (unsigned int)particleIndex, (unsigned int)neighborQuery.current() });
}
// Update progress indicator.
if((particleIndex % 4096) == 0) {
setProgressValue(particleIndex);
if(isCanceled())
return;
}
}
}
else {
for(size_t particleIndex = 0; particleIndex < particleCount; particleIndex++) {
for(CutoffNeighborFinder::Query neighborQuery(neighborFinder, particleIndex); !neighborQuery.atEnd(); neighborQuery.next()) {
int type1 = _particleTypes->getInt(particleIndex);
int type2 = _particleTypes->getInt(neighborQuery.current());
if(type1 >= 0 && type1 < (int)_pairCutoffs.size() && type2 >= 0 && type2 < (int)_pairCutoffs[type1].size()) {
if(neighborQuery.distanceSquared() <= _pairCutoffs[type1][type2])
_bonds->push_back({ neighborQuery.unwrappedPbcShift(), (unsigned int)particleIndex, (unsigned int)neighborQuery.current() });
}
}
// Update progress indicator.
if((particleIndex % 4096) == 0) {
setProgressValue(particleIndex);
if(isCanceled())
return;
}
}
}
setProgressValue(particleCount);
}
QString FormatDBSupportTask::generateReport() const {
QString res;
if (isCanceled()) {
res += QString(tr("Blast database creation has been cancelled")) + "<br>";
if (QFile::exists(externalToolLog)) {
res += prepareLink(externalToolLog);
}
return res;
}
if (!hasError()) {
res += QString(tr("Blast database has been successfully created") + "<br><br>");
res += QString(tr("Source sequences: "));
foreach(const QString &filePath, settings.inputFilesPath){
res += prepareLink(filePath);
if(filePath.size() > 1){
res += "<br> ";
}
}
res += "<br>";
res += QString(tr("Database file path: %1")).arg(QDir::toNativeSeparators(settings.outputPath)) + "<br>";
QString type = settings.isInputAmino ? "protein" : "nucleotide";
res += QString(tr("Type: %1")).arg(type) + "<br>";
if (QFile::exists(externalToolLog)) {
res += QString(tr("Formatdb log file path: "));
res += prepareLink(externalToolLog);
}
}else{
void World::run(){
ZThread::PoolExecutor poolExecutor(sConfig->GetLong("threadPoolSize"));
LOG(LVL_DEBUG,"World::run()");
while(!isCanceled()){
try{
unsigned long delay = m_timersQueue.ShootTimers(GetTickCount());
std::tr1::shared_ptr<WorldMessage> wMsg = m_messageQueue.next(delay);
//helper macros
#define DECLARE_PACKET_CASE(t,h) \
case PacketTypes::t: \
poolExecutor.execute(ZThread::Task(new h(wMsg)));\
break;
//end macros
switch(wMsg->type){
DECLARE_PACKET_CASE(TALK,TalkHandler);
DECLARE_PACKET_CASE(AUTH_REQUEST,AuthHandler);
DECLARE_PACKET_CASE(DISCONNECT,DisconnectHandler);
default:
LOG(LVL_WARNING, "Unknown message to World. Type: %d.", wMsg->type);
}
}
catch (ZThread::Timeout_Exception toExcept){}//no msg added while waiting
catch (...){LOG(LVL_ERROR,"World exception");}//other excpt, like Interrupted or Canceled
}
poolExecutor.wait();
}
Task::ReportResult GzipDecompressTask::report() {
if (hasError() || isCanceled()) {
QDir outputDir(unzippedUrl.dirPath());
outputDir.remove(unzippedUrl.getURLString());
}
return ReportResult_Finished;
}
QList<Task*> GTest_uHMMERSearch::onSubTaskFinished(Task* subTask) {
Q_UNUSED(subTask);
QList<Task*> res;
if (hasError() || isCanceled()) {
return res;
}
if(saveTask && saveTask->isFinished()) {
if (saveTask->hasError()) {
stateInfo.setError( "SaveDocumentTask: "+saveTask->getError() );
}
return res;
} else if(searchTask!=NULL && searchTask->isFinished()) {
if (searchTask->hasError()) {
stateInfo.setError( searchTask->getError() );
return res;
}
if(aDoc == NULL) {
stateInfo.setError( QString("documet creating error") );
return res;
}
if(!resultDocName.isEmpty()) {
QFileInfo fi(aDoc->getURLString());
fi.absoluteDir().mkpath(fi.absoluteDir().absolutePath());
saveTask = new SaveDocumentTask(aDoc);
res.append(saveTask);
}
return res;
}
return res;
}
bool ConstructionTask::update()
{
if(mBuilder)
{
if(shouldReturnUnit())
{
if(!mBuilder->cancel())
mBuilder->stop();
}
else
{
if(!mProducedUnit || !mProducedUnit->exists())
{
if(mReservedLocation && mReservedLocation->isCalculated())
mBuilder->build(mReservedLocation->getTilePosition(), mType);
}
else if(mType.getRace() == BWAPI::Races::Terran && (!mBuilder->isConstructing() || !mProducedUnit->isBeingConstructed()))
mBuilder->build(mProducedUnit);
}
}
if((isStopped() || isCanceled()) && mProducedUnit && mProducedUnit->exists())
{
LOGMESSAGE(String_Builder() << "ConstructionTask : " << mType.getName() << " : Attempting to cancel build");
mProducedUnit->cancel();
}
return hasEnded() && !mBuilder && !mProducedUnit;
}
void * ServerProxy::run() {
while (! isCanceled()) {
std::stringstream msg;
unsigned int msgLen;
std::string commandName;
std::string commandXml;
std::cerr<< std::endl << "################################"<< std::endl<<"ServerProxy leyendo encabezado " << std::endl;
// deshardcodear este 32
msg << socket->full_read(32);
msg >> msgLen;
msg >> commandName;
std::cerr << "longitud " << msgLen << " nombre " << commandName << std::endl;
commandXml = socket->full_read(msgLen);
std::cerr << "serializacion " << commandXml << std::endl;
gameManager->execute(commandName, commandXml);
}
return 0;
}
QList<Task*> DnaAssemblyMultiTask::onSubTaskFinished( Task* subTask ) {
QList<Task*> subTasks;
if (subTask->hasError() || isCanceled()) {
return subTasks;
}
if (subTask == assemblyToRefTask) {
qint64 time=(subTask->getTimeInfo().finishTime - subTask->getTimeInfo().startTime);
taskLog.details(QString("Align to reference task time: %1").arg((double)time/(1000*1000)));
}
if ( subTask == assemblyToRefTask && settings.openView ) {
if (assemblyToRefTask->hasResult()) {
Task* openTask = AppContext::getProjectLoader()->openWithProjectTask(settings.resultFileName);
if (openTask != NULL) {
subTasks << openTask;
}
} else {
QString message = tr("The short reads can't be mapped to the reference sequence!");
coreLog.info(message);
if (NULL != AppContext::getMainWindow()) {
QMessageBox::information(AppContext::getMainWindow()->getQMainWindow(), L10N::warningTitle(), message);
}
}
}
return subTasks;
}
void GenomeAlignerFindTask::run() {
// TODO: this is a fastfix of reopened https://ugene.net/tracker/browse/UGENE-1190
// Problem:
// If reference sequence contains Ns only, ShortReadAligners will return without waiting for all short reads.
// GenomeAlignerTask will create another ReadShortReadsSubTask on GenomeAlignerFindTask->WriteAlignedReadsSubTask subtask finish
// Wait while ReadShortReadsSubTask finished reading.
while (true) {
if (isCanceled()) {
break;
}
QMutexLocker(&(alignContext->readingStatusMutex));
bool isReadingStarted = alignContext->isReadingStarted;
bool isReadingFinished = alignContext->isReadingFinished;
if (isReadingStarted && isReadingFinished) {
break;
}
alignContext->readShortReadsWait.wait(&(alignContext->readingStatusMutex));
}
QReadLocker locker(&alignContext->indexLock);
alignContext->needIndex = false;
alignContext->loadIndexTaskWait.wakeOne();
}
void ExportThread::exportItems( const QString& name, ItemList& items, quint32& currentItem, QTime& time )
{
if( !items.isEmpty() ) {
QDir dir( m_directory );
if( dir.exists() ) {
if( !dir.cd( name ) )
dir.mkdir( name );
dir.cd( name );
QTime rate;
rate.start();
quint32 count = 0;
foreach( TibiaItem* item, items ) {
if( isCanceled() )
break;
if( exportItem( dir, item ) ) {
emit valueChanged( currentItem );
currentItem++;
if( ( float )( rate.elapsed() / 1000 ) >= 1 ) {
emit labelText( tr( "%1\n\nElapsed Time: %2\nTime left: %3" ).arg( m_labelText ).arg( QTime().addMSecs( time.elapsed() ).toString( "hh:mm:ss" ) ).arg( QTime().addMSecs( ( int )( ( ( float )( m_maximum - currentItem ) / count ) * ( float )1000 ) ).toString( "hh:mm:ss" ) ) );
//emit rateChanged( count, libraryFile->getCount() - i, time.elapsed() ); // Items/sec, Items remaining
rate.restart();
count = 0;
}
count++;
}
}
}
}
QList<Task*> WorkflowRunFromCMDLineBase::onSubTaskFinished( Task* subTask ) {
assert( subTask != NULL );
QList<Task*> res;
propagateSubtaskError();
if( hasError() || isCanceled() ) {
return res;
}
assert( !hasError() ); // if error, we won't be here
if( loadTask == subTask ) {
Schema * schema = loadTask->getSchema();
assert( schema != NULL );
remapping = loadTask->getRemapping();
setSchemaCMDLineOptions( schema, optionsStartAt );
if( schema->getDomain().isEmpty() ) {
QList<QString> domainsId = WorkflowEnv::getDomainRegistry()->getAllIds();
assert(!domainsId.isEmpty());
if(!domainsId.isEmpty()) { schema->setDomain(domainsId.first()); }
}
QStringList l;
bool good = WorkflowUtils::validate(*schema, l);
if(!good) {
QString schemaHelpStr = QString("\n\nsee 'ugene --help=%1' for details").arg(schemaName);
setError("\n\n" + l.join("\n\n") + schemaHelpStr);
return res;
}
workflowRunTask = getWorkflowRunTask();
res << workflowRunTask;
}
return res;
}
Task::ReportResult BgzipTask::report() {
if (hasError() || isCanceled()) {
QDir outputDir(bgzfUrl.dirPath());
outputDir.remove(bgzfUrl.getURLString());
}
return ReportResult_Finished;
}
void GzipDecompressTask::run() {
taskLog.details(tr("Start decompression '%1'").arg(zippedUrl.getURLString()));
SAFE_POINT_EXT(AppContext::getIOAdapterRegistry() != NULL, setError(tr("IOAdapterRegistry is NULL!")), );
IOAdapterFactory* inFactory = AppContext::getIOAdapterRegistry()->getIOAdapterFactoryById(BaseIOAdapters::GZIPPED_LOCAL_FILE);
SAFE_POINT_EXT(inFactory != NULL, setError(tr("IOAdapterFactory is NULL!")), );
IOAdapterFactory* outFactory = AppContext::getIOAdapterRegistry()->getIOAdapterFactoryById(BaseIOAdapters::LOCAL_FILE);
SAFE_POINT_EXT(outFactory != NULL, setError(tr("IOAdapterFactory is NULL!")), );
QScopedPointer<IOAdapter> in(inFactory->createIOAdapter());
SAFE_POINT_EXT(!in.isNull(), setError(tr("Can not create IOAdapter!")), );
QScopedPointer<IOAdapter> out(outFactory->createIOAdapter());
SAFE_POINT_EXT(!out.isNull(), setError(tr("Can not create IOAdapter!")), );
if (unzippedUrl.isEmpty()) {
QString unzippedUrlString = zippedUrl.dirPath() + "/" + QFileInfo(zippedUrl.getURLString()).completeBaseName();
if (unzippedUrlString == zippedUrl.getURLString()) {
unzippedUrlString.append("_decompressed");
}
unzippedUrl = GUrl(unzippedUrlString);
}
bool res = out->open( unzippedUrl, IOAdapterMode_Write);
if (!res) {
Task::setError(tr("Can not open output file '%1'").arg(unzippedUrl.getURLString()));
return;
}
res = in->open( zippedUrl, IOAdapterMode_Read);
if (!res) {
Task::setError(tr("Can not open input file '%1'").arg(zippedUrl.getURLString()));
return;
}
const int BUFFER_SIZE = 2097152;
QByteArray readBuffer(BUFFER_SIZE, '\0');
char* buffer = readBuffer.data();
do {
if ( isCanceled() ) {
return;
}
int len = in->readBlock(buffer, BUFFER_SIZE);
if (len == -1) {
stateInfo.setError(tr("Error reading file"));
return;
}
int written = out->writeBlock(buffer, len);
if (written == -1) {
stateInfo.setError(tr("Error writing to file"));
return;
}
} while ( !in->isEof() );
taskLog.details(tr("Decompression finished"));
}
void * PlayerProxy::run() {
while (! isCanceled()) {
std::stringstream msg;
unsigned int msgLen;
std::string commandName;
std::string commandXml;
std::cerr << std::endl << "################################"<< std::endl<< "PlayerProxy leyendo encabezado " << std::endl;
// deshardcodear este 32
std::cerr << "********** A PUNTO DE INVOCAR A SOCKET::FULL_READ(32)" << std::endl << std::endl;
if (getSocket() != NULL) {
std::cerr << "********* SOCKET ERA NULL" << std::endl;
} else {
std::cerr << "********* SOCKET NOOOO ES NULL" << std::endl;
}
msg << getSocket()->full_read(32);
std::cerr << "********** SE INVOCO CORRECTAMENTE A SOCKET::FULL_READ(32)" << std::endl << std::endl;
msg >> msgLen;
msg >> commandName;
std::cerr << "longitud " << msgLen << " nombre " << commandName << std::endl;
commandXml = getSocket()->full_read(msgLen);
//std::cerr << "serializacion " << commandXml << std::endl;
// pasar *this para que los waiting·::joingame sepan
gameManager->execute(commandName, commandXml);
}
return 0;
}
QList<Task*> FormatsMsaClipboardTask::onSubTaskFinished(Task *subTask) {
QList<Task*> res;
QList<Task*> subTasks;
if (subTask->hasError() || isCanceled()) {
return subTasks;
}
if(subTask == createSubalignmentTask){
Document* doc = createSubalignmentTask->getDocument();
SAFE_POINT_EXT(doc != NULL, setError(tr("No temporary document.")), subTasks);
QScopedPointer<LocalFileAdapterFactory> factory( new LocalFileAdapterFactory());
QScopedPointer<IOAdapter> io(factory->createIOAdapter());
if(!io->open(doc->getURL(), IOAdapterMode_Read)){
setError(tr("Cannot read the temporary file."));
return subTasks;
}
QByteArray buf;
while(!io->isEof()){
buf.resize(READ_BUF_SIZE);
buf.fill(0);
bool terminatorFound = false;
int read = io->readLine(buf.data(), READ_BUF_SIZE, &terminatorFound);
buf.resize(read);
result.append(buf);
if (terminatorFound){
result.append('\n');
}
}
}
return res;
}
void RCSDiscoveryManager::DiscoveryTask::cancel()
{
if (isCanceled())
return;
RCSDiscoveryManagerImpl::getInstance()->cancel(m_id);
m_id = RCSDiscoveryManagerImpl::INVALID_ID;
}
void showProgressWindow() {
startJob();
if (isCanceled())
fop_stop(m_fop);
waitJob();
}
//----------------------------------------------------------------------------
void QFutureInterface<ctkCmdLineModuleResult>::reportErrorData(const QByteArray& errorData)
{
QMutexLocker l(&d->Mutex);
if (isCanceled() || isFinished()) return;
d->ErrorData.append(errorData);
d->sendCallOut(ctkCmdLineModuleFutureCallOutEvent(ctkCmdLineModuleFutureCallOutEvent::ErrorReady));
}
void showProgressWindow() {
startJob();
if (isCanceled())
m_fop->stop();
waitJob();
}
bool QgsVectorLayerFeatureCounter::run()
{
QgsLegendSymbolList symbolList = mRenderer->legendSymbolItems();
QgsLegendSymbolList::const_iterator symbolIt = symbolList.constBegin();
for ( ; symbolIt != symbolList.constEnd(); ++symbolIt )
{
mSymbolFeatureCountMap.insert( symbolIt->label(), 0 );
}
// If there are no features to be counted, we can spare us the trouble
if ( mFeatureCount > 0 )
{
int featuresCounted = 0;
// Renderer (rule based) may depend on context scale, with scale is ignored if 0
QgsRenderContext renderContext;
renderContext.setRendererScale( 0 );
renderContext.setExpressionContext( mExpressionContext );
QgsFeatureRequest request;
if ( !mRenderer->filterNeedsGeometry() )
request.setFlags( QgsFeatureRequest::NoGeometry );
request.setSubsetOfAttributes( mRenderer->usedAttributes( renderContext ), mSource->fields() );
QgsFeatureIterator fit = mSource->getFeatures( request );
// TODO: replace QgsInterruptionChecker with QgsFeedback
// fit.setInterruptionChecker( mFeedback );
mRenderer->startRender( renderContext, mSource->fields() );
double progress = 0;
QgsFeature f;
while ( fit.nextFeature( f ) )
{
renderContext.expressionContext().setFeature( f );
QSet<QString> featureKeyList = mRenderer->legendKeysForFeature( f, renderContext );
Q_FOREACH ( const QString &key, featureKeyList )
{
mSymbolFeatureCountMap[key] += 1;
}
++featuresCounted;
double p = ( static_cast< double >( featuresCounted ) / mFeatureCount ) * 100;
if ( p - progress > 1 )
{
progress = p;
setProgress( progress );
}
if ( isCanceled() )
{
mRenderer->stopRender( renderContext );
return false;
}
}
mRenderer->stopRender( renderContext );
}
void FutureInterfaceBase::reportResultReady()
{
if(isCanceled() || isFinished())
return;
_state = State(_state | ResultSet);
_waitCondition.wakeAll();
sendCallOut(FutureWatcher::CallOutEvent::ResultReady);
}
bool QmlProfilerFileReader::loadQtd(QIODevice *device)
{
QXmlStreamReader stream(device);
bool validVersion = true;
while (validVersion && !stream.atEnd() && !stream.hasError()) {
if (isCanceled())
return false;
QXmlStreamReader::TokenType token = stream.readNext();
const QStringRef elementName = stream.name();
switch (token) {
case QXmlStreamReader::StartDocument : continue;
case QXmlStreamReader::StartElement : {
if (elementName == _("trace")) {
QXmlStreamAttributes attributes = stream.attributes();
if (attributes.hasAttribute(_("version")))
validVersion = attributes.value(_("version")) == _(PROFILER_FILE_VERSION);
else
validVersion = false;
if (attributes.hasAttribute(_("traceStart")))
m_traceStart = attributes.value(_("traceStart")).toLongLong();
if (attributes.hasAttribute(_("traceEnd")))
m_traceEnd = attributes.value(_("traceEnd")).toLongLong();
}
if (elementName == _("eventData")) {
loadEventTypes(stream);
emit typesLoaded(m_eventTypes);
break;
}
if (elementName == _("profilerDataModel")) {
loadEvents(stream);
break;
}
if (elementName == _("noteData")) {
loadNotes(stream);
emit notesLoaded(m_notes);
break;
}
break;
}
default: break;
}
}
if (stream.hasError()) {
emit error(tr("Error while parsing trace data file: %1").arg(stream.errorString()));
return false;
} else {
emit success();
return true;
}
}
void FutureInterfaceBase::reportException()
{
//qDebug() << "EXCEPTION FutureInterfaceBase::reportException() this=" << this << "thread=" << QThread::currentThread() << "text=" << progressText();
QMutexLocker locker(&_mutex);
if(isCanceled() || isFinished())
return;
reportException(std::current_exception());
}
QList<Task*> PairwiseAlignmentHirschbergTask::onSubTaskFinished(Task *subTask) {
QList<Task*> res;
if (hasError() || isCanceled()) {
return res;
}
if (subTask->hasError() || subTask->isCanceled()) {
return res;
}
if (subTask == kalignSubTask) {
if (settings->inNewWindow == true) {
TaskStateInfo localStateInfo;
Project * currentProject = AppContext::getProject();
DocumentFormat * format = AppContext::getDocumentFormatRegistry()->getFormatById(BaseDocumentFormats::CLUSTAL_ALN);
Document * alignmentDoc = NULL;
QString newFileUrl = settings->resultFileName.getURLString();
changeGivenUrlIfDocumentExists(newFileUrl, currentProject);
alignmentDoc = format->createNewLoadedDocument(IOAdapterUtils::get(BaseIOAdapters::LOCAL_FILE), GUrl(newFileUrl), localStateInfo);
CHECK_OP(localStateInfo, res);
MAlignment resultMa = kalignSubTask->resultMA;
MAlignmentObject * docObject = MAlignmentImporter::createAlignment(alignmentDoc->getDbiRef(), resultMa, localStateInfo);
CHECK_OP(localStateInfo, res);
alignmentDoc->addObject(docObject);
SaveDocFlags flags = SaveDoc_Overwrite;
flags |= SaveDoc_OpenAfter;
res << new SaveDocumentTask(alignmentDoc, flags);
} else { //in current window
U2OpStatus2Log os;
DbiConnection con(settings->msaRef.dbiRef, os);
CHECK_OP(os, res);
QList<U2MsaRow> rows = con.dbi->getMsaDbi()->getRows(settings->msaRef.entityId, os);
CHECK_OP(os, res);
U2UseCommonUserModStep userModStep(settings->msaRef, os);
Q_UNUSED(userModStep);
SAFE_POINT_OP(os, res);
for (int rowNumber = 0; rowNumber < rows.length(); ++rowNumber) {
if (rows[rowNumber].sequenceId == settings->firstSequenceRef.entityId) {
con.dbi->getMsaDbi()->updateGapModel(settings->msaRef.entityId, rows[rowNumber].rowId, kalignSubTask->resultMA.getRow(0).getGapModel(), os);
CHECK_OP(os, res);
}
if (rows[rowNumber].sequenceId == settings->secondSequenceRef.entityId) {
con.dbi->getMsaDbi()->updateGapModel(settings->msaRef.entityId, rows[rowNumber].rowId, kalignSubTask->resultMA.getRow(1).getGapModel(), os);
CHECK_OP(os, res);
}
}
}
}
return res;
}
virtual void processProgressEvent(ossimProcessProgressEvent& /* event */)
{
if(isCanceled())
{
if(theCurrentProcessInterface)
{
theCurrentProcessInterface->abort();
}
}
}
int
Thread::cancel()
{
if (isNotOk() || !isStarted() || isDetached()) return(-1);
if (isCanceled()) return(0);
int status = ::pthread_cancel(state_.id_);
ThreadMutexLock lock(state_.cs_);
state_.canceled_ = true;
setOk(status == 0);
return(status);
}
void FutureInterfaceBase::setProgressText(const QString& progressText)
{
QMutexLocker locker(&_mutex);
//qDebug() << "FutureInterfaceBase::setProgressText() this=" << this << "thread=" << QThread::currentThread() << "text=" << progressText;
if(isCanceled() || isFinished())
return;
_progressText = progressText;
sendCallOut(FutureWatcher::CallOutEvent::ProgressText, progressText);
}
QString ImportPrimerFromObjectTask::generateReport() const {
const QString docName = (NULL == sequenceObject->getDocument() ? tr("Without document") : sequenceObject->getDocument()->getName());
QString report = QString("<b>%1</b> %2: <font color='%3'>%4</font>").arg(docName).arg(sequenceObject->getGObjectName());
if (isCanceled()) {
return report.arg(L10N::errorColorLabelHtmlStr()).arg(tr("cancelled"));
}
if (hasError()) {
return report.arg(L10N::errorColorLabelHtmlStr()).arg(tr("error")) + ": " + getError();
}
return report.arg(L10N::successColorLabelHtmlStr()).arg(tr("success"));
}
QList<Task*> CopyDocumentTask::onSubTaskFinished(Task *subTask) {
QList<Task*> result;
if (hasError() || isCanceled()) {
return result;
}
if (cloneTask == subTask) {
QList<GObject*> objs = cloneTask->takeResult();
foreach(GObject *dstObj, objs) {
dstObj->moveToThread(QCoreApplication::instance()->thread());
dstDoc->addObject(dstObj);
}
bool TechTask::preUpdate()
{
if(BWAPI::Broodwar->self()->hasResearched(mType))
complete();
if((isStopped() || isCanceled() || isCompleted()) && mUnit && !mUnit->isResearching())
return true;
updateRequirements();
return false;
}
