X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FModel%2FModel_Update.cpp;h=23d96f4298a3d909c0a248f30e9c9f3e19a32080;hb=f36409774efce7c530518a1553946c9c76526fb9;hp=0baff517495c1d305bad1218d96b8844cff3f99d;hpb=2532fb2df83ee1ddd9ff3e8b381d3788eaa15b69;p=modules%2Fshaper.git diff --git a/src/Model/Model_Update.cpp b/src/Model/Model_Update.cpp index 0baff5174..23d96f429 100755 --- a/src/Model/Model_Update.cpp +++ b/src/Model/Model_Update.cpp @@ -14,7 +14,8 @@ // 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 +// See http://www.salome-platform.org/ or +// email : webmaster.salome@opencascade.com // #include @@ -37,6 +38,8 @@ #include #include #include +#include +#include #include #include #include @@ -73,12 +76,17 @@ Model_Update::Model_Update() aLoop->registerListener(this, kReorderEvent); static const Events_ID kUpdatedSel = aLoop->eventByName(EVENT_UPDATE_SELECTION); aLoop->registerListener(this, kUpdatedSel); + static const Events_ID kAutomaticOff = aLoop->eventByName(EVENT_AUTOMATIC_RECOMPUTATION_DISABLE); + aLoop->registerListener(this, kAutomaticOff); + static const Events_ID kAutomaticOn = aLoop->eventByName(EVENT_AUTOMATIC_RECOMPUTATION_ENABLE); + aLoop->registerListener(this, kAutomaticOn); // Config_PropManager::findProp("Model update", "automatic_rebuild")->value() == "true"; myIsParamUpdated = false; myIsFinish = false; myIsProcessed = false; myIsPreviewBlocked = false; + myUpdateBlocked = false; } bool Model_Update::addModified(FeaturePtr theFeature, FeaturePtr theReason) { @@ -86,9 +94,11 @@ 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()) { @@ -103,7 +113,10 @@ bool Model_Update::addModified(FeaturePtr theFeature, FeaturePtr theReason) { // update arguments for "apply button" state change if ((!theFeature->isPreviewNeeded() && !myIsFinish) || myIsPreviewBlocked) { - myProcessOnFinish.insert(theFeature); + 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()<name() @@ -185,7 +198,7 @@ bool Model_Update::addModified(FeaturePtr theFeature, FeaturePtr theReason) { } } } - // proccess also results + // process also results std::list allResults; // list of this feature and results ModelAPI_Tools::allResults(theFeature, allResults); std::list::iterator aRes = allResults.begin(); @@ -215,6 +228,7 @@ bool Model_Update::addModified(FeaturePtr theFeature, FeaturePtr theReason) { void Model_Update::processEvent(const std::shared_ptr& theMessage) { static Events_Loop* aLoop = Events_Loop::loop(); + 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 kOpFinishEvent = aLoop->eventByName("FinishOperation"); @@ -226,10 +240,38 @@ void Model_Update::processEvent(const std::shared_ptr& theMessag 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); + static const Events_ID kAutomaticOff = aLoop->eventByName(EVENT_AUTOMATIC_RECOMPUTATION_DISABLE); + static const Events_ID kAutomaticOn = aLoop->eventByName(EVENT_AUTOMATIC_RECOMPUTATION_ENABLE); #ifdef DEB_UPDATE std::cout<<"****** Event "<eventID().eventText()<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()); return; @@ -240,9 +282,12 @@ void Model_Update::processEvent(const std::shared_ptr& theMessag } if (theMessage->eventID() == kPreviewRequestedEvent) { if (myIsPreviewBlocked) { + bool anUpdateState = myUpdateBlocked; + myUpdateBlocked = false; myIsPreviewBlocked = false; processFeatures(); myIsPreviewBlocked = true; + myUpdateBlocked = anUpdateState; } return; } @@ -286,22 +331,38 @@ void Model_Update::processEvent(const std::shared_ptr& theMessag if ((*anObjIter)->groupName() == ModelAPI_ResultParameter::group()) { myIsParamUpdated = true; } - // 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 (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); + } + }*/ + } } else { // process the updated result as update of features that refers to this result const std::set >& aRefs = (*anObjIter)->data()->refsToMe(); std::set >::const_iterator aRefIter = aRefs.cbegin(); + 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, FeaturePtr())) + if (addModified(anUpdated, aReason)) aSomeModified = true; } } @@ -315,16 +376,26 @@ void Model_Update::processEvent(const std::shared_ptr& theMessag theMessage->eventID() == kOpStartEvent) { myIsPreviewBlocked = false; - if (theMessage->eventID() == kOpFinishEvent) { + if (theMessage->eventID() == kOpFinishEvent) {// if update is blocked, skip myIsFinish = true; // add features that wait for finish as modified - std::set >::iterator aFeature = myProcessOnFinish.begin(); - for(; aFeature != myProcessOnFinish.end(); aFeature++) - if ((*aFeature)->data()->isValid()) // there may be already removed wait for features - addModified(*aFeature, FeaturePtr()); + 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 reimport on load) + // 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 @@ -342,7 +413,6 @@ void Model_Update::processEvent(const std::shared_ptr& theMessag anActiveDoc->setCurrentFeature(aCurrent, false); // #2156 make the current feature back } - // remove all macros before clearing all created std::set::iterator anUpdatedIter = myWaitForFinish.begin(); while(anUpdatedIter != myWaitForFinish.end()) { @@ -413,7 +483,7 @@ void Model_Update::processFeatures(const bool theFlushRedisplay) } } -// collects all the feautres this feature depends on: reasons +// collects all the features this feature depends on: reasons static void allReasons(FeaturePtr theFeature, std::set& theReasons) { std::list > > > aDeps; theFeature->data()->referencesToObjects(aDeps); @@ -558,7 +628,10 @@ bool Model_Update::processFeature(FeaturePtr theFeature) if (aReason != theFeature && (aReason)->data()->isValid()) { if (processFeature(aReason)) aIsModified = true; - if (aReason->data()->execState() == ModelAPI_StateInvalidArgument) + // 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 @@ -578,6 +651,25 @@ bool Model_Update::processFeature(FeaturePtr theFeature) 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; + } + } } #ifdef DEB_UPDATE @@ -598,7 +690,7 @@ bool Model_Update::processFeature(FeaturePtr theFeature) theFeature->data()->execState(ModelAPI_StateDone); // this checking must be after the composite feature sub-elements processing: - // composite feature status may depend on it's subelements + // 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 @@ -615,7 +707,23 @@ bool Model_Update::processFeature(FeaturePtr theFeature) ModelAPI_ExecState aState = theFeature->data()->execState(); if (aFactory->validate(theFeature)) { if (!isPostponedMain) { - executeFeature(theFeature); + bool aDoExecute = true; + if (myUpdateBlocked) { + if (!theFeature->isStable()) { + aDoExecute = true; + } else if (theFeature->results().size()) { // execute only not-results features + aDoExecute = !(theFeature->firstResult()->groupName() == ModelAPI_ResultBody::group() || + theFeature->firstResult()->groupName() == ModelAPI_ResultPart::group()); + } else { + aDoExecute = aState != ModelAPI_StateInvalidArgument; + } + } + if (aDoExecute) { + executeFeature(theFeature); + } else { + // store information that this feature must be executed later + theFeature->data()->execState(ModelAPI_StateMustBeUpdated); + } } } else { #ifdef DEB_UPDATE @@ -627,7 +735,8 @@ bool Model_Update::processFeature(FeaturePtr theFeature) 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); @@ -640,7 +749,8 @@ void Model_Update::redisplayWithResults(FeaturePtr theFeature, const ModelAPI_Ex 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 (theUpdateState) + aRes->data()->execState(theState); } if (theFeature->data()->updateID() > aRes->data()->updateID()) { aRes->data()->setUpdateID(theFeature->data()->updateID()); @@ -649,7 +759,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); + if (theUpdateState) + theFeature->data()->execState(theState); } /// Updates the state by the referenced object: if something bad with it, set state for this one @@ -791,7 +902,7 @@ 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()) { + if (aContext.get() && !aContext->isDisabled() && !aSelAttr->isInvalid()) { if (isReason(theFeature, aContext)) { if (!aSelAttr->update()) { bool isObligatory = !aFactory->isNotObligatory( @@ -801,7 +912,7 @@ void Model_Update::updateArguments(FeaturePtr theFeature) { aState = ModelAPI_StateInvalidArgument; } } - } else if (aContext.get()) { + } else if (aContext.get() || aSelAttr->isInvalid()) { // 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)