X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FModel%2FModel_Update.cpp;h=f6f4cb7a15c6f27375980b3238b5872f2e3ee14d;hb=36c012079cecd007cd09c9192f06fcba9d8982f6;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..f6f4cb7a1 --- a/src/Model/Model_Update.cpp +++ b/src/Model/Model_Update.cpp @@ -1,13 +1,28 @@ -// Copyright (C) 2014-20xx CEA/DEN, EDF R&D - -// File: Model_Update.cxx -// Created: 25 Jun 2014 -// Author: Mikhail PONIKAROV +// Copyright (C) 2014-2017 CEA/DEN, EDF R&D +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// 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 +// #include #include #include #include +#include #include #include #include @@ -23,15 +38,14 @@ #include #include #include +#include #include #include #include #include -#include +#include #include -using namespace std; - Model_Update MY_UPDATER_INSTANCE; /// the only one instance initialized on load of the library //#define DEB_UPDATE @@ -56,6 +70,10 @@ 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); + static const Events_ID kUpdatedSel = aLoop->eventByName(EVENT_UPDATE_SELECTION); + aLoop->registerListener(this, kUpdatedSel); // Config_PropManager::findProp("Model update", "automatic_rebuild")->value() == "true"; myIsParamUpdated = false; @@ -69,35 +87,62 @@ bool Model_Update::addModified(FeaturePtr theFeature, FeaturePtr theReason) { if (!theFeature->data()->isValid()) return false; // delete an extrusion created on the sketch - if (theFeature->isPersistentResult()) { - if (!std::dynamic_pointer_cast((theFeature)->document())->executeFeatures()) + + 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()) { + myNotPersistentRefs[theFeature].insert(theReason); + } else { + std::set > aNewSet; + aNewSet.insert(theReason); + myNotPersistentRefs[theFeature] = aNewSet; + } + return false; } // 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()< 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(); + // need to be validated to update the "Apply" state if not previewed + aFactory->validate(theFeature); + + // to redisplay split's arguments presentation, even result is not computed + if (!theFeature->isPreviewNeeded()) { + static Events_Loop* aLoop = Events_Loop::loop(); + static const Events_ID kRedisplayEvent = aLoop->eventByName(EVENT_OBJECT_TO_REDISPLAY); + ModelAPI_EventCreator::get()->sendUpdated(theFeature, kRedisplayEvent); + aLoop->flush(kRedisplayEvent); } + 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 + theFeature->data()->execState() == ModelAPI_StateExecFailed) { // do not forget that in this case all were the reasons aNewSet.insert(theFeature); } else { if (theReason.get()) aNewSet.insert(theReason); } - myModified[theFeature] = aNewSet; + myModified[theFeature] = aNewSet; #ifdef DEB_UPDATE - std::cout<<"*** Add modified "<name()<name() + // <<" reason "<name()<name()<data()->execState() == ModelAPI_StateDone) + if (theFeature->data()->execState() == ModelAPI_StateDone || + theFeature->data()->execState() == ModelAPI_StateExecFailed) // fix issue 1819 theFeature->data()->execState(ModelAPI_StateMustBeUpdated); - else + else return true; // do not need iteration deeply if it is already marked as modified or so #ifdef DEB_UPDATE - std::cout<<"*** Set modified state "<name()<name()<& 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); + static const Events_ID kRedisplayEvent = aLoop->eventByName(EVENT_OBJECT_TO_REDISPLAY); + static const Events_ID kUpdatedSel = aLoop->eventByName(EVENT_UPDATE_SELECTION); #ifdef DEB_UPDATE std::cout<<"****** Event "<eventID().eventText()<& theMessag } return; } - // creation is added to "update" to avoid recomputation twice: on create and immediately after on update + if (theMessage->eventID() == kUpdatedSel) { + std::shared_ptr aMsg = + std::dynamic_pointer_cast(theMessage); + updateSelection(aMsg->objects()); + } + // creation is added to "update" to avoid recomputation twice: + // on create and immediately after on update if (theMessage->eventID() == kCreatedEvent) { std::shared_ptr aMsg = std::dynamic_pointer_cast(theMessage); const std::set& anObjs = aMsg->objects(); std::set::const_iterator anObjIter = anObjs.cbegin(); for(; anObjIter != anObjs.cend(); anObjIter++) { - if (std::dynamic_pointer_cast((*anObjIter)->document())->executeFeatures()) - ModelAPI_EventCreator::get()->sendUpdated(*anObjIter, kUpdatedEvent); + if (std::dynamic_pointer_cast((*anObjIter)->document())->executeFeatures()) { + if ((*anObjIter)->groupName() == ModelAPI_Feature::group()) { + // results creation means enabling, not update + ModelAPI_EventCreator::get()->sendUpdated(*anObjIter, kUpdatedEvent); + } else { + ModelAPI_EventCreator::get()->sendUpdated(*anObjIter, kRedisplayEvent); + } + } } return; } @@ -218,7 +286,8 @@ void Model_Update::processEvent(const std::shared_ptr& 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; @@ -228,15 +297,21 @@ void Model_Update::processEvent(const std::shared_ptr& theMessag if (anUpdated.get()) { if (addModified(anUpdated, FeaturePtr())) aSomeModified = true; - } else { // process the updated result as update of features that refers to this result - const std::set >& aRefs = (*anObjIter)->data()->refsToMe(); + } 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; } } @@ -253,17 +328,41 @@ void Model_Update::processEvent(const std::shared_ptr& theMessag if (theMessage->eventID() == kOpFinishEvent) { 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; } - myProcessOnFinish.clear(); // 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 reimport on load) + myProcessOnFinish.clear(); + + // #2156: current must be sketch, left after the macro execution + DocumentPtr anActiveDoc = ModelAPI_Session::get()->activeDocument(); + FeaturePtr aCurrent; + if (anActiveDoc.get()) + aCurrent = anActiveDoc->currentFeature(false); if (!(theMessage->eventID() == kOpStartEvent)) { processFeatures(false); } + + if (anActiveDoc.get() && aCurrent.get() && aCurrent->data()->isValid()) { + if (anActiveDoc->currentFeature(false) != aCurrent) + 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()) { @@ -284,14 +383,20 @@ 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 + // 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)); + Events_Loop::loop()->flush(kRedisplayEvent); // 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); + if (aMsg->reordered().get()) + addModified(aMsg->reordered(), aMsg->reordered()); // to update all attributes } } @@ -309,10 +414,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 +433,42 @@ 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(); @@ -347,9 +488,12 @@ bool Model_Update::processFeature(FeaturePtr theFeature) myProcessed[theFeature] = 0; } 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"); + if (aCount > 100) { + // too many repetition of processing (in VS it may crash on 330 with stack overflow) + Events_InfoMessage("Model_Update", + "Feature '%1' is updated in infinitive loop").arg(theFeature->data()->name()).send(); + // to stop iteration + myModified.clear(); return false; } myProcessed[theFeature] = aCount + 1; @@ -361,7 +505,8 @@ bool Model_Update::processFeature(FeaturePtr theFeature) if (theFeature->data()->execState() == ModelAPI_StateMustBeUpdated) { aIsModified = true; std::set > aNewSet; - aNewSet.insert(theFeature); // contains itself, so, we don't know which was the reason and the reason is any + // contains itself, so, we don't know which was the reason and the reason is any + aNewSet.insert(theFeature); myModified[theFeature] = aNewSet; } } @@ -386,91 +531,119 @@ bool Model_Update::processFeature(FeaturePtr theFeature) } } } + std::shared_ptr aShapeBefore = anExtSel->value(); + if (!aShapeBefore.get() && anExtSel->context()) aShapeBefore = anExtSel->context()->shape(); updateArguments(theFeature); + std::shared_ptr aShapeAfter = anExtSel->value(); + if (!aShapeAfter.get() && anExtSel->context()) aShapeAfter = anExtSel->context()->shape(); + // if selected plane is changed, try to re-take external references of all subs of the sketch + if (aShapeBefore.get() && !aShapeBefore->isEqual(aShapeAfter)) { + std::set aWholeR; + allReasons(theFeature, aWholeR); + std::set::iterator aRIter = aWholeR.begin(); + for(; aRIter != aWholeR.end(); aRIter++) { + if ((*aRIter)->data()->selection("External")) + (*aRIter)->attributeChanged("External"); + } + } } if (!aIsModified) { // no modification is needed return false; } - // evaluate parameter before the sub-elements update: it updates dependencies on evaluation (#1085) + // evaluate parameter before the sub-elements update: + // it updates dependencies on evaluation (#1085) if (theFeature->getKind() == "Parameter") { 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; CompositeFeaturePtr aCompos = std::dynamic_pointer_cast(theFeature); if (theFeature->getKind() == "ExtrusionSketch" && aCompos.get()) { - CompositeFeaturePtr aCurrentOwner = + 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(); + 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 - std::cout<<"Update args "<name()<name()<data()->isValid()) + return false; // Update selection and parameters attributes first, before sub-features analysis (sketch plane). updateArguments(theFeature); // add this feature to the processed right now to be able remove it from this list on // update signal during this feature execution myModified.erase(theFeature); + if (myNotPersistentRefs.find(theFeature) != myNotPersistentRefs.end()) + myNotPersistentRefs.erase(theFeature); if (theFeature->data()->execState() == ModelAPI_StateMustBeUpdated) 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 - 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()<eraseResults(); + theFeature->eraseResults(false); redisplayWithResults(theFeature, ModelAPI_StateInvalidArgument); // result also must be updated return true; // so, feature is modified (results are erased) } @@ -485,13 +658,14 @@ bool Model_Update::processFeature(FeaturePtr theFeature) #ifdef DEB_UPDATE std::cout<<"Feature is not valid, erase results "<name()<eraseResults(); + theFeature->eraseResults(false); redisplayWithResults(theFeature, ModelAPI_StateInvalidArgument); // result also must be updated } 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); @@ -501,8 +675,11 @@ void Model_Update::redisplayWithResults(FeaturePtr theFeature, const ModelAPI_Ex 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); + if (!aRes->isDisabled()) { + // update state only for enabled results + // (Placement Result Part may make the original Part Result as invalid) + if (theUpdateState) + aRes->data()->execState(theState); } if (theFeature->data()->updateID() > aRes->data()->updateID()) { aRes->data()->setUpdateID(theFeature->data()->updateID()); @@ -511,7 +688,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 @@ -532,7 +710,6 @@ ModelAPI_ExecState stateByReference(ObjectPtr theTarget, const ModelAPI_ExecStat 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(); ModelAPI_ExecState aState = theFeature->data()->execState(); @@ -586,7 +763,7 @@ void Model_Update::updateArguments(FeaturePtr theFeature) { for(; anIter != anAttributes.end(); anIter++) { AttributePointPtr aPointAttribute = std::dynamic_pointer_cast(*anIter); - if (aPointAttribute.get() && (!aPointAttribute->textX().empty() || + if (aPointAttribute.get() && (!aPointAttribute->textX().empty() || !aPointAttribute->textY().empty() || !aPointAttribute->textZ().empty())) { if (myIsParamUpdated) { ModelAPI_AttributeEvalMessage::send(aPointAttribute, this); @@ -607,7 +784,7 @@ void Model_Update::updateArguments(FeaturePtr theFeature) { AttributePoint2DPtr aPoint2DAttribute = std::dynamic_pointer_cast(*anIter); if (aPoint2DAttribute.get()) { - if (myIsParamUpdated && (!aPoint2DAttribute->textX().empty() || + if (myIsParamUpdated && (!aPoint2DAttribute->textX().empty() || !aPoint2DAttribute->textY().empty())) { ModelAPI_AttributeEvalMessage::send(aPoint2DAttribute, this); } @@ -618,22 +795,29 @@ void Model_Update::updateArguments(FeaturePtr theFeature) { } } // update the selection attributes if any - list aRefs = + std::list aRefs = theFeature->data()->attributes(ModelAPI_AttributeSelection::typeId()); - list::iterator aRefsIter = aRefs.begin(); + std::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 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 +831,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; } } } @@ -664,23 +855,39 @@ void Model_Update::updateArguments(FeaturePtr theFeature) { theFeature->data()->execState(aState); } -bool Model_Update::isReason(std::shared_ptr& theFeature, - std::shared_ptr theReason) +bool Model_Update::isReason(std::shared_ptr& theFeature, + std::shared_ptr theReason) { std::map, std::set > > ::iterator aReasonsIt = myModified.find(theFeature); - if (aReasonsIt == myModified.end()) - return false; // this case only for not-previewed items update state, nothing is changed in args for it - if (aReasonsIt->second.find(theFeature) != aReasonsIt->second.end()) - return true; // any is reason if it contains itself - FeaturePtr aReasFeat = std::dynamic_pointer_cast(theReason); - if (!aReasFeat.get()) { // try to get feature of this result - ResultPtr aReasRes = std::dynamic_pointer_cast(theReason); - if (aReasRes.get()) - aReasFeat = theReason->document()->feature(aReasRes); - } - return aReasonsIt->second.find(aReasFeat) != aReasonsIt->second.end(); + if (aReasonsIt != myModified.end()) { + if (aReasonsIt->second.find(theFeature) != aReasonsIt->second.end()) + return true; // any is reason if it contains itself + FeaturePtr aReasFeat = std::dynamic_pointer_cast(theReason); + if (!aReasFeat.get()) { // try to get feature of this result + ResultPtr aReasRes = std::dynamic_pointer_cast(theReason); + if (aReasRes.get()) + aReasFeat = theReason->document()->feature(aReasRes); + } + if (aReasonsIt->second.find(aReasFeat) != aReasonsIt->second.end()) + return true; + } + // another try: postponed modification by not-persistences + std::map, std::set > > + ::iterator aNotPersist = myNotPersistentRefs.find(theFeature); + if (aNotPersist != myNotPersistentRefs.end()) { + FeaturePtr aReasFeat = std::dynamic_pointer_cast(theReason); + if (!aReasFeat.get()) { // try to get feature of this result + ResultPtr aReasRes = std::dynamic_pointer_cast(theReason); + if (aReasRes.get()) + aReasFeat = theReason->document()->feature(aReasRes); + } + if (aNotPersist->second.find(aReasFeat) != aNotPersist->second.end()) + return true; + } + // this case only for not-previewed items update state, nothing is changed in args for it + return false; } void Model_Update::executeFeature(FeaturePtr theFeature) @@ -700,13 +907,13 @@ 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 + // The macro feature has to be deleted in any case even its execution is failed myWaitForFinish.insert(theFeature); if (aState != ModelAPI_StateDone) { - theFeature->eraseResults(); + theFeature->eraseResults(false); } theFeature->data()->setUpdateID(ModelAPI_Session::get()->transactionID()); redisplayWithResults(theFeature, aState); @@ -719,28 +926,31 @@ void Model_Update::updateStability(void* theSender) bool added = false; // object may be was crated ModelAPI_Object* aSender = static_cast(theSender); if (aSender && aSender->document()) { - FeaturePtr aFeatureSender = + FeaturePtr aFeatureSender = std::dynamic_pointer_cast(aSender->data()->owner()); if (aFeatureSender.get()) { - Model_Objects* aDocObjects = + 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(); + std::list > >::iterator + aRefIt = aRefs.begin(); for(; aRefIt != aRefs.end(); aRefIt++) { if (!aFactory->isConcealed(aFeatureSender->getKind(), aRefIt->first)) - continue; // take into account only concealed references (do not remove the sketch constraint and the edge on constraint edit) + // take into account only concealed references + // (do not remove the sketch constraint and the edge on constraint edit) + continue; 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 + // stability is only on results: feature to feature reference mean nested // features, that will remove nesting references - if (aReferenced->get() && (*aReferenced)->data()->isValid() && + if (aReferenced->get() && (*aReferenced)->data()->isValid() && (*aReferenced)->groupName() != ModelAPI_Feature::group()) { - std::shared_ptr aData = + std::shared_ptr aData = std::dynamic_pointer_cast((*aReferenced)->data()); if (aFeatureSender->isStable()) { aData->addBackReference(aFeatureSender, aRefIt->first); @@ -761,3 +971,30 @@ void Model_Update::updateStability(void* theSender) } } } + +void Model_Update::updateSelection(const std::set >& theObjects) +{ + std::set >::iterator anObj = theObjects.begin(); + for(; anObj != theObjects.end(); anObj++) { + std::list aRefs = + (*anObj)->data()->attributes(ModelAPI_AttributeSelection::typeId()); + std::list::iterator aRefsIter = aRefs.begin(); + for (; aRefsIter != aRefs.end(); aRefsIter++) { + std::shared_ptr aSel = + std::dynamic_pointer_cast(*aRefsIter); + aSel->updateInHistory(); + } + // update the selection list attributes if any + aRefs = (*anObj)->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.get()) + aSelAttr->updateInHistory(); + } + } + } +}