X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FModel%2FModel_Update.cpp;h=097673efc2f67b9a6613383d69d7a2331db6bdd2;hb=803af3deaa4abc9b937e8cfb4a42e7060b6acc22;hp=93f50a171d7ac840e913fa6281c2569ea63888d1;hpb=3e81d29d814a16e6f9bac575e9f11a888849f1e7;p=modules%2Fshaper.git diff --git a/src/Model/Model_Update.cpp b/src/Model/Model_Update.cpp index 93f50a171..097673efc 100644 --- a/src/Model/Model_Update.cpp +++ b/src/Model/Model_Update.cpp @@ -7,6 +7,7 @@ #include #include #include +#include #include #include #include @@ -22,6 +23,8 @@ #include #include #include +#include +#include #include #include #include @@ -30,6 +33,7 @@ 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() { @@ -53,8 +57,11 @@ Model_Update::Model_Update() Config_PropManager::registerProp("Model update", "automatic_rebuild", "Rebuild immediately", Config_Prop::Boolean, "false"); - myIsAutomatic = - Config_PropManager::findProp("Model update", "automatic_rebuild")->value() == "true"; + myIsAutomatic = true; + // Config_PropManager::findProp("Model update", "automatic_rebuild")->value() == "true"; + myIsParamUpdated = false; + myIsFinish = false; + myModification = 0; } void Model_Update::processEvent(const std::shared_ptr& theMessage) @@ -68,12 +75,14 @@ void Model_Update::processEvent(const std::shared_ptr& theMessag 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 isOperationChanged = false; +#ifdef DEB_UPDATE + std::cout<<"****** Event "<eventID().eventText()<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; + // myIsAutomatic = aPropVal; if (myIsAutomatic) // higher level of automatization => to rebuild processOperation(false); } @@ -85,55 +94,142 @@ void Model_Update::processEvent(const std::shared_ptr& theMessag 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 for(; anObjIter != anObjs.cend(); anObjIter++) { - // created objects are always must be up to date (python box feature) - // and updated not in internal uptation chain - if (theMessage->eventID() == kCreatedEvent) { - myJustCreated.insert(*anObjIter); - } else if (myJustCreated.find(*anObjIter) == myJustCreated.end()) { // moved and updated - myJustUpdated.insert(*anObjIter); + if (!std::dynamic_pointer_cast(*anObjIter).get()) { + isOnlyResults = false; } + if ((*anObjIter)->groupName() == ModelAPI_ResultParameter::group()) { + myIsParamUpdated = true; + } + // on undo/redo, abort do not update persisten 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); + } +#ifdef DEB_UPDATE + if (myIsExecuted) std::cout<<"During execution "; + if ((*anObjIter)->data() && (*anObjIter)->data()->isValid()) { + std::cout<<"add updated "<<(*anObjIter)->groupName()<<" " + <<(*anObjIter)->data()->name()<eventID() == kMovedEvent)) + // this event is for solver update, not here, do not react immediately + if (!isOnlyResults && !(theMessage->eventID() == kMovedEvent)) processOperation(false); - } else if (theMessage->eventID() == kOpStartEvent) { - // we don't need the update only on operation start (caused problems in PartSet_Listener::processEvent) - isOperationChanged = true; - } else if (theMessage->eventID() == kOpFinishEvent || theMessage->eventID() == kOpAbortEvent) { - processOperation(true); - isOperationChanged = true; - } - if (isOperationChanged) { + } else if (theMessage->eventID() == kOpFinishEvent || theMessage->eventID() == kOpAbortEvent || + theMessage->eventID() == kOpStartEvent) { + + if (!(theMessage->eventID() == kOpStartEvent)) { + myIsFinish = true; + processOperation(true, theMessage->eventID() == kOpFinishEvent); + myIsFinish = false; + } // remove all macros before clearing all created - std::set::iterator aCreatedIter = myJustCreated.begin(); - for(; aCreatedIter != myJustCreated.end(); aCreatedIter++) { - FeaturePtr aFeature = - std::dynamic_pointer_cast(*aCreatedIter); - if (aFeature.get() && aFeature->isMacro()) { - aFeature->document()->removeFeature(aFeature); + 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++; } } - myJustCreated.clear(); - myJustUpdated.clear(); + // 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(); + myModification = 0; + myWaitForFinish.clear(); } } -void Model_Update::processOperation(const bool theTotalUpdate) +bool Model_Update::iterateUpdate(std::shared_ptr theFeature) { - // the hardcode (DBC asked): hide the sketch referenced by extrusion on apply - std::set >::iterator aFIter; - for(aFIter = myJustCreated.begin(); aFIter != myJustCreated.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); + 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; + } + } + // 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) +{ + if (theFinish) { + // the hardcode (DBC asked): hide the sketch referenced by extrusion on apply + std::set >::iterator aFIter; + for(aFIter = myWaitForFinish.begin(); aFIter != myWaitForFinish.end(); aFIter++) + { + FeaturePtr aF = std::dynamic_pointer_cast(*aFIter); + if (aF && aF->data()->isValid() && 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) { + aSketchRes->setDisplayed(false); + } } } } @@ -141,6 +237,9 @@ void Model_Update::processOperation(const bool theTotalUpdate) } // perform update of everything if needed if (!myIsExecuted) { + #ifdef DEB_UPDATE + std::cout<<"****** Start processing"<moduleDocument()); + // init iteration from the root document + iterateUpdate(CompositeFeaturePtr()); if (isAutomaticChanged) myIsAutomatic = false; myIsExecuted = false; + myModification++; // flush to update display static Events_Loop* aLoop = Events_Loop::loop(); static Events_ID EVENT_DISP = aLoop->eventByName(EVENT_OBJECT_TO_REDISPLAY); aLoop->flush(EVENT_DISP); + #ifdef DEB_UPDATE + std::cout<<"****** End processing"< theDoc) +void Model_Update::updateFeature(FeaturePtr theFeature) { - std::set alreadyProcessed; // features that are processed before others - // all features one by one - for (int aFIndex = 0; aFIndex < theDoc->size(ModelAPI_Feature::group(), true); aFIndex++) { - FeaturePtr aFeature = std::dynamic_pointer_cast( - theDoc->object(ModelAPI_Feature::group(), aFIndex, true)); - if (aFeature && alreadyProcessed.find(aFeature) == alreadyProcessed.end()) { - // update selection and parameters attributes first, before sub-features analysis (sketch plane) - updateArguments(aFeature); - // composite feature must be executed after sub-features execution - CompositeFeaturePtr aComposite = - std::dynamic_pointer_cast(aFeature); - 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); - updateFeature(aSub); - alreadyProcessed.insert(aSub); - } + // check all features this feature depended on (recursive call of updateFeature) + static ModelAPI_ValidatorsFactory* aFactory = ModelAPI_Session::get()->validators(); + + if (theFeature->isDisabled()) + return; + + #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() || myUpdated[theFeature] != myModification) + && !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; + } + + // Update selection and parameters attributes first, before sub-features analysis (sketch plane). + updateArguments(theFeature); + + // 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 + if (theFeature->data()->execState() != ModelAPI_StateMustBeUpdated) + updateArguments(theFeature); + } + // 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; + } + + // only the currently updated features are executed + bool aJustUpdated = myUpdated.find(theFeature) != myUpdated.end() && myUpdated[theFeature] == myModification; + + 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); } + // 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; + } - updateFeature(aFeature); - // update the document results recursively - const std::list >& aResults = aFeature->results(); - std::list >::const_iterator aRIter = aResults.begin(); - for (; aRIter != aResults.cend(); aRIter++) { - ResultPartPtr aPart = std::dynamic_pointer_cast(*aRIter); - if (aPart.get()) { - if (aPart->isActivated()) { - updateInDoc(aPart->partDoc()); - } - } + // execute feature if it must be updated + if (theFeature->isPreviewNeeded() || myIsFinish) { + if (aJustUpdated) { + ModelAPI_ExecState aState = theFeature->data()->execState(); + if (aFactory->validate(theFeature)) { + #ifdef DEB_UPDATE + std::cout<<"Execute Feature "<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; + } } } @@ -208,8 +370,14 @@ void Model_Update::redisplayWithResults(FeaturePtr theFeature, const ModelAPI_Ex std::list >::const_iterator aRIter = aResults.begin(); for (; aRIter != aResults.cend(); aRIter++) { std::shared_ptr aRes = *aRIter; - aRes->data()->execState(theState); - myJustUpdated.insert(aRes); + 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 (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) @@ -223,7 +391,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; } @@ -231,157 +400,335 @@ 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; + 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(); - bool aJustUpdated = false; - ModelAPI_ExecState aState = ModelAPI_StateDone; - // 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 + // 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); - aJustUpdated = true; - } - } else { + if (myIsParamUpdated) { + ModelAPI_AttributeEvalMessage::send(aDouble, this); + } + if (aDouble->expressionInvalid()) { aState = ModelAPI_StateInvalidArgument; } } } - - 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))) + // 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()) { + 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; } } - 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; + } + // 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) { + ModelAPI_AttributeEvalMessage::send(aPoint2DAttribute, this); + } + if ((!aPoint2DAttribute->textX().empty() && aPoint2DAttribute->expressionInvalid(0)) || + (!aPoint2DAttribute->textY().empty() && aPoint2DAttribute->expressionInvalid(1))) + aState = ModelAPI_StateInvalidArgument; + } + } + } + + //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); + ObjectPtr aContext = aSel->context(); + // update argument only if the referenced object is changed + 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 (!aSel->update()) { // this must be done on execution since it may be long operation + if (isObligatory) + aState = ModelAPI_StateInvalidArgument; + } + } else if (aSel->isInvalid()) { // not needed to update, but invalid (stated previously) + 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) { + ObjectPtr aContext = aSelAttr->context(); + // update argument onlt if the referenced object is changed + 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 (!aSelAttr->update()) { + if (isObligatory) + aState = ModelAPI_StateInvalidArgument; + } + } else if (aSelAttr->isInvalid()) { + 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); + } + } + // 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 + for(int a = 0; a < aCompos->numberOfSubs(); 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 (aJustUpdated && myJustCreated.find(theFeature) == myJustCreated.end()) - myJustUpdated.insert(theFeature); + + if (aState != ModelAPI_StateDone) theFeature->data()->execState(aState); } -void Model_Update::updateFeature(FeaturePtr theFeature) +void Model_Update::executeFeature(FeaturePtr theFeature) { - // check all features this feature depended on (recursive call of updateFeature) - static ModelAPI_ValidatorsFactory* aFactory = ModelAPI_Session::get()->validators(); - bool aJustUpdated = false; - - if (theFeature) { - if (theFeature->data()->execState() != ModelAPI_StateDone) - aJustUpdated = true; - - ModelAPI_ExecState aState = ModelAPI_StateDone; - - // 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 (myJustCreated.find(*aRefObj) != myJustCreated.end() || - myJustUpdated.find(*aRefObj) != myJustUpdated.end()) { - aJustUpdated = true; + // execute in try-catch to avoid internal problems of the feature + ModelAPI_ExecState aState = ModelAPI_StateDone; + theFeature->data()->execState(ModelAPI_StateDone); + try { + theFeature->execute(); + if (theFeature->data()->execState() != ModelAPI_StateDone) { + aState = ModelAPI_StateExecFailed; + } else { + aState = ModelAPI_StateDone; + myWaitForFinish.insert(theFeature); + } + } catch(...) { + aState = ModelAPI_StateExecFailed; + Events_Error::send( + "Feature " + theFeature->getKind() + " has failed during the execution"); + } + if (aState != ModelAPI_StateDone) { + theFeature->eraseResults(); + } + theFeature->data()->setUpdateID(ModelAPI_Session::get()->transactionID()); + redisplayWithResults(theFeature, aState); +} + +///////////////// 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; } - aState = stateByReference(*aRefObj, aState); + myIndex++; + if (myIndex == aNumSubs) + break; } + } else if (mySub.get()) { + mySub = myObjects->nextFeature(mySub); } + } +} - // some arguments were changed, so, this feature must be updated - if (myJustCreated.find(theFeature) != myJustCreated.end()) { - aJustUpdated = true; - } else { - if (aJustUpdated) { - if (myJustUpdated.find(theFeature) == myJustUpdated.end()) - myJustUpdated.insert(theFeature); - } else { - aJustUpdated = myJustUpdated.find(theFeature) != myJustUpdated.end(); - } +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) +{ + if (myMain.get()) { + if (myMain->isSub(theFeature)) { + CompositeFeaturePtr anOwner = ModelAPI_Tools::compositeOwner(theFeature); + if (!anOwner.get() || anOwner == myMain) + return true; } - //std::cout<<"Update feature "<getKind()<<" must be updated = "<(theFeature->document())->executeFeatures() || - !theFeature->isPersistentResult()) { - if (aFactory->validate(theFeature)) { - if (myIsAutomatic || - (myJustCreated.find(theFeature) != myJustCreated.end() || - !theFeature->isPersistentResult() /* execute quick, not persistent results */)) - { - // execute in try-catch to avoid internal problems of the feature - if (aState == ModelAPI_StateDone || aState == ModelAPI_StateMustBeUpdated) { - theFeature->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_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); + 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; } } + } else { + mySub = theFeature; } + mySkipNext = true; }