X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FModel%2FModel_Update.cpp;h=d8896e68039a01774be036a7720ca08e9a9b1f8e;hb=f8362ca77ab6a97d18f3c0264be96468d75c8089;hp=5749ee70bc98748941cf413a598a6da047b6bb26;hpb=70f8434967195327040485995ca62b40d029e7ab;p=modules%2Fshaper.git diff --git a/src/Model/Model_Update.cpp b/src/Model/Model_Update.cpp index 5749ee70b..d8896e680 100644 --- a/src/Model/Model_Update.cpp +++ b/src/Model/Model_Update.cpp @@ -1,13 +1,27 @@ -// Copyright (C) 2014-20xx CEA/DEN, EDF R&D - -// File: Model_Update.cxx -// Created: 25 Jun 2014 -// Author: Mikhail PONIKAROV +// Copyright (C) 2014-2019 CEA/DEN, EDF R&D +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// #include #include #include #include +#include #include #include #include @@ -23,15 +37,18 @@ #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 @@ -40,14 +57,10 @@ 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"); @@ -56,100 +69,353 @@ Model_Update::Model_Update() 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); + static const Events_ID kAutoRecomp = aLoop->eventByName(EVENT_AUTOMATIC_RECOMPUTATION_ENABLE); + aLoop->registerListener(this, kAutoRecomp); - /* not needed now with history line - Config_PropManager::registerProp("Model update", "automatic_rebuild", "Rebuild immediately", - Config_Prop::Boolean, "false");*/ - myIsAutomatic = true; // Config_PropManager::findProp("Model update", "automatic_rebuild")->value() == "true"; myIsParamUpdated = false; myIsFinish = false; - myModification = 0; - myModificationInStartProcessing = 0; + myIsProcessed = false; + myIsPreviewBlocked = false; + myUpdateBlocked = 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) { + redisplayWithResults(theFeature, ModelAPI_StateNothing, false); // redisplay even not executed + 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) { + if (theReason.get()) + myProcessOnFinish[theFeature].insert(theReason); + else if (myProcessOnFinish.find(theFeature) == myProcessOnFinish.end()) + myProcessOnFinish[theFeature] = std::set >(); +#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); + } + } + } + // process 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); + } + } + } + } + + // 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 ModelAPI_ValidatorsFactory* aFactory = ModelAPI_Session::get()->validators(); 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"); 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) + // check the automatic update flag on any event + bool aNewAutomaticState = ModelAPI_Session::get()->isAutoUpdateBlocked(); + if (myUpdateBlocked != aNewAutomaticState) { + myUpdateBlocked = aNewAutomaticState; + if (!myUpdateBlocked) { // process all modified features, even if preview is blocked + bool aPreviewBlockedState = myIsPreviewBlocked; // to update the selected arguments + myIsPreviewBlocked = false; + // iterate everything and add features in state "MustBeUpdated" into modified + std::list > allDocs = + ModelAPI_Session::get()->allOpenedDocuments(); + std::list >::iterator aDoc = allDocs.begin(); + for(; aDoc != allDocs.end(); aDoc++) { + std::list > allFeats = (*aDoc)->allFeatures(); + std::list >::iterator aFeat = allFeats.begin(); + for(; aFeat != allFeats.end(); aFeat++) { + if ((*aFeat)->data()->isValid() && + (*aFeat)->data()->execState() == ModelAPI_StateMustBeUpdated) { + addModified(*aFeat, FeaturePtr()); + } + } + } + processFeatures(); + myIsPreviewBlocked = myIsPreviewBlocked; + } + } + + if (theMessage->eventID() == kStabilityEvent) { updateStability(theMessage->sender()); - 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) { // something is changed - // myIsAutomatic = aPropVal; - if (myIsAutomatic) // higher level of automatization => to rebuild - processOperation(false); - }*/ return; - } else if (theMessage->eventID() == kRebuildEvent) { // the rebuild command - processOperation(true); - } else if (theMessage->eventID() == kCreatedEvent || theMessage->eventID() == kUpdatedEvent || - theMessage->eventID() == kMovedEvent) { + } + if (theMessage->eventID() == kPreviewBlockedEvent) { + myIsPreviewBlocked = true; + return; + } + if (theMessage->eventID() == kPreviewRequestedEvent) { + if (myIsPreviewBlocked) { + bool anUpdateState = myUpdateBlocked; + myUpdateBlocked = false; + myIsPreviewBlocked = false; + processFeatures(); + myIsPreviewBlocked = true; + myUpdateBlocked = anUpdateState; + } + 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(); - bool isOnlyResults = true; // check that only results were changed: only redisplay is needed + std::list aFeatures, aResults; for(; anObjIter != anObjs.cend(); anObjIter++) { - if (!std::dynamic_pointer_cast(*anObjIter).get()) { - isOnlyResults = false; + if (std::dynamic_pointer_cast((*anObjIter)->document())->executeFeatures()) { + if ((*anObjIter)->groupName() == ModelAPI_Feature::group()) { + // results creation means enabling, not update + aFeatures.push_back(*anObjIter); + } else { + aResults.push_back(*anObjIter); + } } + } + ModelAPI_EventCreator::get()->sendUpdated(aFeatures, kUpdatedEvent); + ModelAPI_EventCreator::get()->sendUpdated(aResults, 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; } - if (myIsExecuted) // modifications from outside are with never IDs to take them into account in the current updates - myModification++; - // on undo/redo, abort do not update persisten features + // on undo/redo, abort do not update persistent features FeaturePtr anUpdated = std::dynamic_pointer_cast(*anObjIter); - if (std::dynamic_pointer_cast((*anObjIter)->document())->executeFeatures() || - (anUpdated.get() && !anUpdated->isPersistentResult())) { - // created objects are always must be up to date (python box feature) - // and updated not in internal uptation chain - myUpdated[*anObjIter] = myModification; - - // something is updated during the execution: re-execute it (sketch update by parameters or - // Box macro that updates the upper features during the execution) - if (myIsExecuted) { - FeaturePtr anUpdated = std::dynamic_pointer_cast(*anObjIter); - if (anUpdated.get() && anUpdated->data()->isValid()) - iterateUpdateBreak(anUpdated); + if (anUpdated.get()) { + if (addModified(anUpdated, FeaturePtr())) + aSomeModified = true; + if (myUpdateBlocked) { // execute this feature anyway to show the current result + /*if (!anUpdated->isStable() && anUpdated->results().size() && ( + anUpdated->firstResult()->groupName() == ModelAPI_ResultBody::group() || + anUpdated->firstResult()->groupName() == ModelAPI_ResultPart::group())) { + if (aFactory->validate(anUpdated)) { + executeFeature(anUpdated); + redisplayWithResults(anUpdated, ModelAPI_StateNothing, false); + static Events_ID EVENT_DISP = aLoop->eventByName(EVENT_OBJECT_TO_REDISPLAY); + aLoop->flush(EVENT_DISP); + } + }*/ } -#ifdef DEB_UPDATE - if (myIsExecuted) std::cout<<"During execution "; - if ((*anObjIter)->data() && (*anObjIter)->data()->isValid()) { - std::cout<<"add updated "<<(*anObjIter)->groupName()<<" " - <<(*anObjIter)->data()->name()< >& + aRefs = (*anObjIter)->data()->refsToMe(); + std::set >::const_iterator aRefIter = aRefs.cbegin(); + FeaturePtr aReason; + ResultPtr aReasonResult = std::dynamic_pointer_cast(*anObjIter); + if (aReasonResult.get()) + aReason = (*anObjIter)->document()->feature(aReasonResult); + 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, aReason)) + aSomeModified = true; + } } -#endif } - } // this event is for solver update, not here, do not react immediately - if (!isOnlyResults && !(theMessage->eventID() == kMovedEvent)) - processOperation(false); + if (aSomeModified) { + processFeatures(); + } } else if (theMessage->eventID() == kOpFinishEvent || theMessage->eventID() == kOpAbortEvent || theMessage->eventID() == kOpStartEvent) { + myIsPreviewBlocked = false; - if (!(theMessage->eventID() == kOpStartEvent)) { + if (theMessage->eventID() == kOpFinishEvent) {// if update is blocked, skip myIsFinish = true; - processOperation(true, theMessage->eventID() == kOpFinishEvent); + // add features that wait for finish as modified + std::map, std::set > >:: + iterator aFeature = myProcessOnFinish.begin(); + for(; aFeature != myProcessOnFinish.end(); aFeature++) { + if (aFeature->first->data()->isValid()) {// there may be already removed while wait + if (aFeature->second.empty()) { + addModified(aFeature->first, FeaturePtr()); + continue; + } + std::set >::iterator aReasons; + for(aReasons = aFeature->second.begin(); aReasons != aFeature->second.end(); aReasons++){ + addModified(aFeature->first, *aReasons); + } + } + } myIsFinish = false; } + // processed features must be only on finish, so clear anyway (to avoid re-import on load) + myProcessOnFinish.clear(); + + // #2156: current must be sketch, left after the macro execution + DocumentPtr anActiveDoc = ModelAPI_Session::get()->activeDocument(); + FeaturePtr aCurrent; + if (anActiveDoc.get()) + aCurrent = anActiveDoc->currentFeature(false); + + if (!(theMessage->eventID() == kOpStartEvent)) { + processFeatures(false); + } + + if (anActiveDoc.get() && aCurrent.get() && aCurrent->data()->isValid()) { + if (anActiveDoc->currentFeature(false) != aCurrent && + ModelAPI_Tools::compositeOwner(anActiveDoc->currentFeature(false)) == aCurrent) + anActiveDoc->setCurrentFeature(aCurrent, false); // #2156 make the current feature back + } + // remove all macros before clearing all created - std::set::iterator anUpdatedIter = myWaitForFinish.begin(); + std::set::iterator anUpdatedIter = myWaitForFinish.begin(); while(anUpdatedIter != myWaitForFinish.end()) { FeaturePtr aFeature = std::dynamic_pointer_cast(*anUpdatedIter); if (aFeature.get()) { @@ -168,236 +434,324 @@ void Model_Update::processEvent(const std::shared_ptr& theMessag anUpdatedIter++; } } - // in the end of transaction everything is updated, so clear the old objects (the only one - // place where results are cleared) - myIsParamUpdated = false; - myUpdated.clear(); - // do not erase it since there may be modification increment on start of operation - //myModification = 0; - myWaitForFinish.clear(); - } -} + // 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); -bool Model_Update::iterateUpdate(std::shared_ptr theFeature) -{ - myProcessIterator.push_back(IterationItem(theFeature)); - IterationItem& aCurrent = *myProcessIterator.rbegin(); - // two cycles: parameters must be processed first - for(aCurrent.startIteration(true); aCurrent.more(); aCurrent.next()) { - if (aCurrent.current()->getKind() == "Parameter") - updateFeature(aCurrent.current()); - } - // number of subs can be changed in execution: like fillet - for(aCurrent.startIteration(false); aCurrent.more(); aCurrent.next()) { - FeaturePtr aSub = aCurrent.current(); - if (aSub->getKind() != "Parameter") - updateFeature(aSub); - } - // processing is finished, so, remove the iterated - bool aResult = !aCurrent.isBreaked(); // iteration is finished correctly, not breaked - myProcessIterator.pop_back(); - return aResult; -} - -void Model_Update::iterateUpdateBreak(std::shared_ptr theFeature) -{ - // checking that this feature is before the current iterated one: otherwise break is not needed - std::list::reverse_iterator aProcessed = myProcessIterator.rbegin(); - for(; aProcessed != myProcessIterator.rend(); aProcessed++) { - if (aProcessed->isIterated(theFeature)) { - if (aProcessed->isEarlierThanCurrent(theFeature)) { - // break all lower level iterators - std::list::reverse_iterator aBreaked = myProcessIterator.rbegin(); - for(; aBreaked != aProcessed; aBreaked++) { - aBreaked->setBreaked(); - } - // for the current breaked, set iteration to this feature precisely - aBreaked->setCurrentBefore(theFeature); - //myModification++; - } - // the iterator that contains breaked is found, so, nothing else is needed - return; - } + // in the end of transaction everything is updated, so clear the old objects + //myIsParamUpdated = false; // to avoid problems in sprocket.py parameter update + 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 this feature is not found in the list of the currently iterated, try to break the parent - FeaturePtr aParent = ModelAPI_Tools::compositeOwner(theFeature); - if (aParent.get()) - iterateUpdateBreak(aParent); } -void Model_Update::processOperation(const bool theTotalUpdate, const bool theFinish) +void Model_Update::processFeatures(const bool theFlushRedisplay) { - // perform update of everything if needed - if (!myIsExecuted) { + // 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"<first); } - // modifications inside of the iteration will be different from modification that comes outside - myModification++; - // init iteration from the root document - iterateUpdate(CompositeFeaturePtr()); + myIsProcessed = false; - if (isAutomaticChanged) myIsAutomatic = false; - myIsExecuted = false; - // flush updates just before "myModification" increment: to distinguish - // updates by "execute" produced by this updater and other updates, coming outside, - // which are really important for "processEvent" of this updater + // 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); - myModification++; // flush to update display - static Events_ID EVENT_DISP = aLoop->eventByName(EVENT_OBJECT_TO_REDISPLAY); - aLoop->flush(EVENT_DISP); + if (theFlushRedisplay) { + static Events_ID EVENT_DISP = aLoop->eventByName(EVENT_OBJECT_TO_REDISPLAY); + aLoop->flush(EVENT_DISP); + } #ifdef DEB_UPDATE std::cout<<"****** End processing"<= myModificationInStartProcessing && - theModificationID <= myModification; +// collects all the features this feature depends on: reasons +static void allReasons(FeaturePtr theFeature, std::set& 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::updateFeature(FeaturePtr theFeature) +bool Model_Update::processFeature(FeaturePtr theFeature) { - // check all features this feature depended on (recursive call of updateFeature) static ModelAPI_ValidatorsFactory* aFactory = ModelAPI_Session::get()->validators(); - if (theFeature->isDisabled()) { - // possibly sub-elements are not disabled? - CompositeFeaturePtr aCompos = std::dynamic_pointer_cast(theFeature); - if (aCompos) - iterateUpdate(aCompos); - return; + if (!theFeature->data()->isValid()) { // deleted feature, just remove from all containers + if (myModified.find(theFeature) != myModified.end()) + myModified.erase(theFeature); + return false; } - // do not execute the composite that contains the current - bool isPostponedMain = false; - CompositeFeaturePtr aMain = std::dynamic_pointer_cast(theFeature); - if (theFeature->getKind() == "ExtrusionSketch" && aMain.get()) { - CompositeFeaturePtr aCurrentOwner = - ModelAPI_Tools::compositeOwner(theFeature->document()->currentFeature(false)); - isPostponedMain = aCurrentOwner.get() && aMain->isSub(aCurrentOwner); + if (theFeature->isPersistentResult()) { + if (!std::dynamic_pointer_cast((theFeature)->document())->executeFeatures()) + return false; } - #ifdef DEB_UPDATE - std::cout<<"Update Feature "<name()<(theFeature); - // If automatice update is not needed and feature attributes were not updated right now, - // do not execute it and do not update arguments. - if (!myIsAutomatic && - (myUpdated.find(theFeature) == myUpdated.end() || !isProcessed(myUpdated[theFeature])) - && !aCompos.get()) { - // execute will be performed later, but some features may have not-result - // presentations, so call update for them (like coincidence in the sketcher) - static Events_ID EVENT_DISP = Events_Loop::loop()->eventByName(EVENT_OBJECT_TO_REDISPLAY); - ModelAPI_EventCreator::get()->sendUpdated(theFeature, EVENT_DISP); - return; + 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; } - // Update selection and parameters attributes first, before sub-features analysis (sketch plane). - updateArguments(theFeature); + // 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; + } + } - // composite feature must be executed after sub-features execution - if (aCompos) { - if (!iterateUpdate(aCompos)) - return; // iteration was interrupted, so, interrupt the update of this feature (it will be done later) - // reupdate arguments of composite feature: it may be changed during subs execution +#ifdef DEB_UPDATE + std::cout<<"* Process feature "<name()<data()->execState() != ModelAPI_StateMustBeUpdated) - updateArguments(theFeature); + // update the sketch plane before the sketch sub-elements are recomputed + // (otherwise sketch will update plane, modify subs, after executed, but with old subs edges) + if (aIsModified && theFeature->getKind() == "Sketch") { +#ifdef DEB_UPDATE + std::cout << "****** Update sketch args " << theFeature->name() << std::endl; +#endif + AttributeSelectionPtr anExtSel = theFeature->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); + } + std::shared_ptr anOrigin = + std::dynamic_pointer_cast(theFeature->attribute("Origin")); + double anOX = anOrigin->x(), anOY = anOrigin->y(), anOZ = anOrigin->z(); + std::shared_ptr aDir = + std::dynamic_pointer_cast(theFeature->attribute("DirX")); + double aDX = aDir->x(), aDY = aDir->y(), aDZ = aDir->z(); + std::shared_ptr aNorm = + std::dynamic_pointer_cast(theFeature->attribute("Norm")); + double aNX = aNorm->x(), aNY = aNorm->y(), aNZ = aNorm->z(); + // update sketch plane + updateArguments(theFeature); + theFeature->attributeChanged("External"); // to recompute origin, direction and normal + // check it is updated, so all must be changed + if (anOrigin->x() != anOX || anOrigin->y() != anOY || anOrigin->z() != anOZ || + aDir->x() != aDX || aDir->y() != aDY || aDir->z() != aDZ || + aNorm->x() != aNX || aNorm->y() != aNY || aNorm->z() != aNZ) + { + std::set aWholeR; + allReasons(theFeature, aWholeR); + std::set::iterator aRIter = aWholeR.begin(); + for (; aRIter != aWholeR.end(); aRIter++) { + if ((*aRIter)->data()->selection("External").get()) + (*aRIter)->attributeChanged("External"); + } + } + } + } + } + + if (!aIsModified) { // no modification is needed + return false; } - // 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) { - theFeature->eraseResults(); - redisplayWithResults(theFeature, ModelAPI_StateInvalidArgument); // result also must be updated - return; + + // evaluate parameter before the sub-elements update: + // it updates dependencies on evaluation (#1085) + if (theFeature->getKind() == "Parameter") { + theFeature->execute(); } - // only the currently updated features are executed - bool aJustUpdated = myUpdated.find(theFeature) != myUpdated.end(); - if (aJustUpdated) { - // if preview is not needed, the created feature was not updated before, so, myModification is not actual for this - if (theFeature->isPreviewNeeded()) { - aJustUpdated = isProcessed(myUpdated[theFeature]); + 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; + // check validity of aReason once again because it may be removed by dependent feature + // (e.g. by SketchPlugin_IntersectionPoint) + if (!aReason->data()->isValid() || + aReason->data()->execState() == ModelAPI_StateInvalidArgument) + isReferencedInvalid = true; } + // searching for the next not used reason + aProcessedReasons.insert(aReason); + // check theFeature is still in the list of modified, because it may be removed sometimes + // while updating SketchPlugin_Ellipse + if (myModified.find(theFeature) != myModified.end()) + aReasons.erase(aReason); + else + break; } + // 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; - if (myIsAutomatic && theFeature->data()->execState() == ModelAPI_StateMustBeUpdated) - aJustUpdated = true; - - // On abort, undo or redo execute is not needed: results in document are updated automatically - // But redisplay is needed: results are updated, must be also updated in the viewer. - if (aJustUpdated && - !std::dynamic_pointer_cast(theFeature->document())->executeFeatures()) { - if (!theFeature->isPersistentResult()) { // not persistent must be re-executed on abort, etc. - ModelAPI_ExecState aState = theFeature->data()->execState(); - if (aFactory->validate(theFeature)) { - executeFeature(theFeature); - } else { - theFeature->eraseResults(); - redisplayWithResults(theFeature, ModelAPI_StateInvalidArgument); // result also must be updated - } - } else { - redisplayWithResults(theFeature, ModelAPI_StateNothing); - if (theFeature->data()->execState() == ModelAPI_StateMustBeUpdated) { // it is done (in the tree) - theFeature->data()->execState(ModelAPI_StateDone); + // 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); + } else if (theFeature->getKind() == "Sketch" && + std::dynamic_pointer_cast((theFeature)->document())->executeFeatures()) { + // 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* aLoop = Events_Loop::loop(); + // in case it is finish operation, flush for the sketch other events (#2450) + aLoop->flush(aLoop->eventByName(EVENT_OBJECT_UPDATED)); + aLoop->send(aMsg); + // check that sub-elements of sketch are updated => sketch must be re-processed + std::set aWholeR; + allReasons(theFeature, aWholeR); + std::set::iterator aRIter = aWholeR.begin(); + for(; aRIter != aWholeR.end(); aRIter++) { + if (myModified.find(*aRIter) != myModified.end()) { + processFeature(theFeature); + return true; } - // it will be not updated with new modifications: only the currently updated features are updated - //if (myUpdated.find(theFeature) != myUpdated.end()) { - // myUpdated.erase(theFeature); // do not update this persistent feature even in the future - //} } - return; + } + +#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 sub-elements + 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(false); + 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 - if (theFeature->isPreviewNeeded() || myIsFinish) { - if (aJustUpdated) { - ModelAPI_ExecState aState = theFeature->data()->execState(); - if (aFactory->validate(theFeature)) { - if (!isPostponedMain) { - #ifdef DEB_UPDATE - std::cout<<"Execute Feature "<name()<data()->execState(); + if (aFactory->validate(theFeature)) { + if (!isPostponedMain) { + bool aDoExecute = true; + if (myUpdateBlocked) { + if (!theFeature->isStable()) { + aDoExecute = true; + } else if (theFeature->results().size()) { // execute only not persistent results features + aDoExecute = !theFeature->isPersistentResult(); + } else { + aDoExecute = aState != ModelAPI_StateInvalidArgument; } - } else { - #ifdef DEB_UPDATE - std::cout<<"Feature is not valid, erase results "<name()<eraseResults(); - redisplayWithResults(theFeature, ModelAPI_StateInvalidArgument); // result also must be updated } - } - } else { // preview is not needed => make state Done - if (theFeature->data()->execState() == ModelAPI_StateMustBeUpdated) { - theFeature->data()->execState(ModelAPI_StateDone); - if (aJustUpdated) {// store that it must be updated on finish - myUpdated[theFeature] = myModification; - aFactory->validate(theFeature); // need to be validated to update the "Apply" state if not previewed + if (aDoExecute) { + executeFeature(theFeature); + } else { + // store information that this feature must be executed later + theFeature->data()->execState(ModelAPI_StateMustBeUpdated); } } + } else { + #ifdef DEB_UPDATE + std::cout<<"Feature is not valid, erase results "<name()<eraseResults(false); + 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, bool theUpdateState) { // make updated and redisplay all results static Events_ID EVENT_DISP = Events_Loop::loop()->eventByName(EVENT_OBJECT_TO_REDISPLAY); @@ -407,10 +761,11 @@ void Model_Update::redisplayWithResults(FeaturePtr theFeature, const ModelAPI_Ex std::list::iterator aRIter = allResults.begin(); for (; aRIter != allResults.cend(); aRIter++) { std::shared_ptr aRes = *aRIter; - 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 (theState == ModelAPI_StateDone) // feature become "done", so execution changed results - myUpdated[aRes] = myModification; + if (!aRes->isDisabled()) { + // update state only for enabled results + // (Placement Result Part may make the original Part Result as invalid) + if (theUpdateState) + aRes->data()->execState(theState); } if (theFeature->data()->updateID() > aRes->data()->updateID()) { aRes->data()->setUpdateID(theFeature->data()->updateID()); @@ -419,8 +774,8 @@ void Model_Update::redisplayWithResults(FeaturePtr theFeature, const ModelAPI_Ex } // to redisplay "presentable" feature (for ex. distance constraint) ModelAPI_EventCreator::get()->sendUpdated(theFeature, EVENT_DISP); - theFeature->data()->execState(theState); - myUpdated[theFeature] = myModification; // feature is also updated to avoid re-updation of it + if (theUpdateState) + theFeature->data()->execState(theState); } /// Updates the state by the referenced object: if something bad with it, set state for this one @@ -438,47 +793,9 @@ ModelAPI_ExecState stateByReference(ObjectPtr theTarget, const ModelAPI_ExecStat return theCurrent; } -bool Model_Update::isOlder(std::shared_ptr theFeature, - std::shared_ptr theArgument) -{ - int aFeatureID = theFeature->data()->updateID(); - int anArgID = theArgument->data()->updateID(); - if (aFeatureID < anArgID) - return true; - std::map, int >::iterator anAIter = myUpdated.find(theArgument); - if (anAIter == myUpdated.end()) - return false; - // for the modification IDs compare results: modification ID of feature means only that attributes - // of this feature were updated, but if results are obsolete relatively to the referenced results, - // the feature must be updated - std::list aResults; - ModelAPI_Tools::allResults(theFeature, aResults); - std::list::iterator aRIter = aResults.begin(); - for (; aRIter != aResults.cend(); aRIter++) { - std::shared_ptr aRes = *aRIter; - if (!aRes->isDisabled()) { - std::map, int >::iterator anRIter = myUpdated.find(aRes); - int aResultID = aRes->data()->updateID(); - if (aResultID < anArgID) - return true; - if (anRIter == myUpdated.end()) // not updated at all - return true; - if (anRIter->second < anAIter->second) - return true; - } - } - // also check a feature: some have no parameters, - // but must be updated anyway (like Coincidence of sketch) to be redisplayed - std::map, int >::iterator aFIter = myUpdated.find(theFeature); - if (aFIter == myUpdated.end()) - return true; // argument is updated, but feature is not updated at all - return aFIter->second < anAIter->second; -} - 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 - static ModelAPI_ValidatorsFactory* aFactory = ModelAPI_Session::get()->validators(); ModelAPI_ExecState aState = theFeature->data()->execState(); @@ -532,7 +849,8 @@ void Model_Update::updateArguments(FeaturePtr theFeature) { for(; anIter != anAttributes.end(); anIter++) { AttributePointPtr aPointAttribute = std::dynamic_pointer_cast(*anIter); - if (aPointAttribute.get()) { + if (aPointAttribute.get() && (!aPointAttribute->textX().empty() || + !aPointAttribute->textY().empty() || !aPointAttribute->textZ().empty())) { if (myIsParamUpdated) { ModelAPI_AttributeEvalMessage::send(aPointAttribute, this); } @@ -552,7 +870,8 @@ void Model_Update::updateArguments(FeaturePtr theFeature) { AttributePoint2DPtr aPoint2DAttribute = std::dynamic_pointer_cast(*anIter); if (aPoint2DAttribute.get()) { - if (myIsParamUpdated) { + if (myIsParamUpdated && (!aPoint2DAttribute->textX().empty() || + !aPoint2DAttribute->textY().empty())) { ModelAPI_AttributeEvalMessage::send(aPoint2DAttribute, this); } if ((!aPoint2DAttribute->textX().empty() && aPoint2DAttribute->expressionInvalid(0)) || @@ -561,35 +880,33 @@ void Model_Update::updateArguments(FeaturePtr theFeature) { } } } - - //if (aState == ModelAPI_StateDone) {// all referenced objects are ready to be used - //std::cout<<"Execute feature "<getKind()< aRefs = + // update the selection attributes if any + std::list aRefs = theFeature->data()->attributes(ModelAPI_AttributeSelection::typeId()); - list::iterator aRefsIter = aRefs.begin(); + 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 changed + // update argument only if the referenced object is ready to use if (aContext.get() && !aContext->isDisabled()) { - bool isObligatory = !aFactory->isNotObligatory( - theFeature->getKind(), theFeature->data()->id(aSel)) && - aFactory->isCase(theFeature, theFeature->data()->id(aSel)); - if (isOlder(theFeature, aContext)) { - if (aState == ModelAPI_StateDone) - aState = ModelAPI_StateMustBeUpdated; + 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 (aSel->isInvalid()) { // not needed to update, but invalid (stated previously) - 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 = @@ -599,82 +916,71 @@ void Model_Update::updateArguments(FeaturePtr theFeature) { std::dynamic_pointer_cast(aSel->value(a)); if (aSelAttr) { ObjectPtr aContext = aSelAttr->context(); - // update argument onlt if the referenced object is changed + // update argument only if the referenced object is ready to use if (aContext.get() && !aContext->isDisabled()) { - bool isObligatory = !aFactory->isNotObligatory( - theFeature->getKind(), theFeature->data()->id(aSel)) && - aFactory->isCase(theFeature, theFeature->data()->id(aSel)); - if (isOlder(theFeature, aContext)) { - if (aState == ModelAPI_StateDone) - aState = ModelAPI_StateMustBeUpdated; + 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 (aSelAttr->isInvalid()) { - 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; } } } } - // 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 > > aRefsObj; - std::shared_ptr aData = std::dynamic_pointer_cast(theFeature->data()); - aData->referencesToObjects(aRefsObj); - std::list > >::iterator aRef = aRefsObj.begin(); - for(; aRef != aRefsObj.end(); aRef++) { - std::list::iterator aRefObj = aRef->second.begin(); - for(; aRefObj != aRef->second.end(); aRefObj++) { - // if reference is null, it may mean that this reference is to other document - // the does not supported by RefList: parameters may be recomputed - if (!aRefObj->get() && theFeature->firstResult().get() && - theFeature->firstResult()->groupName() == ModelAPI_ResultParameter::group()) { - if (aState == ModelAPI_StateDone) - aState = ModelAPI_StateMustBeUpdated; - } else if (aRefObj->get() && isOlder(theFeature, *aRefObj)) { - if (aState == ModelAPI_StateDone) - aState = ModelAPI_StateMustBeUpdated; - } - aState = stateByReference(*aRefObj, aState); + + 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; } - // composites sub-elements - CompositeFeaturePtr aCompos = std::dynamic_pointer_cast(theFeature); - // composite feature must be executed after sub-features execution - if (aCompos) { - // number of subs can be changed in execution: like fillet - int aNumSubs = aCompos->numberOfSubs(); - for(int a = 0; a < aNumSubs; a++) { - FeaturePtr aSub = aCompos->subFeature(a); - if (aSub.get() && aState == ModelAPI_StateDone) { - if (isOlder(theFeature, aSub)) { - aState = ModelAPI_StateMustBeUpdated; - } - // also check that all results of subs were updated: composite also depends on the results - const std::list >& aResults = aSub->results(); - std::list >::const_iterator aResIter = aResults.begin(); - for(; aResIter != aResults.end(); aResIter++) { - if (aResIter->get() && (*aResIter)->data()->isValid() && !(*aResIter)->isDisabled() && - isOlder(theFeature, *aResIter)) { - aState = ModelAPI_StateMustBeUpdated; - } - } - } - if (a == aNumSubs - 1) // in case number of subs is changed, just recheck before end - aNumSubs = aCompos->numberOfSubs(); + // 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; } - - if (aState != ModelAPI_StateDone) - theFeature->data()->execState(aState); + // 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); @@ -687,44 +993,52 @@ void Model_Update::executeFeature(FeaturePtr theFeature) } } catch(...) { aState = ModelAPI_StateExecFailed; - Events_Error::send( - "Feature " + theFeature->getKind() + " has failed during the execution"); + 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 + // 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->eraseResults(false); } theFeature->data()->setUpdateID(ModelAPI_Session::get()->transactionID()); redisplayWithResults(theFeature, aState); } +// it is called on GUI edit of feature start +// LCOV_EXCL_START 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 = + FeaturePtr aFeatureSender = std::dynamic_pointer_cast(aSender->data()->owner()); if (aFeatureSender.get()) { - Model_Objects* aDocObjects = + 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(); + 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 + // stability is only on results: feature to feature reference mean nested // features, that will remove nesting references - if (aReferenced->get() && (*aReferenced)->data()->isValid() && + if (aReferenced->get() && (*aReferenced)->data()->isValid() && (*aReferenced)->groupName() != ModelAPI_Feature::group()) { - std::shared_ptr aData = + std::shared_ptr aData = std::dynamic_pointer_cast((*aReferenced)->data()); if (aFeatureSender->isStable()) { aData->addBackReference(aFeatureSender, aRefIt->first); @@ -745,129 +1059,39 @@ void Model_Update::updateStability(void* theSender) } } } +// LCOV_EXCL_STOP -///////////////// Updated items iterator //////////////////////// -Model_Update::IterationItem::IterationItem(std::shared_ptr theFeature) -{ - myBreaked = false; - myIsVirtual = false; - myMain = theFeature; - myObjects = NULL; - if (!myMain.get() && ModelAPI_Session::get()->hasModuleDocument()) { // no document => nothing to do - DocumentPtr aRootDoc = ModelAPI_Session::get()->moduleDocument(); - myObjects = std::dynamic_pointer_cast(aRootDoc)->objects(); - } - mySkipNext = false; -} - -void Model_Update::IterationItem::next() -{ - if (mySkipNext) { // ignore one next - mySkipNext = false; - return; - } - if (!myBreaked) { - if (myMain.get()) { - myIndex++; - int aNumSubs = myMain->numberOfSubs(); - if (myIndex == aNumSubs) - return; - // skip sub-objects, that are subs not only for this: sketch elements relatively to Part - for(FeaturePtr aSub = myMain->subFeature(myIndex); aSub.get(); - aSub = myMain->subFeature(myIndex)) { - aSub = myMain->subFeature(myIndex); - CompositeFeaturePtr anOwner = ModelAPI_Tools::compositeOwner(aSub); - if (!anOwner.get() || anOwner == myMain) { - break; - } - myIndex++; - if (myIndex == aNumSubs) - break; - } - } else if (mySub.get()) { - while(mySub.get()) { - mySub = myObjects->nextFeature(mySub); - CompositeFeaturePtr anOwner = ModelAPI_Tools::compositeOwner(mySub); - // skip sub-objects, that are subs not only for this: sketch elements relatively to PartSet - if (!anOwner.get()) { - break; - } - } - } - } -} - -bool Model_Update::IterationItem::more() -{ - if (myBreaked) - return false; - if (myMain.get()) - return myIndex < myMain->numberOfSubs(); - return mySub.get() != NULL; -} - -FeaturePtr Model_Update::IterationItem::current() -{ - if (myMain.get()) - return myMain->subFeature(myIndex); - return mySub; -} - -void Model_Update::IterationItem::setBreaked() -{ - if (!myIsVirtual) - myBreaked = true; -} - -void Model_Update::IterationItem::startIteration(const bool theVirtual) -{ - myIsVirtual = theVirtual; - if (myMain.get()) { - myIndex = 0; - } else if (myObjects) { - mySub = myObjects->firstFeature(); - } -} - -bool Model_Update::IterationItem::isIterated(FeaturePtr theFeature) +void Model_Update::updateSelection(const std::set >& theObjects) { - if (myMain.get()) { - if (myMain->isSub(theFeature)) { - CompositeFeaturePtr anOwner = ModelAPI_Tools::compositeOwner(theFeature); - if (!anOwner.get() || anOwner == myMain) - return true; + 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); + bool aRemove = false; + aSel->updateInHistory(aRemove); } - return false; - } - // for the root document just check that this feature in this document and it is not sub - return myObjects->owner() == theFeature->document() && - !ModelAPI_Tools::compositeOwner(theFeature).get(); -} - -bool Model_Update::IterationItem::isEarlierThanCurrent(FeaturePtr theFeature) -{ - if (myMain.get()) { - for(int a = 0; a < myIndex; a++) { - if (myMain->subFeature(a) == theFeature) - return true; - } - } else { - return !mySub.get() && !myObjects->isLater(theFeature, mySub); - } - return false; -} - -void Model_Update::IterationItem::setCurrentBefore(FeaturePtr theFeature) -{ - if (myMain.get()) { - for(int a = 0; a < myIndex; a++) { - if (myMain->subFeature(a) == theFeature) { - myIndex = a; - break; + // update the selection list attributes if any + aRefs = (*anObj)->data()->attributes(ModelAPI_AttributeSelectionList::typeId()); + for (aRefsIter = aRefs.begin(); aRefsIter != aRefs.end(); aRefsIter++) { + std::set aRemoveSet; + 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()) { + bool theRemove = false; + aSelAttr->updateInHistory(theRemove); + if (theRemove) { + aRemoveSet.insert(a); + } + } } + aSel->remove(aRemoveSet); } - } else { - mySub = theFeature; } - mySkipNext = true; }