X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FModel%2FModel_Update.cpp;h=98d13b066b410deb6d813c01e22827520efa7214;hb=97917d3698f5a2f7fc9596e7c755ff8f6751e373;hp=8e2ac8137228b26224f0245b17bd2d08095d3399;hpb=3d35e6956fa6cbf7da6d04a6bffacc09e8484d38;p=modules%2Fshaper.git diff --git a/src/Model/Model_Update.cpp b/src/Model/Model_Update.cpp old mode 100755 new mode 100644 index 8e2ac8137..98d13b066 --- a/src/Model/Model_Update.cpp +++ b/src/Model/Model_Update.cpp @@ -1,4 +1,4 @@ -// Copyright (C) 2014-2017 CEA/DEN, EDF R&D +// Copyright (C) 2014-2019 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 @@ -12,10 +12,9 @@ // // 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 +// 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 @@ -38,8 +37,12 @@ #include #include #include +#include +#include +#include #include #include +#include #include #include #include @@ -74,12 +77,15 @@ 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 kAutoRecomp = aLoop->eventByName(EVENT_AUTOMATIC_RECOMPUTATION_ENABLE); + aLoop->registerListener(this, kAutoRecomp); // 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) { @@ -87,6 +93,7 @@ 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) { @@ -160,7 +167,7 @@ bool Model_Update::addModified(FeaturePtr theFeature, FeaturePtr theReason) { if (theReason.get()) aNewSet.insert(theReason); } - myModified[theFeature] = aNewSet; + myModified[theFeature] = aNewSet; #ifdef DEB_UPDATE if (theReason.get()) { //std::cout<<"*** Add modified "<name() @@ -190,7 +197,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(); @@ -220,6 +227,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"); @@ -235,6 +243,32 @@ void Model_Update::processEvent(const std::shared_ptr& theMessag #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; @@ -245,9 +279,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; } @@ -263,16 +300,19 @@ void Model_Update::processEvent(const std::shared_ptr& theMessag std::dynamic_pointer_cast(theMessage); const std::set& anObjs = aMsg->objects(); std::set::const_iterator anObjIter = anObjs.cbegin(); + std::list aFeatures, aResults; for(; anObjIter != anObjs.cend(); anObjIter++) { 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); + aFeatures.push_back(*anObjIter); } else { - ModelAPI_EventCreator::get()->sendUpdated(*anObjIter, kRedisplayEvent); + aResults.push_back(*anObjIter); } } } + ModelAPI_EventCreator::get()->sendUpdated(aFeatures, kUpdatedEvent); + ModelAPI_EventCreator::get()->sendUpdated(aResults, kRedisplayEvent); return; } if (theMessage->eventID() == kUpdatedEvent) { @@ -291,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; } } @@ -320,7 +376,7 @@ 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::map, std::set > >:: @@ -332,14 +388,14 @@ void Model_Update::processEvent(const std::shared_ptr& theMessag continue; } std::set >::iterator aReasons; - for(aReasons = aFeature->second.begin(); aReasons != aFeature->second.end(); 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 @@ -353,11 +409,11 @@ void Model_Update::processEvent(const std::shared_ptr& theMessag } if (anActiveDoc.get() && aCurrent.get() && aCurrent->data()->isValid()) { - if (anActiveDoc->currentFeature(false) != aCurrent) + if (anActiveDoc->currentFeature(false) != aCurrent && + ModelAPI_Tools::compositeOwner(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()) { @@ -428,7 +484,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); @@ -512,36 +568,46 @@ bool Model_Update::processFeature(FeaturePtr theFeature) // update the sketch plane before the sketch sub-elements are recomputed // (otherwise sketch will update plane, modify subs, after executed, but with old subs edges) - if (aIsModified && theFeature->getKind() == "Sketch") { + if (aIsModified && theFeature->getKind() == "Sketch") { #ifdef DEB_UPDATE - std::cout<<"****** Update sketch args "<name()<name() << std::endl; #endif - AttributeSelectionPtr anExtSel = theFeature->selection("External"); - if (anExtSel.get()) { - ResultPtr aContext = anExtSel->context(); - if (aContext.get() && aContext->document().get()) { - FeaturePtr anExtBase = aContext->document()->feature(aContext); - if (anExtBase.get()) { - processFeature(anExtBase); + AttributeSelectionPtr anExtSel = theFeature->selection("External"); + if (anExtSel.get()) { + ResultPtr aContext = anExtSel->context(); + if (aContext.get() && aContext->document().get()) { + FeaturePtr anExtBase = aContext->document()->feature(aContext); + if (anExtBase.get()) { + processFeature(anExtBase); + } + std::shared_ptr anOrigin = + std::dynamic_pointer_cast(theFeature->attribute("Origin")); + double anOX = anOrigin->x(), anOY = anOrigin->y(), anOZ = anOrigin->z(); + std::shared_ptr aDir = + std::dynamic_pointer_cast(theFeature->attribute("DirX")); + double aDX = aDir->x(), aDY = aDir->y(), aDZ = aDir->z(); + std::shared_ptr aNorm = + std::dynamic_pointer_cast(theFeature->attribute("Norm")); + double aNX = aNorm->x(), aNY = aNorm->y(), aNZ = aNorm->z(); + // update sketch plane + updateArguments(theFeature); + theFeature->attributeChanged("External"); // to recompute origin, direction and normal + // check it is updated, so all must be changed + if (anOrigin->x() != anOX || anOrigin->y() != anOY || anOrigin->z() != anOZ || + aDir->x() != aDX || aDir->y() != aDY || aDir->z() != aDZ || + aNorm->x() != aNX || aNorm->y() != aNY || aNorm->z() != aNZ) + { + std::set aWholeR; + allReasons(theFeature, aWholeR); + std::set::iterator aRIter = aWholeR.begin(); + for (; aRIter != aWholeR.end(); aRIter++) { + if ((*aRIter)->data()->selection("External").get()) + (*aRIter)->attributeChanged("External"); + } + } } } } - 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; @@ -573,7 +639,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 @@ -593,6 +662,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 @@ -613,7 +701,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 @@ -630,7 +718,24 @@ 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() || + theFeature->getKind() == "Sketch"); + } 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 @@ -897,6 +1002,8 @@ void Model_Update::executeFeature(FeaturePtr theFeature) redisplayWithResults(theFeature, aState); } +// it is called on GUI edit of feature start +// LCOV_EXCL_START void Model_Update::updateStability(void* theSender) { static ModelAPI_ValidatorsFactory* aFactory = ModelAPI_Session::get()->validators(); @@ -949,6 +1056,7 @@ void Model_Update::updateStability(void* theSender) } } } +// LCOV_EXCL_STOP void Model_Update::updateSelection(const std::set >& theObjects) {