X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FModel%2FModel_Update.cpp;h=1f6c8319f6e7950e42d4505e79a2bafee60ca786;hb=392e617e3add41f698281c14ce5701cfd9f41e9c;hp=16a7b9e3c740ee11a865b29cb91bfa429cf9497c;hpb=1490e92974d2c0bdcdbecd6fa9388e31dccfa363;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 16a7b9e3c..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,19 +82,26 @@ bool Model_Update::addModified(FeaturePtr theFeature, FeaturePtr theReason) { #ifdef DEB_UPDATE std::cout<<"*** Add process on finish "<name()<data()->execState() == ModelAPI_StateMustBeUpdated || myIsPreviewBlocked) { - 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 - } + // keeps the currently updated features to avoid infinitive cycling here: where feature on + // "updateArguments" sends "updated" (in selection attribute) and goes here again + static std::set 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(); + 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 { @@ -111,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) @@ -126,9 +139,11 @@ bool Model_Update::addModified(FeaturePtr theFeature, FeaturePtr theReason) { const std::set >& aRefs = theFeature->data()->refsToMe(); std::set >::const_iterator aRefIter = aRefs.cbegin(); for(; aRefIter != aRefs.cend(); aRefIter++) { - FeaturePtr aReferenced = std::dynamic_pointer_cast((*aRefIter)->owner()); - if (aReferenced.get()) { - addModified(aReferenced, theFeature); + if ((*aRefIter)->isArgument()) { + FeaturePtr aReferenced = std::dynamic_pointer_cast((*aRefIter)->owner()); + if (aReferenced.get()) { + addModified(aReferenced, theFeature); + } } } // proccess also results @@ -139,9 +154,11 @@ bool Model_Update::addModified(FeaturePtr theFeature, FeaturePtr theReason) { const std::set >& aRefs = (*aRes)->data()->refsToMe(); std::set >::const_iterator aRefIter = aRefs.cbegin(); for(; aRefIter != aRefs.cend(); aRefIter++) { - FeaturePtr aReferenced = std::dynamic_pointer_cast((*aRefIter)->owner()); - if (aReferenced.get()) { - addModified(aReferenced, theFeature); + if ((*aRefIter)->isArgument()) { + FeaturePtr aReferenced = std::dynamic_pointer_cast((*aRefIter)->owner()); + if (aReferenced.get()) { + addModified(aReferenced, theFeature); + } } } } @@ -167,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; @@ -253,7 +271,7 @@ void Model_Update::processEvent(const std::shared_ptr& theMessag myProcessOnFinish.clear(); // processed features must be only on finish, so clear anyway (to avoid reimport on load) if (!(theMessage->eventID() == kOpStartEvent)) { - processFeatures(); + processFeatures(false); } // remove all macros before clearing all created std::set::iterator anUpdatedIter = myWaitForFinish.begin(); @@ -275,13 +293,22 @@ void Model_Update::processEvent(const std::shared_ptr& theMessag anUpdatedIter++; } } + // the redisplay signal should be flushed in order to erase the feature presentation in the viewer + // if should be done after removeFeature() of document, + // by this reason, upper processFeatures() do not perform this flush + Events_Loop::loop()->flush(Events_Loop::loop()->eventByName(EVENT_OBJECT_TO_REDISPLAY)); + // 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 } } -void Model_Update::processFeatures() +void Model_Update::processFeatures(const bool theFlushRedisplay) { // perform update of everything if it is not performed right now or any preview is blocked if (!myIsProcessed && !myIsPreviewBlocked) { @@ -295,16 +322,18 @@ void Model_Update::processFeatures() } 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); // 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"<& 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(); @@ -332,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 updtated 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; @@ -382,48 +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++) { - 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; @@ -434,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); @@ -448,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()<(*anIter); - if (aPointAttribute.get()) { + if (aPointAttribute.get() && (!aPointAttribute->textX().empty() || + !aPointAttribute->textY().empty() || !aPointAttribute->textZ().empty())) { if (myIsParamUpdated) { ModelAPI_AttributeEvalMessage::send(aPointAttribute, this); } @@ -588,7 +645,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)) || @@ -606,14 +664,21 @@ void Model_Update::updateArguments(FeaturePtr theFeature) { std::dynamic_pointer_cast(*aRefsIter); ObjectPtr aContext = aSel->context(); // update argument only if the referenced object is ready to use - if (aContext.get() && !aContext->isDisabled() && 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 @@ -627,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; } } } @@ -680,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);