X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FModel%2FModel_Update.cpp;h=1f6c8319f6e7950e42d4505e79a2bafee60ca786;hb=dfd8991c975a7493c1e7be200503a5c9456ad2da;hp=8886c5f02e32102a56b3eea79d454264e420110d;hpb=1b835da9f6eccd48b02166d222d353d899ecf309;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 8886c5f02..1f6c8319f --- a/src/Model/Model_Update.cpp +++ b/src/Model/Model_Update.cpp @@ -27,7 +27,7 @@ #include #include #include -#include +#include #include using namespace std; @@ -56,6 +56,8 @@ Model_Update::Model_Update() 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); // Config_PropManager::findProp("Model update", "automatic_rebuild")->value() == "true"; myIsParamUpdated = false; @@ -80,24 +82,26 @@ bool Model_Update::addModified(FeaturePtr theFeature, FeaturePtr theReason) { #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); } - if (theFeature->data()->execState() == ModelAPI_StateMustBeUpdated) { - theFeature->data()->execState(ModelAPI_StateDone); - static ModelAPI_ValidatorsFactory* aFactory = ModelAPI_Session::get()->validators(); - aFactory->validate(theFeature); // need to be validated to update the "Apply" state if not previewed - } + // 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(); + aFactory->validate(theFeature); // need to be validated to update the "Apply" state if not previewed + if (!myIsPreviewBlocked) return true; } if (myModified.find(theFeature) != myModified.end()) { if (theReason.get()) { #ifdef DEB_UPDATE - std::cout<<"*** Add already modified "<name()<name()<<" reason "<name()<isDisabled(); if (!aIsDisabled) { std::set > aNewSet; - if (theFeature->data()->execState() == ModelAPI_StateMustBeUpdated) { + if (theFeature->data()->execState() == ModelAPI_StateMustBeUpdated || + theFeature->data()->execState() == ModelAPI_StateInvalidArgument) { // issue 1519 // do not forget that in this case all were the reasons aNewSet.insert(theFeature); } else { @@ -116,7 +121,10 @@ bool Model_Update::addModified(FeaturePtr theFeature, FeaturePtr theReason) { } myModified[theFeature] = aNewSet; #ifdef DEB_UPDATE - std::cout<<"*** Add modified "<name()<name()<<" reason "<name()<name()<data()->execState() == ModelAPI_StateDone) @@ -176,6 +184,7 @@ void Model_Update::processEvent(const std::shared_ptr& theMessag 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); #ifdef DEB_UPDATE std::cout<<"****** Event "<eventID().eventText()<& theMessag if (!(*anObjIter)->data()->isValid()) continue; #ifdef DEB_UPDATE - std::cout<<">>> in event updated "<<(*anObjIter)->data()->name()<>> in event updated "<<(*anObjIter)->groupName()<<" "<<(*anObjIter)->data()->name()<groupName() == ModelAPI_ResultParameter::group()) { myIsParamUpdated = true; @@ -292,6 +301,10 @@ void Model_Update::processEvent(const std::shared_ptr& theMessag // 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); + addModified(aMsg->reordered(), aMsg->reordered()); // to update all attributes } } @@ -309,10 +322,10 @@ void Model_Update::processFeatures(const bool theFlushRedisplay) } myIsProcessed = 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); @@ -328,6 +341,41 @@ void Model_Update::processFeatures(const bool theFlushRedisplay) } } +// collects all the feautres 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); + } + } + } +} + bool Model_Update::processFeature(FeaturePtr theFeature) { static ModelAPI_ValidatorsFactory* aFactory = ModelAPI_Session::get()->validators(); @@ -348,8 +396,8 @@ bool Model_Update::processFeature(FeaturePtr theFeature) } else { int aCount = myProcessed[theFeature]; if (aCount > 100) { // too many repetition of processing (in VS it may crash on 330 with stack overflow) - Events_Error::send( - "Feature '" + theFeature->data()->name() + "' is updated in infinitive loop"); + Events_InfoMessage("Model_Update", + "Feature '%1' is updated in infinitive loop").arg(theFeature->data()->name()).send(); return false; } myProcessed[theFeature] = aCount + 1; @@ -398,50 +446,36 @@ bool Model_Update::processFeature(FeaturePtr theFeature) theFeature->execute(); } + bool isReferencedInvalid = false; // check all features this feature depended on (recursive call of updateFeature) - std::set >& aReasons = myModified[theFeature]; - if (aReasons.find(theFeature) == aReasons.end()) { - std::set >::iterator aReasonIter = aReasons.begin(); - for(; aReasonIter != aReasons.end(); aReasonIter++) { - if (*aReasonIter != theFeature && processFeature(*aReasonIter)) { + 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; - } - } - } else { // check all features this feature depended on because here which one was modified is unknown - 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()) { - if (processFeature(aDepFeat)) - aIsModified = true; - } - } - } - } - 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()) { - if (processFeature(aSub)) - 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; @@ -452,9 +486,12 @@ bool Model_Update::processFeature(FeaturePtr theFeature) isPostponedMain = aCurrentOwner.get() && aCompos->isSub(aCurrentOwner); } - #ifdef DEB_UPDATE - std::cout<<"Update args "<name()<name()<data()->isValid()) + return false; // Update selection and parameters attributes first, before sub-features analysis (sketch plane). updateArguments(theFeature); @@ -466,7 +503,8 @@ bool Model_Update::processFeature(FeaturePtr 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) { + 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()<(*aRefsIter); ObjectPtr aContext = aSel->context(); // update argument only if the referenced object is ready to use - if (aContext.get() && !aContext->isDisabled() && 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; + 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 @@ -647,14 +692,21 @@ void Model_Update::updateArguments(FeaturePtr theFeature) { if (aSelAttr) { ObjectPtr aContext = aSelAttr->context(); // update argument only if the referenced object is ready to use - if (aContext.get() && !aContext->isDisabled() && 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; + 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; } } } @@ -700,8 +752,8 @@ 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 myWaitForFinish.insert(theFeature);