X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FModel%2FModel_Update.cpp;h=9d655c03c64a57db054c18350b13bd99554b50fc;hb=6925e1e8fb0b465d32b2ce7e0d7a32582b53858c;hp=244aa68678f78cc2ad1d0dbaa10869a6fafbfafe;hpb=35d4b199e4d3581615470404d47e3bfae4def046;p=modules%2Fshaper.git diff --git a/src/Model/Model_Update.cpp b/src/Model/Model_Update.cpp index 244aa6867..9d655c03c 100644 --- a/src/Model/Model_Update.cpp +++ b/src/Model/Model_Update.cpp @@ -54,14 +54,18 @@ Model_Update::Model_Update() aLoop->registerListener(this, kOpAbortEvent); static const Events_ID kOpStartEvent = aLoop->eventByName("StartOperation"); aLoop->registerListener(this, kOpStartEvent); + static const Events_ID kStabilityEvent = aLoop->eventByName(EVENT_STABILITY_CHANGED); + aLoop->registerListener(this, kStabilityEvent); + /* not needed now with history line Config_PropManager::registerProp("Model update", "automatic_rebuild", "Rebuild immediately", - Config_Prop::Boolean, "false"); + Config_Prop::Boolean, "false");*/ myIsAutomatic = true; // Config_PropManager::findProp("Model update", "automatic_rebuild")->value() == "true"; myIsParamUpdated = false; myIsFinish = false; myModification = 0; + myModificationInStartProcessing = 0; } void Model_Update::processEvent(const std::shared_ptr& theMessage) @@ -75,17 +79,21 @@ 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"); + static const Events_ID kStabilityEvent = aLoop->eventByName(EVENT_STABILITY_CHANGED); #ifdef DEB_UPDATE std::cout<<"****** Event "<eventID().eventText()<eventID() == kStabilityEvent) + updateStability(theMessage->sender()); if (theMessage->eventID() == kChangedEvent) { // automatic and manual rebuild flag is changed - bool aPropVal = + /*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 || @@ -102,6 +110,8 @@ void Model_Update::processEvent(const std::shared_ptr& theMessag if ((*anObjIter)->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 FeaturePtr anUpdated = std::dynamic_pointer_cast(*anObjIter); if (std::dynamic_pointer_cast((*anObjIter)->document())->executeFeatures() || @@ -162,7 +172,8 @@ void Model_Update::processEvent(const std::shared_ptr& theMessag // place where results are cleared) myIsParamUpdated = false; myUpdated.clear(); - myModification = 0; + // do not erase it since there may be modification increment on start of operation + //myModification = 0; myWaitForFinish.clear(); } } @@ -202,7 +213,7 @@ void Model_Update::iterateUpdateBreak(std::shared_ptr theFeatu } // for the current breaked, set iteration to this feature precisely aBreaked->setCurrentBefore(theFeature); - myModification++; + //myModification++; } // the iterator that contains breaked is found, so, nothing else is needed return; @@ -216,32 +227,13 @@ void Model_Update::iterateUpdateBreak(std::shared_ptr theFeatu 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" || aF->getKind() == "Revolution")) { - 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); - } - } - } - } - } - } // perform update of everything if needed if (!myIsExecuted) { #ifdef DEB_UPDATE std::cout<<"****** Start processing"<eventByName(EVENT_OBJECT_UPDATED); + aLoop->flush(kUpdatedEvent); 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 @@ -266,22 +265,42 @@ void Model_Update::processOperation(const bool theTotalUpdate, const bool theFin } } +bool Model_Update::isProcessed(const int theModificationID) +{ + return theModificationID >= myModificationInStartProcessing && + theModificationID <= myModification; +} + void Model_Update::updateFeature(FeaturePtr theFeature) { // check all features this feature depended on (recursive call of updateFeature) static ModelAPI_ValidatorsFactory* aFactory = ModelAPI_Session::get()->validators(); - if (theFeature->isDisabled()) + if (theFeature->isDisabled()) { + // possibly sub-elements are not disabled? + CompositeFeaturePtr aCompos = std::dynamic_pointer_cast(theFeature); + if (aCompos) + iterateUpdate(aCompos); return; + } + + // 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); + } #ifdef DEB_UPDATE - //std::cout<<"Update Feature "<name()<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) + (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) @@ -298,7 +317,9 @@ void Model_Update::updateFeature(FeaturePtr theFeature) 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) + + // issue 955: extrusion fuse sketch naming must be updated after the sketch update + // so, comment this: if (theFeature->data()->execState() != ModelAPI_StateMustBeUpdated) updateArguments(theFeature); } // this checking must be after the composite feature sub-elements processing: @@ -310,7 +331,13 @@ void Model_Update::updateFeature(FeaturePtr theFeature) } // only the currently updated features are executed - bool aJustUpdated = myUpdated.find(theFeature) != myUpdated.end() && myUpdated[theFeature] == myModification; + 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]); + } + } if (myIsAutomatic && theFeature->data()->execState() == ModelAPI_StateMustBeUpdated) aJustUpdated = true; @@ -345,11 +372,16 @@ void Model_Update::updateFeature(FeaturePtr theFeature) if (aJustUpdated) { ModelAPI_ExecState aState = theFeature->data()->execState(); if (aFactory->validate(theFeature)) { + if (!isPostponedMain) { + #ifdef DEB_UPDATE + std::cout<<"Execute Feature "<name()<name()<name()<eraseResults(); redisplayWithResults(theFeature, ModelAPI_StateInvalidArgument); // result also must be updated } @@ -357,8 +389,10 @@ void Model_Update::updateFeature(FeaturePtr theFeature) } 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 + 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 + } } } } @@ -367,9 +401,11 @@ void Model_Update::redisplayWithResults(FeaturePtr theFeature, const ModelAPI_Ex { // make updated and redisplay all results static Events_ID EVENT_DISP = Events_Loop::loop()->eventByName(EVENT_OBJECT_TO_REDISPLAY); - const std::list >& aResults = theFeature->results(); - std::list >::const_iterator aRIter = aResults.begin(); - for (; aRIter != aResults.cend(); aRIter++) { + + std::list allResults; + ModelAPI_Tools::allResults(theFeature, allResults); + 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); @@ -384,6 +420,7 @@ 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 } /// Updates the state by the referenced object: if something bad with it, set state for this one @@ -411,6 +448,27 @@ bool Model_Update::isOlder(std::shared_ptr theFeature, 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 @@ -507,7 +565,8 @@ void Model_Update::updateArguments(FeaturePtr theFeature) { aState = ModelAPI_StateInvalidArgument; } } else if (aSel->isInvalid()) { // not needed to update, but invalid (stated previously) - aState = ModelAPI_StateInvalidArgument; + if (isObligatory) + aState = ModelAPI_StateInvalidArgument; } } } @@ -533,7 +592,8 @@ void Model_Update::updateArguments(FeaturePtr theFeature) { aState = ModelAPI_StateInvalidArgument; } } else if (aSelAttr->isInvalid()) { - aState = ModelAPI_StateInvalidArgument; + if (isObligatory) + aState = ModelAPI_StateInvalidArgument; } } } @@ -566,7 +626,8 @@ void Model_Update::updateArguments(FeaturePtr 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++) { + 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)) { @@ -582,6 +643,8 @@ void Model_Update::updateArguments(FeaturePtr theFeature) { } } } + if (a == aNumSubs - 1) // in case number of subs is changed, just recheck before end + aNumSubs = aCompos->numberOfSubs(); } } @@ -601,13 +664,14 @@ void Model_Update::executeFeature(FeaturePtr theFeature) 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"); } + // The macro feature has to be deleted in any case even its execution is failed + myWaitForFinish.insert(theFeature); if (aState != ModelAPI_StateDone) { theFeature->eraseResults(); } @@ -615,6 +679,53 @@ void Model_Update::executeFeature(FeaturePtr theFeature) redisplayWithResults(theFeature, aState); } +void Model_Update::updateStability(void* theSender) +{ + if (theSender) { + bool added = false; // object may be was crated + ModelAPI_Object* aSender = static_cast(theSender); + if (aSender && aSender->document()) { + FeaturePtr aFeatureSender = + std::dynamic_pointer_cast(aSender->data()->owner()); + if (aFeatureSender.get()) { + 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(); + for(; aRefIt != aRefs.end(); aRefIt++) { + 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 + // features, that will remove nesting references + if (aReferenced->get() && (*aReferenced)->data()->isValid() && + (*aReferenced)->groupName() != ModelAPI_Feature::group()) { + std::shared_ptr aData = + std::dynamic_pointer_cast((*aReferenced)->data()); + if (aFeatureSender->isStable()) { + aData->addBackReference(aFeatureSender, aRefIt->first); + } else { + aData->removeBackReference(aFeatureSender, aRefIt->first); + added = true; // remove of concealment may be caused creation of some result + } + } + } + } + } + } + } + if (added) { + static Events_Loop* aLoop = Events_Loop::loop(); + static Events_ID kEventCreated = aLoop->eventByName(EVENT_OBJECT_CREATED); + aLoop->flush(kEventCreated); + } + } +} + ///////////////// Updated items iterator //////////////////////// Model_Update::IterationItem::IterationItem(std::shared_ptr theFeature) { @@ -654,7 +765,14 @@ void Model_Update::IterationItem::next() break; } } else if (mySub.get()) { - mySub = myObjects->nextFeature(mySub); + 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; + } + } } } }