X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FModel%2FModel_Update.cpp;h=f95f59d7c0f81a202ca8d4f42d8eba5f1338feb4;hb=41f9517e84ae934ce536718d4f48e26731c8430d;hp=403b3dffc759e217a86476a58ac5d94eeb84a630;hpb=114994217c1f77cdc9ab17984456c46808812325;p=modules%2Fshaper.git diff --git a/src/Model/Model_Update.cpp b/src/Model/Model_Update.cpp old mode 100644 new mode 100755 index 403b3dffc..f95f59d7c --- a/src/Model/Model_Update.cpp +++ b/src/Model/Model_Update.cpp @@ -7,6 +7,8 @@ #include #include #include +#include +#include #include #include #include @@ -17,174 +19,595 @@ #include #include #include +#include #include #include #include #include +#include +#include #include #include -#include +#include #include -using namespace std; - Model_Update MY_UPDATER_INSTANCE; /// the only one instance initialized on load of the library +//#define DEB_UPDATE Model_Update::Model_Update() { Events_Loop* aLoop = Events_Loop::loop(); static const Events_ID kChangedEvent = aLoop->eventByName("PreferenceChanged"); aLoop->registerListener(this, kChangedEvent); - static const Events_ID kRebuildEvent = aLoop->eventByName("Rebuild"); - aLoop->registerListener(this, kRebuildEvent); static const Events_ID kCreatedEvent = Events_Loop::loop()->eventByName(EVENT_OBJECT_CREATED); aLoop->registerListener(this, kCreatedEvent); static const Events_ID kUpdatedEvent = Events_Loop::loop()->eventByName(EVENT_OBJECT_UPDATED); aLoop->registerListener(this, kUpdatedEvent); - static const Events_ID kMovedEvent = Events_Loop::loop()->eventByName(EVENT_OBJECT_MOVED); - aLoop->registerListener(this, kMovedEvent); static const Events_ID kOpFinishEvent = aLoop->eventByName("FinishOperation"); aLoop->registerListener(this, kOpFinishEvent); static const Events_ID kOpAbortEvent = aLoop->eventByName("AbortOperation"); aLoop->registerListener(this, kOpAbortEvent); static const Events_ID kOpStartEvent = aLoop->eventByName("StartOperation"); aLoop->registerListener(this, kOpStartEvent); + static const Events_ID kStabilityEvent = aLoop->eventByName(EVENT_STABILITY_CHANGED); + aLoop->registerListener(this, kStabilityEvent); + static const Events_ID kPreviewBlockedEvent = aLoop->eventByName(EVENT_PREVIEW_BLOCKED); + aLoop->registerListener(this, kPreviewBlockedEvent); + static const Events_ID kPreviewRequestedEvent = aLoop->eventByName(EVENT_PREVIEW_REQUESTED); + aLoop->registerListener(this, kPreviewRequestedEvent); + static const Events_ID kReorderEvent = aLoop->eventByName(EVENT_ORDER_UPDATED); + aLoop->registerListener(this, kReorderEvent); + static const Events_ID kUpdatedSel = aLoop->eventByName(EVENT_UPDATE_SELECTION); + aLoop->registerListener(this, kUpdatedSel); + + // Config_PropManager::findProp("Model update", "automatic_rebuild")->value() == "true"; + myIsParamUpdated = false; + myIsFinish = false; + myIsProcessed = false; + myIsPreviewBlocked = false; +} + +bool Model_Update::addModified(FeaturePtr theFeature, FeaturePtr theReason) { + + if (!theFeature->data()->isValid()) + return false; // delete an extrusion created on the sketch + + bool isNotExecuted = theFeature->isPersistentResult() && + !std::dynamic_pointer_cast((theFeature)->document())->executeFeatures(); + if (isNotExecuted) { + if (!theReason.get()) // no reason => no construction reason + return false; + if (myNotPersistentRefs.find(theFeature) == myNotPersistentRefs.end()) { + myNotPersistentRefs[theFeature].insert(theReason); + } else { + std::set > aNewSet; + aNewSet.insert(theReason); + myNotPersistentRefs[theFeature] = aNewSet; + } + return false; + } + + // update arguments for "apply button" state change + if ((!theFeature->isPreviewNeeded() && !myIsFinish) || myIsPreviewBlocked) { + myProcessOnFinish.insert(theFeature); +#ifdef DEB_UPDATE + std::cout<<"*** Add process on finish "<name()< aCurrentlyUpdated; + if (aCurrentlyUpdated.find(theFeature) == aCurrentlyUpdated.end()) { + aCurrentlyUpdated.insert(theFeature); + updateArguments(theFeature); + aCurrentlyUpdated.erase(theFeature); + } + // make it without conditions otherwise the apply button may have a bad state + theFeature->data()->execState(ModelAPI_StateDone); + static ModelAPI_ValidatorsFactory* aFactory = ModelAPI_Session::get()->validators(); + // need to be validated to update the "Apply" state if not previewed + aFactory->validate(theFeature); + + // to redisplay split's arguments presentation, even result is not computed + if (!theFeature->isPreviewNeeded()) { + static Events_Loop* aLoop = Events_Loop::loop(); + static const Events_ID kRedisplayEvent = aLoop->eventByName(EVENT_OBJECT_TO_REDISPLAY); + ModelAPI_EventCreator::get()->sendUpdated(theFeature, kRedisplayEvent); + aLoop->flush(kRedisplayEvent); + } + + if (!myIsPreviewBlocked) + return true; + } + if (myModified.find(theFeature) != myModified.end()) { + if (theReason.get()) { +#ifdef DEB_UPDATE + //std::cout<<"*** Add already modified " + // <name()<<" reason "<name()<isDisabled(); + if (!aIsDisabled) { + std::set > aNewSet; + if (theFeature->data()->execState() == ModelAPI_StateMustBeUpdated || + theFeature->data()->execState() == ModelAPI_StateInvalidArgument || // issue 1519 + theFeature->data()->execState() == ModelAPI_StateExecFailed) { + // do not forget that in this case all were the reasons + aNewSet.insert(theFeature); + } else { + if (theReason.get()) + aNewSet.insert(theReason); + } + myModified[theFeature] = aNewSet; +#ifdef DEB_UPDATE + if (theReason.get()) { + //std::cout<<"*** Add modified "<name() + // <<" reason "<name()<name()<data()->execState() == ModelAPI_StateDone || + theFeature->data()->execState() == ModelAPI_StateExecFailed) // fix issue 1819 + theFeature->data()->execState(ModelAPI_StateMustBeUpdated); + else + return true; // do not need iteration deeply if it is already marked as modified or so +#ifdef DEB_UPDATE + //std::cout<<"*** Set modified state "<name()< >& aRefs = theFeature->data()->refsToMe(); + std::set >::const_iterator aRefIter = aRefs.cbegin(); + for(; aRefIter != aRefs.cend(); aRefIter++) { + if ((*aRefIter)->isArgument()) { + FeaturePtr aReferenced = std::dynamic_pointer_cast((*aRefIter)->owner()); + if (aReferenced.get()) { + addModified(aReferenced, theFeature); + } + } + } + // proccess also results + std::list allResults; // list of this feature and results + ModelAPI_Tools::allResults(theFeature, allResults); + std::list::iterator aRes = allResults.begin(); + for(; aRes != allResults.end(); aRes++) { + const std::set >& aRefs = (*aRes)->data()->refsToMe(); + std::set >::const_iterator aRefIter = aRefs.cbegin(); + for(; aRefIter != aRefs.cend(); aRefIter++) { + if ((*aRefIter)->isArgument()) { + FeaturePtr aReferenced = std::dynamic_pointer_cast((*aRefIter)->owner()); + if (aReferenced.get()) { + addModified(aReferenced, theFeature); + } + } + } + } - Config_PropManager::registerProp("Model update", "automatic_rebuild", "Rebuild immediately", - Config_Prop::Boolean, "false"); - myIsAutomatic = - Config_PropManager::findProp("Model update", "automatic_rebuild")->value() == "true"; + // also add part feature that contains this feature to the modified + if (theFeature->document()->kind() != "PartSet") { + FeaturePtr aPart = ModelAPI_Tools::findPartFeature( + ModelAPI_Session::get()->moduleDocument(), theFeature->document()); + if (aPart.get()) + addModified(aPart, theFeature); + } + return true; } void Model_Update::processEvent(const std::shared_ptr& theMessage) { static Events_Loop* aLoop = Events_Loop::loop(); - static const Events_ID kChangedEvent = aLoop->eventByName("PreferenceChanged"); - static const Events_ID kRebuildEvent = aLoop->eventByName("Rebuild"); static const Events_ID kCreatedEvent = aLoop->eventByName(EVENT_OBJECT_CREATED); static const Events_ID kUpdatedEvent = aLoop->eventByName(EVENT_OBJECT_UPDATED); - static const Events_ID kMovedEvent = Events_Loop::loop()->eventByName(EVENT_OBJECT_MOVED); static const Events_ID kOpFinishEvent = aLoop->eventByName("FinishOperation"); static const Events_ID kOpAbortEvent = aLoop->eventByName("AbortOperation"); static const Events_ID kOpStartEvent = aLoop->eventByName("StartOperation"); - bool isAutomaticChanged = false; - if (theMessage->eventID() == kChangedEvent) { // automatic and manual rebuild flag is changed - bool aPropVal = - Config_PropManager::findProp("Model update", "automatic_rebuild")->value() == "true"; - if (aPropVal == myIsAutomatic) - return; // nothing is changed, so nithing to do - myIsAutomatic = aPropVal; - if (!myIsAutomatic) - return; // less automatization => nothing to do - } else if (theMessage->eventID() == kRebuildEvent) { // the rebuild command - if (myIsAutomatic == false) { - isAutomaticChanged = true; - myIsAutomatic = true; - } - } else if (theMessage->eventID() == kCreatedEvent || theMessage->eventID() == kUpdatedEvent || - theMessage->eventID() == kMovedEvent) { + static const Events_ID kStabilityEvent = aLoop->eventByName(EVENT_STABILITY_CHANGED); + static const Events_ID kPreviewBlockedEvent = aLoop->eventByName(EVENT_PREVIEW_BLOCKED); + static const Events_ID kPreviewRequestedEvent = aLoop->eventByName(EVENT_PREVIEW_REQUESTED); + static const Events_ID kReorderEvent = aLoop->eventByName(EVENT_ORDER_UPDATED); + static const Events_ID kRedisplayEvent = aLoop->eventByName(EVENT_OBJECT_TO_REDISPLAY); + static const Events_ID kUpdatedSel = aLoop->eventByName(EVENT_UPDATE_SELECTION); + +#ifdef DEB_UPDATE + std::cout<<"****** Event "<eventID().eventText()<eventID() == kStabilityEvent) { + updateStability(theMessage->sender()); + return; + } + if (theMessage->eventID() == kPreviewBlockedEvent) { + myIsPreviewBlocked = true; + return; + } + if (theMessage->eventID() == kPreviewRequestedEvent) { + if (myIsPreviewBlocked) { + myIsPreviewBlocked = false; + processFeatures(); + myIsPreviewBlocked = true; + } + return; + } + if (theMessage->eventID() == kUpdatedSel) { + std::shared_ptr aMsg = + std::dynamic_pointer_cast(theMessage); + updateSelection(aMsg->objects()); + } + // creation is added to "update" to avoid recomputation twice: + // on create and immediately after on update + if (theMessage->eventID() == kCreatedEvent) { std::shared_ptr aMsg = std::dynamic_pointer_cast(theMessage); const std::set& anObjs = aMsg->objects(); std::set::const_iterator anObjIter = anObjs.cbegin(); for(; anObjIter != anObjs.cend(); anObjIter++) { - myJustCreatedOrUpdated.insert(*anObjIter); - // created objects are always must be up to date (python box feature) - // and updated not in internal uptation chain - if (!myIsExecuted || theMessage->eventID() == kCreatedEvent) - myInitial.insert(*anObjIter); - // TODO(mpv): check the next line. Came into dev 0.6.1 from BR_PYTHON_PLUGIN - // (*anObjIter)->data()->mustBeUpdated(true); // object must be updated because it was changed - } - if (theMessage->eventID() == kMovedEvent) - return; // this event is for solver update, not here - } else if (theMessage->eventID() == kOpStartEvent) { - myJustCreatedOrUpdated.clear(); - myInitial.clear(); - return; // we don't need the update only on operation start (caused problems in PartSet_Listener::processEvent) - } else if (theMessage->eventID() == kOpFinishEvent || theMessage->eventID() == kOpAbortEvent) { - if (myIsAutomatic == false) { // Apply button now works as "Rebuild" - isAutomaticChanged = true; - myIsAutomatic = true; - } - // the hardcode (DBC asked): hide the sketch referenced by extrusion on apply - if (theMessage->eventID() == kOpFinishEvent) { - std::set >::iterator aFIter; - for(aFIter = myJustCreatedOrUpdated.begin(); aFIter != myJustCreatedOrUpdated.end(); aFIter++) - { - FeaturePtr aF = std::dynamic_pointer_cast(*aFIter); - if (aF && aF->data().get() && aF->getKind() == "Extrusion") { - AttributeSelectionListPtr aBase = aF->selectionList("base"); - if (aBase.get()) { - for(int a = aBase->size() - 1; a >= 0; a--) { - ResultPtr aSketchRes = aBase->value(a)->context(); - if (aSketchRes) { - static Events_ID HIDE_DISP = Events_Loop::loop()->eventByName(EVENT_OBJECT_TOHIDE); - ModelAPI_EventCreator::get()->sendUpdated(aSketchRes, HIDE_DISP); - } - } + if (std::dynamic_pointer_cast((*anObjIter)->document())->executeFeatures()) { + if ((*anObjIter)->groupName() == ModelAPI_Feature::group()) { + // results creation means enabling, not update + ModelAPI_EventCreator::get()->sendUpdated(*anObjIter, kUpdatedEvent); + } else { + ModelAPI_EventCreator::get()->sendUpdated(*anObjIter, kRedisplayEvent); + } + } + } + return; + } + if (theMessage->eventID() == kUpdatedEvent) { + std::shared_ptr aMsg = + std::dynamic_pointer_cast(theMessage); + const std::set& anObjs = aMsg->objects(); + std::set::const_iterator anObjIter = anObjs.cbegin(); + bool aSomeModified = false; // check that features not changed: only redisplay is needed + for(; anObjIter != anObjs.cend(); anObjIter++) { + if (!(*anObjIter)->data()->isValid()) + continue; +#ifdef DEB_UPDATE + std::cout<<">>> in event updated "<<(*anObjIter)->groupName()<< + " "<<(*anObjIter)->data()->name()<groupName() == ModelAPI_ResultParameter::group()) { + myIsParamUpdated = true; + } + // on undo/redo, abort do not update persisten features + FeaturePtr anUpdated = std::dynamic_pointer_cast(*anObjIter); + if (anUpdated.get()) { + if (addModified(anUpdated, FeaturePtr())) + aSomeModified = true; + } else { + // process the updated result as update of features that refers to this result + const std::set >& + aRefs = (*anObjIter)->data()->refsToMe(); + std::set >::const_iterator aRefIter = aRefs.cbegin(); + for(; aRefIter != aRefs.cend(); aRefIter++) { + if (!(*aRefIter)->owner()->data()->isValid()) + continue; + FeaturePtr anUpdated = std::dynamic_pointer_cast((*aRefIter)->owner()); + if (anUpdated.get()) { + if (addModified(anUpdated, FeaturePtr())) + aSomeModified = true; } } } } + // this event is for solver update, not here, do not react immediately + if (aSomeModified) { + processFeatures(); + } + } else if (theMessage->eventID() == kOpFinishEvent || theMessage->eventID() == kOpAbortEvent || + theMessage->eventID() == kOpStartEvent) { + myIsPreviewBlocked = false; + + if (theMessage->eventID() == kOpFinishEvent) { + myIsFinish = true; + // add features that wait for finish as modified + std::set >::iterator aFeature = myProcessOnFinish.begin(); + for(; aFeature != myProcessOnFinish.end(); aFeature++) + if ((*aFeature)->data()->isValid()) // there may be already removed wait for features + addModified(*aFeature, FeaturePtr()); + myIsFinish = false; + } + // processed features must be only on finish, so clear anyway (to avoid reimport on load) + myProcessOnFinish.clear(); + + if (!(theMessage->eventID() == kOpStartEvent)) { + processFeatures(false); + } + // remove all macros before clearing all created + std::set::iterator anUpdatedIter = myWaitForFinish.begin(); + while(anUpdatedIter != myWaitForFinish.end()) { + FeaturePtr aFeature = std::dynamic_pointer_cast(*anUpdatedIter); + if (aFeature.get()) { + // remove macro on finish + if (aFeature->isMacro()) { + aFeature->document()->removeFeature(aFeature); + myWaitForFinish.erase(aFeature); + } + // to avoid the map update problems on "remove" + if (myWaitForFinish.find(aFeature) == myWaitForFinish.end()) { + anUpdatedIter = myWaitForFinish.begin(); + } else { + anUpdatedIter++; + } + } else { + anUpdatedIter++; + } + } + // the redisplay signal should be flushed in order + // to erase the feature presentation in the viewer + // if should be done after removeFeature() of document, + // by this reason, upper processFeatures() do not perform this flush + Events_Loop::loop()->flush(kRedisplayEvent); + + // in the end of transaction everything is updated, so clear the old objects + myIsParamUpdated = false; + myWaitForFinish.clear(); + } else if (theMessage->eventID() == kReorderEvent) { + std::shared_ptr aMsg = + std::dynamic_pointer_cast(theMessage); + if (aMsg->reordered().get()) + addModified(aMsg->reordered(), aMsg->reordered()); // to update all attributes } +} - if (myIsExecuted) - return; // nothing to do: it is executed now +void Model_Update::processFeatures(const bool theFlushRedisplay) +{ + // perform update of everything if it is not performed right now or any preview is blocked + if (!myIsProcessed && !myIsPreviewBlocked) { + myIsProcessed = true; + #ifdef DEB_UPDATE + std::cout<<"****** Start processing"<moduleDocument()); + while(!myModified.empty()) { + processFeature(myModified.begin()->first); + } + myIsProcessed = false; - myUpdated.clear(); - // flush to update display - static Events_ID EVENT_DISP = aLoop->eventByName(EVENT_OBJECT_TO_REDISPLAY); - aLoop->flush(EVENT_DISP); - //Events_LongOp::end(this); - if (isAutomaticChanged) myIsAutomatic = false; + // to update the object browser if something is updated/created during executions + static Events_Loop* aLoop = Events_Loop::loop(); + static const Events_ID kCreatedEvent= aLoop->eventByName(EVENT_OBJECT_CREATED); + aLoop->flush(kCreatedEvent); + static const Events_ID kUpdatedEvent = aLoop->eventByName(EVENT_OBJECT_UPDATED); + aLoop->flush(kUpdatedEvent); - if (theMessage->eventID() == kOpFinishEvent || theMessage->eventID() == kOpAbortEvent) { - myJustCreatedOrUpdated.clear(); - myInitial.clear(); + // flush to update display + if (theFlushRedisplay) { + static Events_ID EVENT_DISP = aLoop->eventByName(EVENT_OBJECT_TO_REDISPLAY); + aLoop->flush(EVENT_DISP); + } + #ifdef DEB_UPDATE + std::cout<<"****** End processing"<& theReasons) { + std::list > > > aDeps; + theFeature->data()->referencesToObjects(aDeps); + std::list > > >::iterator + anAttrsIter = aDeps.begin(); + for(; anAttrsIter != aDeps.end(); anAttrsIter++) { + if (theFeature->attribute(anAttrsIter->first)->isArgument()) { + std::list >::iterator aDepIter = anAttrsIter->second.begin(); + for(; aDepIter != anAttrsIter->second.end(); aDepIter++) { + FeaturePtr aDepFeat = std::dynamic_pointer_cast(*aDepIter); + if (!aDepFeat.get()) { // so, it depends on the result and process the feature owner of it + ResultPtr aDepRes = std::dynamic_pointer_cast(*aDepIter); + if (aDepRes.get()) { + aDepFeat = (*aDepIter)->document()->feature(aDepRes); + } + } + if (aDepFeat.get() && aDepFeat->data()->isValid()) { + theReasons.insert(aDepFeat); + } + } + } + } + if (theFeature->getKind() == "Part") { + // part is not depended on its subs directly, but subs must be iterated anyway + CompositeFeaturePtr aPart = std::dynamic_pointer_cast(theFeature); + int aNum = aPart->numberOfSubs(); + for(int a = 0; a < aNum; a++) { + FeaturePtr aSub = aPart->subFeature(a); + if (aSub.get() && aSub->data()->isValid()) { + theReasons.insert(aSub); + } + } + } } -void Model_Update::updateInDoc(std::shared_ptr theDoc) +bool Model_Update::processFeature(FeaturePtr theFeature) { - // all features one by one - int aNbFeatures = theDoc->size(ModelAPI_Feature::group(), true); - for (int aFIndex = 0; aFIndex < aNbFeatures; aFIndex++) { - FeaturePtr aFeature = std::dynamic_pointer_cast( - theDoc->object(ModelAPI_Feature::group(), aFIndex, true)); - if (aFeature) - updateFeature(aFeature); - } - // all sub-documents one by one - std::shared_ptr aDoc = std::dynamic_pointer_cast(theDoc); - if (aDoc) { - const std::set aSubs = aDoc->subDocuments(true); - for(std::set::iterator aSub = aSubs.begin(); aSub != aSubs.end(); aSub++) { - DocumentPtr aSubDoc = theDoc->subDocument(*aSub); - if (aSubDoc) { - updateInDoc(aSubDoc); + static ModelAPI_ValidatorsFactory* aFactory = ModelAPI_Session::get()->validators(); + + if (!theFeature->data()->isValid()) { // deleted feature, just remove from all containers + if (myModified.find(theFeature) != myModified.end()) + myModified.erase(theFeature); + return false; + } + + if (theFeature->isPersistentResult()) { + if (!std::dynamic_pointer_cast((theFeature)->document())->executeFeatures()) + return false; + } + + if (myProcessed.find(theFeature) == myProcessed.end()) { + myProcessed[theFeature] = 0; + } else { + int aCount = myProcessed[theFeature]; + if (aCount > 100) { + // too many repetition of processing (in VS it may crash on 330 with stack overflow) + Events_InfoMessage("Model_Update", + "Feature '%1' is updated in infinitive loop").arg(theFeature->data()->name()).send(); + // to stop iteration + myModified.clear(); + return false; + } + myProcessed[theFeature] = aCount + 1; + } + + // check this feature is not yet checked or processed + bool aIsModified = myModified.find(theFeature) != myModified.end(); + if (!aIsModified && myIsFinish) { // get info about the modification for features without preview + if (theFeature->data()->execState() == ModelAPI_StateMustBeUpdated) { + aIsModified = true; + std::set > aNewSet; + // contains itself, so, we don't know which was the reason and the reason is any + aNewSet.insert(theFeature); + myModified[theFeature] = aNewSet; + } + } + +#ifdef DEB_UPDATE + std::cout<<"* Process feature "<name()<getKind() == "Sketch") { +#ifdef DEB_UPDATE + std::cout<<"****** Update sketch args "<name()<selection("External"); + if (anExtSel.get()) { + ResultPtr aContext = anExtSel->context(); + if (aContext.get() && aContext->document().get()) { + FeaturePtr anExtBase = aContext->document()->feature(aContext); + if (anExtBase.get()) { + processFeature(anExtBase); + } } } + updateArguments(theFeature); + // send event that sketch is prepared to be recomputed + static Events_ID anID = Events_Loop::eventByName("SketchPrepared"); + std::shared_ptr aMsg(new Events_Message(anID, this)); + Events_Loop::loop()->send(aMsg); + } + + if (!aIsModified) { // no modification is needed + return false; + } + + // evaluate parameter before the sub-elements update: + // it updates dependencies on evaluation (#1085) + if (theFeature->getKind() == "Parameter") { + theFeature->execute(); + } + + bool isReferencedInvalid = false; + // check all features this feature depended on (recursive call of updateFeature) + std::set& aReasons = myModified[theFeature]; + bool allSubsUsed = aReasons.find(theFeature) != aReasons.end(); + if (allSubsUsed) { + // add all subs in aReasons and temporary remove "theFeature" to avoid processing itself + allReasons(theFeature, aReasons); + aReasons.erase(theFeature); + } + // take reasons one by one (they may be added during the feature process + // (circle by the radius of sketch) + std::set aProcessedReasons; + while(!aReasons.empty()) { + FeaturePtr aReason = *(aReasons.begin()); +#ifdef DEB_UPDATE + //cout<name()<<" process next reason "<name()<data()->isValid()) { + if (processFeature(aReason)) + aIsModified = true; + if (aReason->data()->execState() == ModelAPI_StateInvalidArgument) + isReferencedInvalid = true; + } + // searching for the next not used reason + aProcessedReasons.insert(aReason); + aReasons.erase(aReason); + } + // restore the modified reasons: they will be used in the update of arguments + if (allSubsUsed) { // restore theFeature in this set + aProcessedReasons.insert(theFeature); + } + myModified[theFeature] = aProcessedReasons; + + // do not execute the composite that contains the current + bool isPostponedMain = false; + CompositeFeaturePtr aCompos = std::dynamic_pointer_cast(theFeature); + if (theFeature->getKind() == "ExtrusionSketch" && aCompos.get()) { + CompositeFeaturePtr aCurrentOwner = + ModelAPI_Tools::compositeOwner(theFeature->document()->currentFeature(false)); + isPostponedMain = aCurrentOwner.get() && aCompos->isSub(aCurrentOwner); + } + +#ifdef DEB_UPDATE + std::cout<<"Update args "<name()<data()->isValid()) + return false; + // Update selection and parameters attributes first, before sub-features analysis (sketch plane). + updateArguments(theFeature); + + // add this feature to the processed right now to be able remove it from this list on + // update signal during this feature execution + myModified.erase(theFeature); + if (myNotPersistentRefs.find(theFeature) != myNotPersistentRefs.end()) + myNotPersistentRefs.erase(theFeature); + if (theFeature->data()->execState() == ModelAPI_StateMustBeUpdated) + theFeature->data()->execState(ModelAPI_StateDone); + + // this checking must be after the composite feature sub-elements processing: + // composite feature status may depend on it's subelements + if ((theFeature->data()->execState() == ModelAPI_StateInvalidArgument || isReferencedInvalid) && + theFeature->getKind() != "Part") { + // don't disable Part because it will make disabled all the features + // (performance and problems with the current feature) + #ifdef DEB_UPDATE + std::cout<<"Invalid args "<name()<eraseResults(); + redisplayWithResults(theFeature, ModelAPI_StateInvalidArgument); // result also must be updated + return true; // so, feature is modified (results are erased) + } + + // execute feature if it must be updated + ModelAPI_ExecState aState = theFeature->data()->execState(); + if (aFactory->validate(theFeature)) { + if (!isPostponedMain) { + executeFeature(theFeature); + } + } else { + #ifdef DEB_UPDATE + std::cout<<"Feature is not valid, erase results "<name()<eraseResults(); + redisplayWithResults(theFeature, ModelAPI_StateInvalidArgument); // result also must be updated } + return true; } -void Model_Update::redisplayWithResults(FeaturePtr theFeature, const ModelAPI_ExecState theState) +void Model_Update::redisplayWithResults(FeaturePtr theFeature, const ModelAPI_ExecState theState) { // make updated and redisplay all results static Events_ID EVENT_DISP = Events_Loop::loop()->eventByName(EVENT_OBJECT_TO_REDISPLAY); - const std::list >& aResults = theFeature->results(); - std::list >::const_iterator aRIter = aResults.begin(); - for (; aRIter != aResults.cend(); aRIter++) { + + std::list allResults; + ModelAPI_Tools::allResults(theFeature, allResults); + std::list::iterator aRIter = allResults.begin(); + for (; aRIter != allResults.cend(); aRIter++) { std::shared_ptr aRes = *aRIter; - aRes->data()->execState(theState); - myUpdated[aRes] = true; + if (!aRes->isDisabled()) { + // update state only for enabled results + // (Placement Result Part may make the original Part Result as invalid) + aRes->data()->execState(theState); + } + if (theFeature->data()->updateID() > aRes->data()->updateID()) { + aRes->data()->setUpdateID(theFeature->data()->updateID()); + } ModelAPI_EventCreator::get()->sendUpdated(aRes, EVENT_DISP); } // to redisplay "presentable" feature (for ex. distance constraint) @@ -198,7 +621,8 @@ ModelAPI_ExecState stateByReference(ObjectPtr theTarget, const ModelAPI_ExecStat if (theTarget) { ModelAPI_ExecState aRefState = theTarget->data()->execState(); if (aRefState == ModelAPI_StateMustBeUpdated) { - return ModelAPI_StateMustBeUpdated; + if (theCurrent == ModelAPI_StateDone) + return ModelAPI_StateMustBeUpdated; } else if (aRefState != ModelAPI_StateDone) { return ModelAPI_StateInvalidArgument; } @@ -206,206 +630,295 @@ ModelAPI_ExecState stateByReference(ObjectPtr theTarget, const ModelAPI_ExecStat return theCurrent; } -bool Model_Update::updateFeature(FeaturePtr theFeature) -{ - // check it is already processed - if (myUpdated.find(theFeature) != myUpdated.end()) - return myUpdated[theFeature]; - // check all features this feature depended on (recursive call of updateFeature) - ModelAPI_ValidatorsFactory* aFactory = ModelAPI_Session::get()->validators(); - bool aMustbeUpdated = myInitial.find(theFeature) != myInitial.end(); - if (theFeature) { // only real feature contains references to other objects - if (theFeature->data()->execState() != ModelAPI_StateDone) - aMustbeUpdated = true; +void Model_Update::updateArguments(FeaturePtr theFeature) { + // perform this method also for disabled features: to make "not done" state for + // features referenced to the active and modified features - ModelAPI_ExecState aState = ModelAPI_StateDone; + static ModelAPI_ValidatorsFactory* aFactory = ModelAPI_Session::get()->validators(); - // check the parameters: values can be changed - std::list aDoubles = - theFeature->data()->attributes(ModelAPI_AttributeDouble::typeId()); + ModelAPI_ExecState aState = theFeature->data()->execState(); + if (aState == ModelAPI_StateExecFailed) { // try again failed feature: issue 577 + aState = ModelAPI_StateMustBeUpdated; + } + if (aState == ModelAPI_StateInvalidArgument) // a chance to be corrected + aState = ModelAPI_StateMustBeUpdated; + // check the parameters state + // Integer + { + std::list anAttrinbutes = + theFeature->data()->attributes(ModelAPI_AttributeInteger::typeId()); + std::list::iterator anIter = anAttrinbutes.begin(); + for(; anIter != anAttrinbutes.end(); anIter++) { + AttributeIntegerPtr anAttribute = + std::dynamic_pointer_cast(*anIter); + if (anAttribute.get() && !anAttribute->text().empty()) { + if (myIsParamUpdated) { + ModelAPI_AttributeEvalMessage::send(anAttribute, this); + } + if (anAttribute->expressionInvalid()) { + aState = ModelAPI_StateInvalidArgument; + } + } + } + } + // Double + { + std::list aDoubles = + theFeature->data()->attributes(ModelAPI_AttributeDouble::typeId()); std::list::iterator aDoubleIter = aDoubles.begin(); for(; aDoubleIter != aDoubles.end(); aDoubleIter++) { - AttributeDoublePtr aDouble = + AttributeDoublePtr aDouble = std::dynamic_pointer_cast(*aDoubleIter); if (aDouble.get() && !aDouble->text().empty()) { - double aNewVal; - if (ModelAPI_Tools::findVariable(aDouble->text(), aNewVal)) { - if (aNewVal != aDouble->value()) { - aDouble->setValue(aNewVal); - aMustbeUpdated = true; - } - } else { + if (myIsParamUpdated) { + ModelAPI_AttributeEvalMessage::send(aDouble, this); + } + if (aDouble->expressionInvalid()) { aState = ModelAPI_StateInvalidArgument; } } } - - // composite feature must be executed after sub-features execution - CompositeFeaturePtr aComposite = - std::dynamic_pointer_cast(theFeature); - if (aComposite) { - // number of subs can be changed in execution: like fillet - for(int a = 0; a < aComposite->numberOfSubs(); a++) { - if (updateFeature(aComposite->subFeature(a))) - aMustbeUpdated = true; + } + // Point + { + std::list anAttributes = + theFeature->data()->attributes(GeomDataAPI_Point::typeId()); + std::list::iterator anIter = anAttributes.begin(); + for(; anIter != anAttributes.end(); anIter++) { + AttributePointPtr aPointAttribute = + std::dynamic_pointer_cast(*anIter); + if (aPointAttribute.get() && (!aPointAttribute->textX().empty() || + !aPointAttribute->textY().empty() || !aPointAttribute->textZ().empty())) { + if (myIsParamUpdated) { + ModelAPI_AttributeEvalMessage::send(aPointAttribute, this); + } + if ((!aPointAttribute->textX().empty() && aPointAttribute->expressionInvalid(0)) || + (!aPointAttribute->textY().empty() && aPointAttribute->expressionInvalid(1)) || + (!aPointAttribute->textZ().empty() && aPointAttribute->expressionInvalid(2))) + aState = ModelAPI_StateInvalidArgument; } } - // check all references: if referenced objects are updated, this object also must be updated - // also check state of referenced objects: if they are not ready, inherit corresponding state - std::list > > aRefs; - std::shared_ptr aData = - std::dynamic_pointer_cast(theFeature->data()); - aData->referencesToObjects(aRefs); - std::list > >::iterator aRef = aRefs.begin(); - for(; aRef != aRefs.end(); aRef++) { - std::list::iterator aRefObj = aRef->second.begin(); - for(; aRefObj != aRef->second.end(); aRefObj++) { - if (updateObject(*aRefObj)) { - aMustbeUpdated = true; + } + // Point2D + { + std::list anAttributes = + theFeature->data()->attributes(GeomDataAPI_Point2D::typeId()); + std::list::iterator anIter = anAttributes.begin(); + for(; anIter != anAttributes.end(); anIter++) { + AttributePoint2DPtr aPoint2DAttribute = + std::dynamic_pointer_cast(*anIter); + if (aPoint2DAttribute.get()) { + if (myIsParamUpdated && (!aPoint2DAttribute->textX().empty() || + !aPoint2DAttribute->textY().empty())) { + ModelAPI_AttributeEvalMessage::send(aPoint2DAttribute, this); } - aState = stateByReference(*aRefObj, aState); + if ((!aPoint2DAttribute->textX().empty() && aPoint2DAttribute->expressionInvalid(0)) || + (!aPoint2DAttribute->textY().empty() && aPoint2DAttribute->expressionInvalid(1))) + aState = ModelAPI_StateInvalidArgument; } } - - //std::cout<<"Update feature "<getKind()<<" must be updated = "<(theFeature->document())->executeFeatures() || - !theFeature->isPersistentResult()) { - if (aFactory->validate(theFeature)) { - if (myIsAutomatic || - (myJustCreatedOrUpdated.find(theFeature) != myJustCreatedOrUpdated.end()) || - !theFeature->isPersistentResult() /* execute quick, not persistent results */) - { - if (aState == ModelAPI_StateDone) {// all referenced objects are ready to be used - //std::cout<<"Execute feature "<getKind()< aRefs = - theFeature->data()->attributes(ModelAPI_AttributeSelection::typeId()); - list::iterator aRefsIter = aRefs.begin(); - for (; aRefsIter != aRefs.end(); aRefsIter++) { - std::shared_ptr aSel = - std::dynamic_pointer_cast(*aRefsIter); - if (!aSel->update()) { // this must be done on execution since it may be long operation - if (!aFactory->isNotObligatory(theFeature->getKind(), theFeature->data()->id(aSel)) && - aFactory->isCase(theFeature, theFeature->data()->id(aSel))) - aState = ModelAPI_StateInvalidArgument; - } - } - aRefs = theFeature->data()->attributes(ModelAPI_AttributeSelectionList::typeId()); - for (aRefsIter = aRefs.begin(); aRefsIter != aRefs.end(); aRefsIter++) { - std::shared_ptr aSel = - std::dynamic_pointer_cast(*aRefsIter); - for(int a = aSel->size() - 1; a >= 0; a--) { - std::shared_ptr aSelAttr = - std::dynamic_pointer_cast(aSel->value(a)); - if (aSelAttr) { - if (!aSelAttr->update()) { - if (!aFactory->isNotObligatory( - theFeature->getKind(), theFeature->data()->id(aSel)) && - aFactory->isCase(theFeature, theFeature->data()->id(aSel))) - aState = ModelAPI_StateInvalidArgument; - } - } - } - } - // for sketch after update of plane (by update of selection attribute) - // but before execute, all sub-elements also must be updated (due to the plane changes) - if (aComposite) { - // number of subs can be changed in execution: like fillet - for(int a = 0; a < aComposite->numberOfSubs(); a++) { - FeaturePtr aSub = aComposite->subFeature(a); - bool aWasModified = myUpdated[aSub]; - myUpdated.erase(myUpdated.find(aSub)); // erase to update for sure (plane may be changed) - myInitial.insert(aSub); - updateFeature(aSub); - myUpdated[aSub] = aWasModified; // restore value - } - // re-execute after update: solver may update the previous values, so, shapes must be - // updated - for(int a = 0; a < aComposite->numberOfSubs(); a++) { - if (aComposite->subFeature(a) && aFactory->validate(aComposite->subFeature(a))) - aComposite->subFeature(a)->execute(); - } - } + } + // update the selection attributes if any + std::list aRefs = + theFeature->data()->attributes(ModelAPI_AttributeSelection::typeId()); + std::list::iterator aRefsIter = aRefs.begin(); + for (; aRefsIter != aRefs.end(); aRefsIter++) { + std::shared_ptr aSel = + std::dynamic_pointer_cast(*aRefsIter); + ObjectPtr aContext = aSel->context(); + // update argument only if the referenced object is ready to use + if (aContext.get() && !aContext->isDisabled()) { + if (isReason(theFeature, aContext)) { + if (!aSel->update()) { // this must be done on execution since it may be long operation + bool isObligatory = !aFactory->isNotObligatory( + theFeature->getKind(), theFeature->data()->id(aSel)) && + aFactory->isCase(theFeature, theFeature->data()->id(aSel)); + if (isObligatory) + aState = ModelAPI_StateInvalidArgument; + } + } + } else if (aContext.get()) { + // here it may be not obligatory, but if the reference is wrong, it should not be correct + bool isObligatory = aFactory->isCase(theFeature, theFeature->data()->id(aSel)); + if (isObligatory) + aState = ModelAPI_StateInvalidArgument; + } + } + // update the selection list attributes if any + aRefs = theFeature->data()->attributes(ModelAPI_AttributeSelectionList::typeId()); + for (aRefsIter = aRefs.begin(); aRefsIter != aRefs.end(); aRefsIter++) { + std::shared_ptr aSel = + std::dynamic_pointer_cast(*aRefsIter); + for(int a = aSel->size() - 1; a >= 0; a--) { + std::shared_ptr aSelAttr = + std::dynamic_pointer_cast(aSel->value(a)); + if (aSelAttr) { + ObjectPtr aContext = aSelAttr->context(); + // update argument only if the referenced object is ready to use + if (aContext.get() && !aContext->isDisabled()) { + if (isReason(theFeature, aContext)) { + if (!aSelAttr->update()) { + bool isObligatory = !aFactory->isNotObligatory( + theFeature->getKind(), theFeature->data()->id(aSel)) && + aFactory->isCase(theFeature, theFeature->data()->id(aSel)); + if (isObligatory) + aState = ModelAPI_StateInvalidArgument; } + } + } else if (aContext.get()) { + // here it may be not obligatory, but if the reference is wrong, it should not be correct + bool isObligatory = aFactory->isCase(theFeature, theFeature->data()->id(aSel)); + if (isObligatory) + aState = ModelAPI_StateInvalidArgument; + } + } + } + } - // execute in try-catch to avoid internal problems of the feature - if (aState == ModelAPI_StateDone) { - theFeature->data()->execState(ModelAPI_StateDone); - try { - theFeature->execute(); - if (theFeature->data()->execState() != ModelAPI_StateDone) { - aState = ModelAPI_StateExecFailed; + if (aState != ModelAPI_StateDone) + theFeature->data()->execState(aState); +} + +bool Model_Update::isReason(std::shared_ptr& theFeature, + std::shared_ptr theReason) +{ + std::map, std::set > > + ::iterator aReasonsIt = myModified.find(theFeature); + if (aReasonsIt != myModified.end()) { + if (aReasonsIt->second.find(theFeature) != aReasonsIt->second.end()) + return true; // any is reason if it contains itself + FeaturePtr aReasFeat = std::dynamic_pointer_cast(theReason); + if (!aReasFeat.get()) { // try to get feature of this result + ResultPtr aReasRes = std::dynamic_pointer_cast(theReason); + if (aReasRes.get()) + aReasFeat = theReason->document()->feature(aReasRes); + } + if (aReasonsIt->second.find(aReasFeat) != aReasonsIt->second.end()) + return true; + } + // another try: postponed modification by not-persistences + std::map, std::set > > + ::iterator aNotPersist = myNotPersistentRefs.find(theFeature); + if (aNotPersist != myNotPersistentRefs.end()) { + FeaturePtr aReasFeat = std::dynamic_pointer_cast(theReason); + if (!aReasFeat.get()) { // try to get feature of this result + ResultPtr aReasRes = std::dynamic_pointer_cast(theReason); + if (aReasRes.get()) + aReasFeat = theReason->document()->feature(aReasRes); + } + if (aNotPersist->second.find(aReasFeat) != aNotPersist->second.end()) + return true; + } + + // this case only for not-previewed items update state, nothing is changed in args for it + return false; +} + +void Model_Update::executeFeature(FeaturePtr theFeature) +{ +#ifdef DEB_UPDATE + std::cout<<"Execute Feature "<name()<data()->execState(ModelAPI_StateDone); + try { + theFeature->execute(); + if (theFeature->data()->execState() != ModelAPI_StateDone) { + aState = ModelAPI_StateExecFailed; + } else { + aState = ModelAPI_StateDone; + } + } catch(...) { + aState = ModelAPI_StateExecFailed; + Events_InfoMessage("Model_Update", + "Feature %1 has failed during the execution").arg(theFeature->getKind()).send(); + } + // The macro feature has to be deleted in any case even its execution is failed + myWaitForFinish.insert(theFeature); + if (aState != ModelAPI_StateDone) { + theFeature->eraseResults(); + } + theFeature->data()->setUpdateID(ModelAPI_Session::get()->transactionID()); + redisplayWithResults(theFeature, aState); +} + +void Model_Update::updateStability(void* theSender) +{ + static ModelAPI_ValidatorsFactory* aFactory = ModelAPI_Session::get()->validators(); + if (theSender) { + bool added = false; // object may be was crated + ModelAPI_Object* aSender = static_cast(theSender); + if (aSender && aSender->document()) { + FeaturePtr aFeatureSender = + std::dynamic_pointer_cast(aSender->data()->owner()); + if (aFeatureSender.get()) { + Model_Objects* aDocObjects = + std::dynamic_pointer_cast(aSender->document())->objects(); + if (aDocObjects) { + //aDocObjects->synchronizeBackRefs(); + // remove or add all concealment refs from this feature + std::list > > aRefs; + aSender->data()->referencesToObjects(aRefs); + std::list > >::iterator + aRefIt = aRefs.begin(); + for(; aRefIt != aRefs.end(); aRefIt++) { + if (!aFactory->isConcealed(aFeatureSender->getKind(), aRefIt->first)) + // take into account only concealed references + // (do not remove the sketch constraint and the edge on constraint edit) + continue; + std::list& aRefFeaturesList = aRefIt->second; + std::list::iterator aReferenced = aRefFeaturesList.begin(); + for(; aReferenced != aRefFeaturesList.end(); aReferenced++) { + // stability is only on results: feature to feature reference mean nested + // features, that will remove nesting references + if (aReferenced->get() && (*aReferenced)->data()->isValid() && + (*aReferenced)->groupName() != ModelAPI_Feature::group()) { + std::shared_ptr aData = + std::dynamic_pointer_cast((*aReferenced)->data()); + if (aFeatureSender->isStable()) { + aData->addBackReference(aFeatureSender, aRefIt->first); + } else { + aData->removeBackReference(aFeatureSender, aRefIt->first); + added = true; // remove of concealment may be caused creation of some result } - } catch(...) { - aState = ModelAPI_StateExecFailed; - Events_Error::send( - "Feature " + theFeature->getKind() + " has failed during the execution"); } } - if (aState != ModelAPI_StateDone) { - theFeature->eraseResults(); - } - redisplayWithResults(theFeature, aState); - } else { // must be updatet, but not updated yet - theFeature->data()->execState(ModelAPI_StateMustBeUpdated); - const std::list >& aResults = theFeature->results(); - std::list >::const_iterator aRIter = aResults.begin(); - for (; aRIter != aResults.cend(); aRIter++) { - std::shared_ptr aRes = *aRIter; - aRes->data()->execState(ModelAPI_StateMustBeUpdated); - } } - } else { - theFeature->eraseResults(); - redisplayWithResults(theFeature, ModelAPI_StateInvalidArgument); // result also must be updated - } - } else { // for automatically updated features (on abort, etc) it is necessary to redisplay anyway - redisplayWithResults(theFeature, ModelAPI_StateNothing); - } - } else { - // returns also true is results were updated: for sketch that - // refers to sub-features but results of sub-features were changed - const std::list >& aResults = theFeature->results(); - std::list >::const_iterator aRIter = aResults.begin(); - for (; aRIter != aResults.cend(); aRIter++) { - if (myInitial.find(*aRIter) != myInitial.end()) { - aMustbeUpdated = true; - break; } } } + if (added) { + static Events_Loop* aLoop = Events_Loop::loop(); + static Events_ID kEventCreated = aLoop->eventByName(EVENT_OBJECT_CREATED); + aLoop->flush(kEventCreated); + } } - myUpdated[theFeature] = aMustbeUpdated; - return aMustbeUpdated; } -bool Model_Update::updateObject(std::shared_ptr theObject, const bool theCyclic) +void Model_Update::updateSelection(const std::set >& theObjects) { - if (myUpdated.find(theObject) != myUpdated.end()) - return myUpdated[theObject]; // already processed - - /* - if (theCyclic) { // algorithm for update of all features by dependencies tree - if (!theObject) - return false; - FeaturePtr aFeature = std::dynamic_pointer_cast(theObject); - if (aFeature) { // for feature just call update Feature - return updateFeature(aFeature); - } - // check general object, possible just a result - if (myUpdated.find(theObject) != myUpdated.end()) - return myUpdated[theObject]; // already processed - // check the feature of this object must be executed - ResultPtr aResult = std::dynamic_pointer_cast(theObject); - if (aResult) { - FeaturePtr aResFeature = aResult->document()->feature(aResult); - if (aResFeature) { - return updateFeature(aResFeature); + std::set >::iterator anObj = theObjects.begin(); + for(; anObj != theObjects.end(); anObj++) { + std::list aRefs = + (*anObj)->data()->attributes(ModelAPI_AttributeSelection::typeId()); + std::list::iterator aRefsIter = aRefs.begin(); + for (; aRefsIter != aRefs.end(); aRefsIter++) { + std::shared_ptr aSel = + std::dynamic_pointer_cast(*aRefsIter); + aSel->updateInHistory(); + } + // update the selection list attributes if any + aRefs = (*anObj)->data()->attributes(ModelAPI_AttributeSelectionList::typeId()); + for (aRefsIter = aRefs.begin(); aRefsIter != aRefs.end(); aRefsIter++) { + std::shared_ptr aSel = + std::dynamic_pointer_cast(*aRefsIter); + for(int a = aSel->size() - 1; a >= 0; a--) { + std::shared_ptr aSelAttr = + std::dynamic_pointer_cast(aSel->value(a)); + if (aSelAttr.get()) + aSelAttr->updateInHistory(); } } } - */ - return myInitial.find(theObject) != myInitial.end(); }