From b60c0aec61603b3f1218bec0e3366decfb49a67c Mon Sep 17 00:00:00 2001 From: mpv Date: Thu, 7 May 2015 20:26:15 +0300 Subject: [PATCH] Simplification of "Update" algorithm and "Macro" flag implementation for the box feature: not it fails on remove (or abort) because of python problems with swig connection (null shared pointer to "data") --- src/Model/Model_AttributeSelection.cpp | 2 +- src/Model/Model_Update.cpp | 390 ++++++++++----------- src/Model/Model_Update.h | 24 +- src/ModelAPI/ModelAPI_CompositeFeature.cpp | 1 - src/ModelAPI/ModelAPI_Feature.cpp | 6 + src/ModelAPI/ModelAPI_Feature.h | 4 + src/PythonAPI/modeler/extrusion.py | 4 +- src/PythonAddons/macros/box/feature.py | 11 +- src/SketchPlugin/SketchPlugin_Sketch.cpp | 11 + 9 files changed, 224 insertions(+), 229 deletions(-) diff --git a/src/Model/Model_AttributeSelection.cpp b/src/Model/Model_AttributeSelection.cpp index 3b82ea108..d6f9f869e 100644 --- a/src/Model/Model_AttributeSelection.cpp +++ b/src/Model/Model_AttributeSelection.cpp @@ -98,7 +98,7 @@ void Model_AttributeSelection::setValue(const ResultPtr& theContext, // to keep the reference attribute label TDF_Label aRefLab = myRef.myRef->Label(); aSelLab.ForgetAllAttributes(true); - myRef.myRef = TDF_Reference::Set(aSelLab, aSelLab); + myRef.myRef = TDF_Reference::Set(aSelLab.Father(), aSelLab.Father()); return; } if (theContext->groupName() == ModelAPI_ResultBody::group()) { diff --git a/src/Model/Model_Update.cpp b/src/Model/Model_Update.cpp index 403b3dffc..93f321bec 100644 --- a/src/Model/Model_Update.cpp +++ b/src/Model/Model_Update.cpp @@ -17,6 +17,7 @@ #include #include #include +#include #include #include #include @@ -67,20 +68,17 @@ 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"); - bool isAutomaticChanged = false; + bool isOperationChanged = false; if (theMessage->eventID() == kChangedEvent) { // automatic and manual rebuild flag is changed bool aPropVal = Config_PropManager::findProp("Model update", "automatic_rebuild")->value() == "true"; - if (aPropVal == myIsAutomatic) - return; // nothing is changed, so nithing to do - myIsAutomatic = aPropVal; - if (!myIsAutomatic) - return; // less automatization => nothing to do - } else if (theMessage->eventID() == kRebuildEvent) { // the rebuild command - if (myIsAutomatic == false) { - isAutomaticChanged = true; - myIsAutomatic = true; + if (aPropVal != myIsAutomatic) { // something is changed + myIsAutomatic = aPropVal; + if (myIsAutomatic) // higher level of automatization => to rebuild + processOperation(false); } + } else if (theMessage->eventID() == kRebuildEvent) { // the rebuild command + processOperation(true); } else if (theMessage->eventID() == kCreatedEvent || theMessage->eventID() == kUpdatedEvent || theMessage->eventID() == kMovedEvent) { std::shared_ptr aMsg = @@ -88,88 +86,113 @@ void Model_Update::processEvent(const std::shared_ptr& theMessag const std::set& anObjs = aMsg->objects(); std::set::const_iterator anObjIter = anObjs.cbegin(); for(; anObjIter != anObjs.cend(); anObjIter++) { - myJustCreatedOrUpdated.insert(*anObjIter); // created objects are always must be up to date (python box feature) // and updated not in internal uptation chain - if (!myIsExecuted || theMessage->eventID() == kCreatedEvent) - myInitial.insert(*anObjIter); - // TODO(mpv): check the next line. Came into dev 0.6.1 from BR_PYTHON_PLUGIN - // (*anObjIter)->data()->mustBeUpdated(true); // object must be updated because it was changed + if (theMessage->eventID() == kCreatedEvent) { + myJustCreated.insert(*anObjIter); + } else if (myJustCreated.find(*anObjIter) == myJustCreated.end()) { // moved and updated + myJustUpdated.insert(*anObjIter); + } } - if (theMessage->eventID() == kMovedEvent) - return; // this event is for solver update, not here + // this event is for solver update, not here, do not react immideately + if (!(theMessage->eventID() == kMovedEvent)) + processOperation(false); } else if (theMessage->eventID() == kOpStartEvent) { - myJustCreatedOrUpdated.clear(); - myInitial.clear(); - return; // we don't need the update only on operation start (caused problems in PartSet_Listener::processEvent) + // we don't need the update only on operation start (caused problems in PartSet_Listener::processEvent) + isOperationChanged = true; } else if (theMessage->eventID() == kOpFinishEvent || theMessage->eventID() == kOpAbortEvent) { - if (myIsAutomatic == false) { // Apply button now works as "Rebuild" - isAutomaticChanged = true; - myIsAutomatic = true; + processOperation(true); + isOperationChanged = true; + } + if (isOperationChanged) { + // remove all macros before clearing all created + std::set::iterator aCreatedIter = myJustCreated.begin(); + for(; aCreatedIter != myJustCreated.end(); aCreatedIter++) { + FeaturePtr aFeature = + std::dynamic_pointer_cast(*aCreatedIter); + if (aFeature.get() && aFeature->isMacro()) { + aFeature->document()->removeFeature(aFeature); + } } - // the hardcode (DBC asked): hide the sketch referenced by extrusion on apply - if (theMessage->eventID() == kOpFinishEvent) { - std::set >::iterator aFIter; - for(aFIter = myJustCreatedOrUpdated.begin(); aFIter != myJustCreatedOrUpdated.end(); aFIter++) - { - FeaturePtr aF = std::dynamic_pointer_cast(*aFIter); - if (aF && aF->data().get() && aF->getKind() == "Extrusion") { - 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) { - static Events_ID HIDE_DISP = Events_Loop::loop()->eventByName(EVENT_OBJECT_TOHIDE); - ModelAPI_EventCreator::get()->sendUpdated(aSketchRes, HIDE_DISP); - } - } + myJustCreated.clear(); + myJustUpdated.clear(); + } +} + +void Model_Update::processOperation(const bool theTotalUpdate) +{ + // the hardcode (DBC asked): hide the sketch referenced by extrusion on apply + std::set >::iterator aFIter; + for(aFIter = myJustCreated.begin(); aFIter != myJustCreated.end(); aFIter++) + { + FeaturePtr aF = std::dynamic_pointer_cast(*aFIter); + if (aF && aF->data().get() && aF->getKind() == "Extrusion") { + 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) { + static Events_ID HIDE_DISP = Events_Loop::loop()->eventByName(EVENT_OBJECT_TOHIDE); + ModelAPI_EventCreator::get()->sendUpdated(aSketchRes, HIDE_DISP); } } } } } + // perform update of everything if needed + if (!myIsExecuted) { + myIsExecuted = true; - if (myIsExecuted) - return; // nothing to do: it is executed now + bool isAutomaticChanged = false; - //Events_LongOp::start(this); - myIsExecuted = true; - // iterate all documents: features in Root first, then - subs - updateInDoc(ModelAPI_Session::get()->moduleDocument()); + if (theTotalUpdate && !myIsAutomatic) { // Apply button now works as "Rebuild" + isAutomaticChanged = true; + myIsAutomatic = true; + } - myUpdated.clear(); - // flush to update display - static Events_ID EVENT_DISP = aLoop->eventByName(EVENT_OBJECT_TO_REDISPLAY); - aLoop->flush(EVENT_DISP); - //Events_LongOp::end(this); - if (isAutomaticChanged) myIsAutomatic = false; + updateInDoc(ModelAPI_Session::get()->moduleDocument()); - if (theMessage->eventID() == kOpFinishEvent || theMessage->eventID() == kOpAbortEvent) { - myJustCreatedOrUpdated.clear(); - myInitial.clear(); - } + if (isAutomaticChanged) myIsAutomatic = false; + myIsExecuted = false; - myIsExecuted = false; + // 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); + } } void Model_Update::updateInDoc(std::shared_ptr theDoc) { + std::set alreadyProcessed; // features that are processed before others // all features one by one - int aNbFeatures = theDoc->size(ModelAPI_Feature::group(), true); - for (int aFIndex = 0; aFIndex < aNbFeatures; aFIndex++) { + for (int aFIndex = 0; aFIndex < theDoc->size(ModelAPI_Feature::group(), true); aFIndex++) { FeaturePtr aFeature = std::dynamic_pointer_cast( - theDoc->object(ModelAPI_Feature::group(), aFIndex, true)); - if (aFeature) + theDoc->object(ModelAPI_Feature::group(), aFIndex, true)); + if (aFeature && alreadyProcessed.find(aFeature) == alreadyProcessed.end()) { + // update selection and parameters attributes first, before sub-features analysis (sketch plane) + updateArguments(aFeature); + // composite feature must be executed after sub-features execution + CompositeFeaturePtr aComposite = + std::dynamic_pointer_cast(aFeature); + if (aComposite) { + // number of subs can be changed in execution: like fillet + for(int a = 0; a < aComposite->numberOfSubs(); a++) { + FeaturePtr aSub = aComposite->subFeature(a); + updateFeature(aSub); + alreadyProcessed.insert(aSub); + } + } + updateFeature(aFeature); - } - // all sub-documents one by one - std::shared_ptr aDoc = std::dynamic_pointer_cast(theDoc); - if (aDoc) { - const std::set aSubs = aDoc->subDocuments(true); - for(std::set::iterator aSub = aSubs.begin(); aSub != aSubs.end(); aSub++) { - DocumentPtr aSubDoc = theDoc->subDocument(*aSub); - if (aSubDoc) { - updateInDoc(aSubDoc); + // update the document results recursively + const std::list >& aResults = aFeature->results(); + std::list >::const_iterator aRIter = aResults.begin(); + for (; aRIter != aResults.cend(); aRIter++) { + ResultPartPtr aPart = std::dynamic_pointer_cast(*aRIter); + if (aPart.get()) { + updateInDoc(aPart->partDoc()); + } } } } @@ -184,7 +207,7 @@ void Model_Update::redisplayWithResults(FeaturePtr theFeature, const ModelAPI_Ex for (; aRIter != aResults.cend(); aRIter++) { std::shared_ptr aRes = *aRIter; aRes->data()->execState(theState); - myUpdated[aRes] = true; + myJustUpdated.insert(aRes); ModelAPI_EventCreator::get()->sendUpdated(aRes, EVENT_DISP); } // to redisplay "presentable" feature (for ex. distance constraint) @@ -206,50 +229,82 @@ ModelAPI_ExecState stateByReference(ObjectPtr theTarget, const ModelAPI_ExecStat return theCurrent; } -bool Model_Update::updateFeature(FeaturePtr theFeature) -{ - // check it is already processed - if (myUpdated.find(theFeature) != myUpdated.end()) - return myUpdated[theFeature]; - // check all features this feature depended on (recursive call of updateFeature) - ModelAPI_ValidatorsFactory* aFactory = ModelAPI_Session::get()->validators(); - bool aMustbeUpdated = myInitial.find(theFeature) != myInitial.end(); - if (theFeature) { // only real feature contains references to other objects - if (theFeature->data()->execState() != ModelAPI_StateDone) - aMustbeUpdated = true; - - ModelAPI_ExecState aState = ModelAPI_StateDone; +void Model_Update::updateArguments(FeaturePtr theFeature) { + static ModelAPI_ValidatorsFactory* aFactory = ModelAPI_Session::get()->validators(); - // check the parameters: values can be changed - std::list aDoubles = - theFeature->data()->attributes(ModelAPI_AttributeDouble::typeId()); - std::list::iterator aDoubleIter = aDoubles.begin(); - for(; aDoubleIter != aDoubles.end(); aDoubleIter++) { - AttributeDoublePtr aDouble = - std::dynamic_pointer_cast(*aDoubleIter); - if (aDouble.get() && !aDouble->text().empty()) { - double aNewVal; - if (ModelAPI_Tools::findVariable(aDouble->text(), aNewVal)) { - if (aNewVal != aDouble->value()) { - aDouble->setValue(aNewVal); - aMustbeUpdated = true; - } - } else { - aState = ModelAPI_StateInvalidArgument; + bool aJustUpdated = false; + ModelAPI_ExecState aState = ModelAPI_StateDone; + // check the parameters: values can be changed + std::list aDoubles = + theFeature->data()->attributes(ModelAPI_AttributeDouble::typeId()); + std::list::iterator aDoubleIter = aDoubles.begin(); + for(; aDoubleIter != aDoubles.end(); aDoubleIter++) { + AttributeDoublePtr aDouble = + std::dynamic_pointer_cast(*aDoubleIter); + if (aDouble.get() && !aDouble->text().empty()) { + double aNewVal; + if (ModelAPI_Tools::findVariable(aDouble->text(), aNewVal)) { + if (aNewVal != aDouble->value()) { + aDouble->setValue(aNewVal); + aJustUpdated = true; } + } else { + aState = ModelAPI_StateInvalidArgument; } } + } - // composite feature must be executed after sub-features execution - CompositeFeaturePtr aComposite = - std::dynamic_pointer_cast(theFeature); - if (aComposite) { - // number of subs can be changed in execution: like fillet - for(int a = 0; a < aComposite->numberOfSubs(); a++) { - if (updateFeature(aComposite->subFeature(a))) - aMustbeUpdated = true; + if (aState == ModelAPI_StateDone) {// all referenced objects are ready to be used + //std::cout<<"Execute feature "<getKind()< aRefs = + theFeature->data()->attributes(ModelAPI_AttributeSelection::typeId()); + list::iterator aRefsIter = aRefs.begin(); + for (; aRefsIter != aRefs.end(); aRefsIter++) { + std::shared_ptr aSel = + std::dynamic_pointer_cast(*aRefsIter); + if (!aSel->update()) { // this must be done on execution since it may be long operation + if (!aFactory->isNotObligatory(theFeature->getKind(), theFeature->data()->id(aSel)) && + aFactory->isCase(theFeature, theFeature->data()->id(aSel))) + aState = ModelAPI_StateInvalidArgument; + } + } + aRefs = theFeature->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) { + if (!aSelAttr->update()) { + if (!aFactory->isNotObligatory( + theFeature->getKind(), theFeature->data()->id(aSel)) && + aFactory->isCase(theFeature, theFeature->data()->id(aSel))) + aState = ModelAPI_StateInvalidArgument; + } + } } } + } + if (aJustUpdated && myJustCreated.find(theFeature) == myJustCreated.end()) + myJustUpdated.insert(theFeature); + if (aState != ModelAPI_StateDone) + theFeature->data()->execState(aState); +} + +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(); + bool aJustUpdated = false; + + if (theFeature) { + if (theFeature->data()->execState() != ModelAPI_StateDone) + aJustUpdated = true; + + ModelAPI_ExecState aState = ModelAPI_StateDone; + // check all references: if referenced objects are updated, this object also must be updated // also check state of referenced objects: if they are not ready, inherit corresponding state std::list > > aRefs; @@ -260,83 +315,44 @@ bool Model_Update::updateFeature(FeaturePtr theFeature) for(; aRef != aRefs.end(); aRef++) { std::list::iterator aRefObj = aRef->second.begin(); for(; aRefObj != aRef->second.end(); aRefObj++) { - if (updateObject(*aRefObj)) { - aMustbeUpdated = true; + if (myJustCreated.find(*aRefObj) != myJustCreated.end() || + myJustUpdated.find(*aRefObj) != myJustUpdated.end()) { + aJustUpdated = true; } aState = stateByReference(*aRefObj, aState); } } + // some arguments were changed, so, this feature must be updated + if (myJustCreated.find(theFeature) != myJustCreated.end()) { + aJustUpdated = true; + } else { + if (aJustUpdated) { + if (myJustUpdated.find(theFeature) == myJustUpdated.end()) + myJustUpdated.insert(theFeature); + } else { + aJustUpdated = myJustUpdated.find(theFeature) != myJustUpdated.end(); + } + } //std::cout<<"Update feature "<getKind()<<" must be updated = "<(theFeature->document())->executeFeatures() || !theFeature->isPersistentResult()) { if (aFactory->validate(theFeature)) { if (myIsAutomatic || - (myJustCreatedOrUpdated.find(theFeature) != myJustCreatedOrUpdated.end()) || - !theFeature->isPersistentResult() /* execute quick, not persistent results */) + (myJustCreated.find(theFeature) != myJustCreated.end() || + !theFeature->isPersistentResult() /* execute quick, not persistent results */)) { - if (aState == ModelAPI_StateDone) {// all referenced objects are ready to be used - //std::cout<<"Execute feature "<getKind()< aRefs = - theFeature->data()->attributes(ModelAPI_AttributeSelection::typeId()); - list::iterator aRefsIter = aRefs.begin(); - for (; aRefsIter != aRefs.end(); aRefsIter++) { - std::shared_ptr aSel = - std::dynamic_pointer_cast(*aRefsIter); - if (!aSel->update()) { // this must be done on execution since it may be long operation - if (!aFactory->isNotObligatory(theFeature->getKind(), theFeature->data()->id(aSel)) && - aFactory->isCase(theFeature, theFeature->data()->id(aSel))) - aState = ModelAPI_StateInvalidArgument; - } - } - aRefs = theFeature->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) { - if (!aSelAttr->update()) { - if (!aFactory->isNotObligatory( - theFeature->getKind(), theFeature->data()->id(aSel)) && - aFactory->isCase(theFeature, theFeature->data()->id(aSel))) - aState = ModelAPI_StateInvalidArgument; - } - } - } - } - // for sketch after update of plane (by update of selection attribute) - // but before execute, all sub-elements also must be updated (due to the plane changes) - if (aComposite) { - // number of subs can be changed in execution: like fillet - for(int a = 0; a < aComposite->numberOfSubs(); a++) { - FeaturePtr aSub = aComposite->subFeature(a); - bool aWasModified = myUpdated[aSub]; - myUpdated.erase(myUpdated.find(aSub)); // erase to update for sure (plane may be changed) - myInitial.insert(aSub); - updateFeature(aSub); - myUpdated[aSub] = aWasModified; // restore value - } - // re-execute after update: solver may update the previous values, so, shapes must be - // updated - for(int a = 0; a < aComposite->numberOfSubs(); a++) { - if (aComposite->subFeature(a) && aFactory->validate(aComposite->subFeature(a))) - aComposite->subFeature(a)->execute(); - } - } - } - // execute in try-catch to avoid internal problems of the feature - if (aState == ModelAPI_StateDone) { + if (aState == ModelAPI_StateDone || aState == ModelAPI_StateMustBeUpdated) { theFeature->data()->execState(ModelAPI_StateDone); try { theFeature->execute(); if (theFeature->data()->execState() != ModelAPI_StateDone) { aState = ModelAPI_StateExecFailed; + } else { + aState = ModelAPI_StateDone; } } catch(...) { aState = ModelAPI_StateExecFailed; @@ -364,48 +380,6 @@ bool Model_Update::updateFeature(FeaturePtr theFeature) } else { // for automatically updated features (on abort, etc) it is necessary to redisplay anyway redisplayWithResults(theFeature, ModelAPI_StateNothing); } - } else { - // returns also true is results were updated: for sketch that - // refers to sub-features but results of sub-features were changed - const std::list >& aResults = theFeature->results(); - std::list >::const_iterator aRIter = aResults.begin(); - for (; aRIter != aResults.cend(); aRIter++) { - if (myInitial.find(*aRIter) != myInitial.end()) { - aMustbeUpdated = true; - break; - } - } - } - } - myUpdated[theFeature] = aMustbeUpdated; - return aMustbeUpdated; -} - -bool Model_Update::updateObject(std::shared_ptr theObject, const bool theCyclic) -{ - if (myUpdated.find(theObject) != myUpdated.end()) - return myUpdated[theObject]; // already processed - - /* - if (theCyclic) { // algorithm for update of all features by dependencies tree - if (!theObject) - return false; - FeaturePtr aFeature = std::dynamic_pointer_cast(theObject); - if (aFeature) { // for feature just call update Feature - return updateFeature(aFeature); - } - // check general object, possible just a result - if (myUpdated.find(theObject) != myUpdated.end()) - return myUpdated[theObject]; // already processed - // check the feature of this object must be executed - ResultPtr aResult = std::dynamic_pointer_cast(theObject); - if (aResult) { - FeaturePtr aResFeature = aResult->document()->feature(aResult); - if (aResFeature) { - return updateFeature(aResFeature); - } } } - */ - return myInitial.find(theObject) != myInitial.end(); } diff --git a/src/Model/Model_Update.h b/src/Model/Model_Update.h index 6e09dc7ad..89141313b 100644 --- a/src/Model/Model_Update.h +++ b/src/Model/Model_Update.h @@ -23,18 +23,14 @@ class ModelAPI_Feature; */ class Model_Update : public Events_Listener { - /// initial set of updated features that must be processed: caused by external changes, not - /// by sequence of update of this class - std::set > myInitial; - /// already updated and processed features and modificated feature flag - std::map, bool> myUpdated; + /// created features during this transaction: must be updated all the time + std::set > myJustCreated; + /// updated features during this transaction: must be updated in the end of transaction + std::set > myJustUpdated; /// to know that all next updates are caused by this execution bool myIsExecuted; /// to know execute or not automatically all update bool myIsAutomatic; - /// just created features: they must be updated immideately even in not-automatic mode for - /// preview; cleared on commit operations - std::set > myJustCreatedOrUpdated; public: /// Is called only once, on startup of the application @@ -48,14 +44,18 @@ protected: void updateInDoc(std::shared_ptr theDoc); /// Recoursively checks and updates the feature if needed (calls the execute method) /// Returns true if feature was updated. - bool updateFeature(std::shared_ptr theFeature); + void updateFeature(std::shared_ptr theFeature); + + /// Updates the selection and parametrical arguments before the later feature analysis + void updateArguments(std::shared_ptr theFeature); - /// Recoursively checks and updates the object (result or feature) if needed (calls updateFeature) - /// Returns true if object was updated. - bool updateObject(std::shared_ptr theObject, const bool theCyclic = true); /// Sends the redisplay events for feature and results, updates the updated status void redisplayWithResults(std::shared_ptr theFeature, const ModelAPI_ExecState theState); + + /// On operation start/end/abort the "Just" fileds must be cleared and processed in the right way + /// \param theTotalUpdate force to updates everything that has been changed in this operation + void processOperation(const bool theTotalUpdate); }; #endif diff --git a/src/ModelAPI/ModelAPI_CompositeFeature.cpp b/src/ModelAPI/ModelAPI_CompositeFeature.cpp index ba5d1cd5c..5cad229fa 100644 --- a/src/ModelAPI/ModelAPI_CompositeFeature.cpp +++ b/src/ModelAPI/ModelAPI_CompositeFeature.cpp @@ -10,4 +10,3 @@ ModelAPI_CompositeFeature::~ModelAPI_CompositeFeature() { } - diff --git a/src/ModelAPI/ModelAPI_Feature.cpp b/src/ModelAPI/ModelAPI_Feature.cpp index d9533e83e..8a5d93cbd 100644 --- a/src/ModelAPI/ModelAPI_Feature.cpp +++ b/src/ModelAPI/ModelAPI_Feature.cpp @@ -171,3 +171,9 @@ FeaturePtr ModelAPI_Feature::feature(ObjectPtr theObject) } return aFeature; } + + +bool ModelAPI_Feature::isMacro() const +{ + return false; +} diff --git a/src/ModelAPI/ModelAPI_Feature.h b/src/ModelAPI/ModelAPI_Feature.h index 85ebe38b5..88f8d7221 100644 --- a/src/ModelAPI/ModelAPI_Feature.h +++ b/src/ModelAPI/ModelAPI_Feature.h @@ -98,6 +98,10 @@ class ModelAPI_Feature : public ModelAPI_Object return false; } + /// Returns true if this feature is used as macro: creates other features and then removed. + /// \returns false by default + MODELAPI_EXPORT virtual bool isMacro() const; + /// Must return document where the new feature must be added to /// By default it is empty: it is added to the document this method is called to MODELAPI_EXPORT virtual const std::string& documentToAdd(); diff --git a/src/PythonAPI/modeler/extrusion.py b/src/PythonAPI/modeler/extrusion.py index ecb7fbe79..785fba6ab 100644 --- a/src/PythonAPI/modeler/extrusion.py +++ b/src/PythonAPI/modeler/extrusion.py @@ -18,7 +18,7 @@ class Extrusion(): else: self.my.data().boolean("reverse").setValue(False) - self.my.data().real("size").setValue(size) + self.my.data().real("to_size").setValue(size) if ModelAPI_Session.get().validators().validate(self.my): self.my.execute() @@ -34,7 +34,7 @@ class Extrusion(): else: self.my.data().boolean("reverse").setValue(False) - self.my.data().real("size").setValue(size) + self.my.data().real("to_size").setValue(size) self.my.execute() def result (self): diff --git a/src/PythonAddons/macros/box/feature.py b/src/PythonAddons/macros/box/feature.py index 675b84c42..d5d5e8e07 100644 --- a/src/PythonAddons/macros/box/feature.py +++ b/src/PythonAddons/macros/box/feature.py @@ -82,8 +82,9 @@ class BoxFeature(modeler.Feature): self.base.setValue( self.length, length ) self.box.setSize( height ) - # Publishing the result - self.addResult( self.box.result() ) - - - + # Publishing the result: not needed for Macro feature + #self.addResult( self.box.result() ) + + def isMacro(self): + # Box feature is macro: removes itself on the creation transaction finish + return True diff --git a/src/SketchPlugin/SketchPlugin_Sketch.cpp b/src/SketchPlugin/SketchPlugin_Sketch.cpp index 049d0e8c5..2190a6e4b 100644 --- a/src/SketchPlugin/SketchPlugin_Sketch.cpp +++ b/src/SketchPlugin/SketchPlugin_Sketch.cpp @@ -26,11 +26,14 @@ #include #include #include +#include #include #include #include +#include + #include #include @@ -243,6 +246,14 @@ void SketchPlugin_Sketch::attributeChanged(const std::string& theID) { std::shared_ptr aDir = aPlane->direction(); } } + } else if (theID == SketchPlugin_Sketch::NORM_ID() || theID == SketchPlugin_Sketch::DIRX_ID()) { + // send all sub-elements are also updated: all entities become created on different plane + static Events_ID anUpdateEvent = Events_Loop::eventByName(EVENT_OBJECT_UPDATED); + std::list aSubs = data()->reflist(SketchPlugin_Sketch::FEATURES_ID())->list(); + std::list::iterator aSub = aSubs.begin(); + for(; aSub != aSubs.end(); aSub++) { + ModelAPI_EventCreator::get()->sendUpdated(*aSub, anUpdateEvent); + } } } -- 2.39.2