X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FModel%2FModel_Update.cpp;h=561882b7c28d3157111c3cff3df98d6bbb186620;hb=0c0c2fd5b941ad2e65a0e82251dca2f796750b97;hp=2390df8268e737bb4e0038bd0df4e4e4e38f58d6;hpb=7fcf163a8a369889707c5b73eeeb2bc68a4b906e;p=modules%2Fshaper.git

diff --git a/src/Model/Model_Update.cpp b/src/Model/Model_Update.cpp
index 2390df826..561882b7c 100644
--- a/src/Model/Model_Update.cpp
+++ b/src/Model/Model_Update.cpp
@@ -7,6 +7,7 @@
 #include <Model_Update.h>
 #include <Model_Document.h>
 #include <Model_Data.h>
+#include <Model_Objects.h>
 #include <ModelAPI_Feature.h>
 #include <ModelAPI_Data.h>
 #include <ModelAPI_Document.h>
@@ -17,9 +18,13 @@
 #include <ModelAPI_AttributeSelection.h>
 #include <ModelAPI_AttributeSelectionList.h>
 #include <ModelAPI_Result.h>
+#include <ModelAPI_ResultPart.h>
 #include <ModelAPI_Validator.h>
 #include <ModelAPI_CompositeFeature.h>
 #include <ModelAPI_Session.h>
+#include <ModelAPI_Tools.h>
+#include <GeomDataAPI_Point.h>
+#include <GeomDataAPI_Point2D.h>
 #include <Events_Loop.h>
 #include <Events_LongOp.h>
 #include <Events_Error.h>
@@ -28,6 +33,7 @@
 using namespace std;
 
 Model_Update MY_UPDATER_INSTANCE;  /// the only one instance initialized on load of the library
+//#define DEB_UPDATE
 
 Model_Update::Model_Update()
 {
@@ -50,9 +56,11 @@ Model_Update::Model_Update()
   aLoop->registerListener(this, kOpStartEvent);
 
   Config_PropManager::registerProp("Model update", "automatic_rebuild", "Rebuild immediately",
-                                   Config_Prop::Bool, "false");
+                                   Config_Prop::Boolean, "false");
   myIsAutomatic =
     Config_PropManager::findProp("Model update", "automatic_rebuild")->value() == "true";
+  myIsParamUpdated = false;
+  myIsFinish = false;
 }
 
 void Model_Update::processEvent(const std::shared_ptr<Events_Message>& theMessage)
@@ -66,111 +74,241 @@ void Model_Update::processEvent(const std::shared_ptr<Events_Message>& 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;
   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<ModelAPI_ObjectUpdatedMessage> aMsg =
         std::dynamic_pointer_cast<ModelAPI_ObjectUpdatedMessage>(theMessage);
     const std::set<ObjectPtr>& anObjs = aMsg->objects();
     std::set<ObjectPtr>::const_iterator anObjIter = anObjs.cbegin();
+    bool isOnlyResults = true; // check that only results were changed: only redisplay is needed
     for(; anObjIter != anObjs.cend(); anObjIter++) {
-      myJustCreatedOrUpdated.insert(*anObjIter);
+      if (!std::dynamic_pointer_cast<ModelAPI_Result>(*anObjIter).get()) {
+        isOnlyResults = false;
+      }
+      if ((*anObjIter)->groupName() == ModelAPI_ResultParameter::group()) {
+        myIsParamUpdated = true;
+      }
       // 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
+      myJustUpdated.insert(*anObjIter);
+      #ifdef DEB_UPDATE
+      if ((*anObjIter)->data() && (*anObjIter)->data()->isValid()) {
+        std::cout<<"Add updated "<<(*anObjIter)->groupName()<<" "
+          <<(*anObjIter)->data()->name()<<std::endl;
+      }
+      #endif
     }
-    if (theMessage->eventID() == kMovedEvent)
-      return; // this event is for solver update, not here
-  } 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)
-  } else if (theMessage->eventID() == kOpFinishEvent || theMessage->eventID() == kOpAbortEvent) {
-    if (myIsAutomatic == false) { // Apply button now works as "Rebuild"
-      isAutomaticChanged = true;
-      myIsAutomatic = true;
+    // this event is for solver update, not here, do not react immediately
+    if (!isOnlyResults && !(theMessage->eventID() == kMovedEvent))
+      processOperation(false);
+  } else if (theMessage->eventID() == kOpFinishEvent || theMessage->eventID() == kOpAbortEvent ||
+      theMessage->eventID() == kOpStartEvent) {
+
+    if (!(theMessage->eventID() == kOpStartEvent)) {
+      myIsFinish = true;
+      processOperation(true, theMessage->eventID() == kOpFinishEvent);
+      myIsFinish = false;
     }
+    // remove all macros before clearing all created
+    std::set<ObjectPtr>::iterator anUpdatedIter = myWaitForFinish.begin();
+    while(anUpdatedIter != myWaitForFinish.end()) {
+      FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(*anUpdatedIter);
+      if (aFeature.get()) {
+        // remove macro on finish
+        if (aFeature->isMacro()) {
+          aFeature->document()->removeFeature(aFeature);
+          myWaitForFinish.erase(aFeature);
+        }
+        // to avoid the map update problems on "remove"
+        if (myWaitForFinish.find(aFeature) == myWaitForFinish.end()) {
+          anUpdatedIter = myWaitForFinish.begin();
+        } else {
+          anUpdatedIter++;
+        }
+      } else {
+        anUpdatedIter++;
+      }
+    }
+    // in the end of transaction everything is updated, so clear the old objects (the only one
+    // place where results are cleared)
+    myIsParamUpdated = false;
+    myJustUpdated.clear();
+    myWaitForFinish.clear();
+  }
+}
+
+void Model_Update::processOperation(const bool theTotalUpdate, const bool theFinish)
+{
+  if (theFinish) {
     // the hardcode (DBC asked): hide the sketch referenced by extrusion on apply
-    if (theMessage->eventID() == kOpFinishEvent) {
-      std::set<std::shared_ptr<ModelAPI_Object> >::iterator aFIter;
-      for(aFIter = myJustCreatedOrUpdated.begin(); aFIter != myJustCreatedOrUpdated.end(); aFIter++)
-      {
-        FeaturePtr aF = std::dynamic_pointer_cast<ModelAPI_Feature>(*aFIter);
-        if (aF && 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);
-              }
+    std::set<std::shared_ptr<ModelAPI_Object> >::iterator aFIter;
+    for(aFIter = myWaitForFinish.begin(); aFIter != myWaitForFinish.end(); aFIter++)
+    {
+      FeaturePtr aF = std::dynamic_pointer_cast<ModelAPI_Feature>(*aFIter);
+      if (aF && aF->data()->isValid() && 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) {
+              aSketchRes->setDisplayed(false);
             }
           }
         }
       }
     }
   }
+  // perform update of everything if needed
+  if (!myIsExecuted) {
+    #ifdef DEB_UPDATE
+      std::cout<<"****** Start processing"<<std::endl;
+    #endif
+    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;
+    // iterate all features in the root document to update each
+    DocumentPtr aRootDoc = ModelAPI_Session::get()->moduleDocument();
+    Model_Objects* anObjs = std::dynamic_pointer_cast<Model_Document>(aRootDoc)->objects();
+    if (!anObjs) return;
+    // two cycles: parameters are first to process
+    FeaturePtr aFeatureIter = anObjs->firstFeature();
+    std::set<FeaturePtr> aProcessedFeatures; // to avoid processing twice
+    for (; aFeatureIter.get(); aFeatureIter = anObjs->nextFeature(aFeatureIter)) {
+      if (aFeatureIter->getKind() == "Parameter")
+        updateFeature(aFeatureIter, aProcessedFeatures);
+    }
+    aFeatureIter = anObjs->firstFeature();
+    for (; aFeatureIter.get(); aFeatureIter = anObjs->nextFeature(aFeatureIter)) {
+      if (aFeatureIter->getKind() != "Parameter")
+        updateFeature(aFeatureIter, aProcessedFeatures);
+    }
 
-  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);
+    #ifdef DEB_UPDATE
+      std::cout<<"****** End processing"<<std::endl;
+    #endif
+  }
 }
 
-void Model_Update::updateInDoc(std::shared_ptr<ModelAPI_Document> theDoc)
+void Model_Update::updateFeature(FeaturePtr theFeature, std::set<FeaturePtr>& theProcessed)
 {
-  // all features one by one
-  int aNbFeatures = theDoc->size(ModelAPI_Feature::group(), true);
-  for (int aFIndex = 0; aFIndex < aNbFeatures; aFIndex++) {
-    FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(
-        theDoc->object(ModelAPI_Feature::group(), aFIndex, true));
-    if (aFeature)
-      updateFeature(aFeature);
+  // check all features this feature depended on (recursive call of updateFeature)
+  static ModelAPI_ValidatorsFactory* aFactory = ModelAPI_Session::get()->validators();
+
+  if (theProcessed.find(theFeature) != theProcessed.end())
+    return;
+  theProcessed.insert(theFeature);
+  if (theFeature->isDisabled())
+    return;
+
+  #ifdef DEB_UPDATE
+    std::cout<<"Update Feature "<<theFeature->name()<<std::endl;
+  #endif
+  CompositeFeaturePtr aCompos = std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(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 && myJustUpdated.find(theFeature) == myJustUpdated.end() && !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)
+    static Events_ID EVENT_DISP = Events_Loop::loop()->eventByName(EVENT_OBJECT_TO_REDISPLAY);
+    ModelAPI_EventCreator::get()->sendUpdated(theFeature, EVENT_DISP);
+    return;
+  }
+
+  // Update selection and parameters attributes first, before sub-features analysis (sketch plane).
+  updateArguments(theFeature);
+
+  // composite feature must be executed after sub-features execution
+  if (aCompos) {
+    // two cycles: parameters must be processed first
+    for(int a = 0; a < aCompos->numberOfSubs(); a++) {
+      FeaturePtr aSub = aCompos->subFeature(a);
+      if (aSub->getKind() == "Parameter")
+        updateFeature(aSub, theProcessed);
+    }
+    // number of subs can be changed in execution: like fillet
+    for(int a = 0; a < aCompos->numberOfSubs(); a++) {
+      FeaturePtr aSub = aCompos->subFeature(a);
+      if (aSub->getKind() != "Parameter")
+       updateFeature(aSub, theProcessed);
+    }
   }
-  // all sub-documents one by one
-  std::shared_ptr<Model_Document> aDoc = std::dynamic_pointer_cast<Model_Document>(theDoc);
-  if (aDoc) {
-    const std::set<std::string> aSubs = aDoc->subDocuments(true);
-    for(std::set<std::string>::iterator aSub = aSubs.begin(); aSub != aSubs.end(); aSub++) {
-      DocumentPtr aSubDoc = theDoc->subDocument(*aSub);
-      if (aSubDoc) {
-        updateInDoc(aSubDoc);
+  // 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) {
+    theFeature->eraseResults();
+    redisplayWithResults(theFeature, ModelAPI_StateInvalidArgument); // result also must be updated
+    return;
+  }
+
+  bool aJustUpdated = myJustUpdated.find(theFeature) != myJustUpdated.end();
+
+  if (myIsAutomatic && theFeature->data()->execState() == ModelAPI_StateMustBeUpdated)
+    aJustUpdated = true;
+
+  // On abort, undo or redo execute is not needed: results in document are updated automatically
+  // But redisplay is needed: results are updated, must be also updated in the viewer.
+  if (aJustUpdated && 
+      !std::dynamic_pointer_cast<Model_Document>(theFeature->document())->executeFeatures()) {
+    if (!theFeature->isPersistentResult()) { // not persistent must be re-executed on abort, etc.
+      ModelAPI_ExecState aState = theFeature->data()->execState();
+      if (aFactory->validate(theFeature)) {
+        executeFeature(theFeature);
+      } else {
+        theFeature->eraseResults();
+        redisplayWithResults(theFeature, ModelAPI_StateInvalidArgument); // result also must be updated
+      }
+    } else {
+      redisplayWithResults(theFeature, ModelAPI_StateNothing);
+      if (theFeature->data()->execState() == ModelAPI_StateMustBeUpdated) { // it is done (in the tree)
+        theFeature->data()->execState(ModelAPI_StateDone);
       }
     }
+    return;
+  }
+
+  // execute feature if it must be updated
+  if (theFeature->isPreviewNeeded() || myIsFinish) {
+    if (aJustUpdated) {
+      ModelAPI_ExecState aState = theFeature->data()->execState();
+      if (aFactory->validate(theFeature)) {
+        #ifdef DEB_UPDATE
+          std::cout<<"Execute Feature "<<theFeature->name()<<std::endl;
+        #endif
+        executeFeature(theFeature);
+      } else {
+        theFeature->eraseResults();
+        redisplayWithResults(theFeature, ModelAPI_StateInvalidArgument); // result also must be updated
+      }
+    }
+  } 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
+        myJustUpdated.insert(theFeature);
+    }
   }
 }
 
@@ -182,8 +320,11 @@ void Model_Update::redisplayWithResults(FeaturePtr theFeature, const ModelAPI_Ex
   std::list<std::shared_ptr<ModelAPI_Result> >::const_iterator aRIter = aResults.begin();
   for (; aRIter != aResults.cend(); aRIter++) {
     std::shared_ptr<ModelAPI_Result> aRes = *aRIter;
-    aRes->data()->execState(theState);
-    myUpdated[aRes] = true;
+    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 (theFeature->data()->updateID() > aRes->data()->updateID()) {
+      aRes->data()->setUpdateID(theFeature->data()->updateID());
+    }
     ModelAPI_EventCreator::get()->sendUpdated(aRes, EVENT_DISP);
   }
   // to redisplay "presentable" feature (for ex. distance constraint)
@@ -197,7 +338,8 @@ ModelAPI_ExecState stateByReference(ObjectPtr theTarget, const ModelAPI_ExecStat
   if (theTarget) {
     ModelAPI_ExecState aRefState = theTarget->data()->execState();
     if (aRefState == ModelAPI_StateMustBeUpdated) {
-      return ModelAPI_StateMustBeUpdated;
+      if (theCurrent == ModelAPI_StateDone)
+        return ModelAPI_StateMustBeUpdated;
     } else if (aRefState != ModelAPI_StateDone) {
       return ModelAPI_StateInvalidArgument;
     }
@@ -205,185 +347,197 @@ 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;
-
-    // composite feature must be executed after sub-features execution
-    CompositeFeaturePtr aComposite = 
-      std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(theFeature);
-    if (aComposite) {
-      int aSubsNum = aComposite->numberOfSubs();
-      for(int a = 0; a < aSubsNum; a++) {
-        if (updateFeature(aComposite->subFeature(a)))
-          aMustbeUpdated = true;
+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();
+  if (aState == ModelAPI_StateExecFailed) { // try again failed feature: issue 577
+    aState = ModelAPI_StateMustBeUpdated;
+  }
+  if (aState == ModelAPI_StateInvalidArgument) // a chance to be corrected
+    aState = ModelAPI_StateMustBeUpdated;
+  // check the parameters state
+  // Double
+  std::list<AttributePtr> aDoubles =
+    theFeature->data()->attributes(ModelAPI_AttributeDouble::typeId());
+  std::list<AttributePtr>::iterator aDoubleIter = aDoubles.begin();
+  for(; aDoubleIter != aDoubles.end(); aDoubleIter++) {
+    AttributeDoublePtr aDouble =
+      std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(*aDoubleIter);
+    if (aDouble.get() && !aDouble->text().empty()) {
+      if (myIsParamUpdated) {
+        ModelAPI_AttributeEvalMessage::send(aDouble, this);
+      }
+      if (aDouble->expressionInvalid()) {
+        aState = ModelAPI_StateInvalidArgument;
       }
     }
-    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<std::pair<std::string, std::list<ObjectPtr> > > aRefs;
-    std::shared_ptr<Model_Data> aData = 
-      std::dynamic_pointer_cast<Model_Data>(theFeature->data());
-    aData->referencesToObjects(aRefs);
-    std::list<std::pair<std::string, std::list<ObjectPtr> > >::iterator aRef = aRefs.begin();
-    for(; aRef != aRefs.end(); aRef++) {
-      std::list<ObjectPtr>::iterator aRefObj = aRef->second.begin();
-      for(; aRefObj != aRef->second.end(); aRefObj++) {
-        if (updateObject(*aRefObj)) {
-          aMustbeUpdated = true;
+  }
+  // Point
+  {
+    std::list<AttributePtr> anAttributes =
+      theFeature->data()->attributes(GeomDataAPI_Point::typeId());
+    std::list<AttributePtr>::iterator anIter = anAttributes.begin();
+    for(; anIter != anAttributes.end(); anIter++) {
+      AttributePointPtr aPointAttribute =
+        std::dynamic_pointer_cast<GeomDataAPI_Point>(*anIter);
+      if (aPointAttribute.get()) {
+        if (myIsParamUpdated) {
+          ModelAPI_AttributeEvalMessage::send(aPointAttribute, this);
         }
-        aState = stateByReference(*aRefObj, aState);
+        if ((!aPointAttribute->textX().empty() && aPointAttribute->expressionInvalid(0)) ||
+          (!aPointAttribute->textY().empty() && aPointAttribute->expressionInvalid(1)) ||
+          (!aPointAttribute->textZ().empty() && aPointAttribute->expressionInvalid(2)))
+          aState = ModelAPI_StateInvalidArgument;
       }
     }
+  }
+  // Point2D
+  {
+    std::list<AttributePtr> anAttributes =
+      theFeature->data()->attributes(GeomDataAPI_Point2D::typeId());
+    std::list<AttributePtr>::iterator anIter = anAttributes.begin();
+    for(; anIter != anAttributes.end(); anIter++) {
+      AttributePoint2DPtr aPoint2DAttribute =
+        std::dynamic_pointer_cast<GeomDataAPI_Point2D>(*anIter);
+      if (aPoint2DAttribute.get()) {
+        if (myIsParamUpdated) {
+          ModelAPI_AttributeEvalMessage::send(aPoint2DAttribute, this);
+        }
+        if ((!aPoint2DAttribute->textX().empty() && aPoint2DAttribute->expressionInvalid(0)) ||
+          (!aPoint2DAttribute->textY().empty() && aPoint2DAttribute->expressionInvalid(1)))
+          aState = ModelAPI_StateInvalidArgument;
+      }
+    }
+  }
 
-    //std::cout<<"Update feature "<<theFeature->getKind()<<" must be updated = "<<aMustbeUpdated<<std::endl;
-    // execute feature if it must be updated
-    if (aMustbeUpdated) {
-      if (std::dynamic_pointer_cast<Model_Document>(theFeature->document())->executeFeatures() ||
-          !theFeature->isPersistentResult()) {
-        if (aFactory->validate(theFeature)) {
-          if (myIsAutomatic || 
-              (myJustCreatedOrUpdated.find(theFeature) != myJustCreatedOrUpdated.end()) ||
-              !theFeature->isPersistentResult() /* execute quick, not persistent results */) 
-          {
-            if (aState == ModelAPI_StateDone) {// all referenced objects are ready to be used
-              //std::cout<<"Execute feature "<<theFeature->getKind()<<std::endl;
-              // before execution update the selection attributes if any
-              list<AttributePtr> aRefs = 
-                theFeature->data()->attributes(ModelAPI_AttributeSelection::typeId());
-              list<AttributePtr>::iterator aRefsIter = aRefs.begin();
-              for (; aRefsIter != aRefs.end(); aRefsIter++) {
-                std::shared_ptr<ModelAPI_AttributeSelection> aSel =
-                  std::dynamic_pointer_cast<ModelAPI_AttributeSelection>(*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<ModelAPI_AttributeSelectionList> aSel =
-                  std::dynamic_pointer_cast<ModelAPI_AttributeSelectionList>(*aRefsIter);
-                for(int a = aSel->size() - 1; a >= 0; a--) {
-                  std::shared_ptr<ModelAPI_AttributeSelection> aSelAttr =
-                    std::dynamic_pointer_cast<ModelAPI_AttributeSelection>(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) {
-                int aSubsNum = aComposite->numberOfSubs();
-                for(int a = 0; a < aSubsNum; 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 < aSubsNum; 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) {
-              theFeature->data()->execState(ModelAPI_StateDone);
-              try {
-                theFeature->execute();
-                if (theFeature->data()->execState() != ModelAPI_StateDone) {
-                  aState = ModelAPI_StateExecFailed;
-                }
-              } catch(...) {
-                aState = ModelAPI_StateExecFailed;
-                Events_Error::send(
-                  "Feature " + theFeature->getKind() + " has failed during the execution");
-              }
-            }
-            if (aState != ModelAPI_StateDone) {
-              theFeature->eraseResults();
-            }
-            redisplayWithResults(theFeature, aState);
-          } else { // must be updatet, but not updated yet
-            theFeature->data()->execState(ModelAPI_StateMustBeUpdated);
-            const std::list<std::shared_ptr<ModelAPI_Result> >& aResults = theFeature->results();
-            std::list<std::shared_ptr<ModelAPI_Result> >::const_iterator aRIter = aResults.begin();
-            for (; aRIter != aResults.cend(); aRIter++) {
-              std::shared_ptr<ModelAPI_Result> aRes = *aRIter;
-              aRes->data()->execState(ModelAPI_StateMustBeUpdated);
+  //if (aState == ModelAPI_StateDone) {// all referenced objects are ready to be used
+  //std::cout<<"Execute feature "<<theFeature->getKind()<<std::endl;
+  // before execution update the selection attributes if any
+  list<AttributePtr> aRefs = 
+    theFeature->data()->attributes(ModelAPI_AttributeSelection::typeId());
+  list<AttributePtr>::iterator aRefsIter = aRefs.begin();
+  for (; aRefsIter != aRefs.end(); aRefsIter++) {
+    std::shared_ptr<ModelAPI_AttributeSelection> aSel =
+      std::dynamic_pointer_cast<ModelAPI_AttributeSelection>(*aRefsIter);
+    ObjectPtr aContext = aSel->context();
+    // update argument onlt if the referenced object is changed
+    if (aContext.get() && !aContext->isDisabled() && 
+      (myJustUpdated.find(aContext) != myJustUpdated.end() ||
+      aContext->data()->updateID() > theFeature->data()->updateID())) {
+        if (aState == ModelAPI_StateDone)
+          aState = ModelAPI_StateMustBeUpdated;
+        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<ModelAPI_AttributeSelectionList> aSel =
+      std::dynamic_pointer_cast<ModelAPI_AttributeSelectionList>(*aRefsIter);
+    for(int a = aSel->size() - 1; a >= 0; a--) {
+      std::shared_ptr<ModelAPI_AttributeSelection> aSelAttr =
+        std::dynamic_pointer_cast<ModelAPI_AttributeSelection>(aSel->value(a));
+      if (aSelAttr) {
+        ObjectPtr aContext = aSelAttr->context();
+        // update argument onlt if the referenced object is changed
+        if (aContext.get() && !aContext->isDisabled() &&
+            (myJustUpdated.find(aContext) != myJustUpdated.end() ||
+             aContext->data()->updateID() > theFeature->data()->updateID())) {
+            if (aState == ModelAPI_StateDone)
+              aState = ModelAPI_StateMustBeUpdated;
+            if (!aSelAttr->update()) {
+              if (!aFactory->isNotObligatory(
+                theFeature->getKind(), theFeature->data()->id(aSel)) &&
+                aFactory->isCase(theFeature, theFeature->data()->id(aSel)))
+                aState = ModelAPI_StateInvalidArgument;
             }
-          }
-        } else {
-          theFeature->eraseResults();
-          redisplayWithResults(theFeature, ModelAPI_StateInvalidArgument); // result also must be updated
         }
-      } 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<std::shared_ptr<ModelAPI_Result> >& aResults = theFeature->results();
-      std::list<std::shared_ptr<ModelAPI_Result> >::const_iterator aRIter = aResults.begin();
-      for (; aRIter != aResults.cend(); aRIter++) {
-        if (myInitial.find(*aRIter) != myInitial.end()) {
-          aMustbeUpdated = true;
-          break;
+    }
+  }
+  // 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<std::pair<std::string, std::list<ObjectPtr> > > aRefsObj;
+  std::shared_ptr<Model_Data> aData = std::dynamic_pointer_cast<Model_Data>(theFeature->data());
+  aData->referencesToObjects(aRefsObj);
+  std::list<std::pair<std::string, std::list<ObjectPtr> > >::iterator aRef = aRefsObj.begin();
+  for(; aRef != aRefsObj.end(); aRef++) {
+    std::list<ObjectPtr>::iterator aRefObj = aRef->second.begin();
+    for(; aRefObj != aRef->second.end(); aRefObj++) {
+      // if reference is null, it may mean that this reference is to other document
+      // the does not supported by RefList: parameters may be recomputed
+      if (!aRefObj->get() && theFeature->firstResult().get() && 
+               theFeature->firstResult()->groupName() == ModelAPI_ResultParameter::group()) {
+          if (aState == ModelAPI_StateDone)
+            aState = ModelAPI_StateMustBeUpdated;
+      } else if (myJustUpdated.find(*aRefObj) != myJustUpdated.end() || 
+             (aRefObj->get() && (*aRefObj)->data()->updateID() > theFeature->data()->updateID())) {
+          if (aState == ModelAPI_StateDone)
+            aState = ModelAPI_StateMustBeUpdated;
+      }
+      aState = stateByReference(*aRefObj, aState);
+    }
+  }
+  // composites sub-elements
+  CompositeFeaturePtr aCompos = std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(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++) {
+      FeaturePtr aSub = aCompos->subFeature(a);
+      if (aSub.get() && aState == ModelAPI_StateDone) {
+        if (myJustUpdated.find(aSub) != myJustUpdated.end() || 
+              (aSub->data()->updateID() > theFeature->data()->updateID())) {
+          aState = ModelAPI_StateMustBeUpdated;
+        }
+        // also check that all results of subs were updated: composite also depends on the results
+        const std::list<std::shared_ptr<ModelAPI_Result> >& aResults = aSub->results();
+        std::list<std::shared_ptr<ModelAPI_Result> >::const_iterator aResIter = aResults.begin();
+        for(; aResIter != aResults.end(); aResIter++) {
+          if (aResIter->get() && (*aResIter)->data()->isValid() && !(*aResIter)->isDisabled() &&
+                (myJustUpdated.find(*aResIter) != myJustUpdated.end() || 
+                  ((*aResIter)->data()->updateID() > theFeature->data()->updateID()))) {
+            aState = ModelAPI_StateMustBeUpdated;
+          }
         }
       }
     }
   }
-  myUpdated[theFeature] = aMustbeUpdated;
-  return aMustbeUpdated;
+
+
+  if (aState != ModelAPI_StateDone)
+    theFeature->data()->execState(aState);
 }
 
-bool Model_Update::updateObject(std::shared_ptr<ModelAPI_Object> theObject, const bool theCyclic)
+void Model_Update::executeFeature(FeaturePtr theFeature)
 {
-  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<ModelAPI_Feature>(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<ModelAPI_Result>(theObject);
-    if (aResult) {
-      FeaturePtr aResFeature = aResult->document()->feature(aResult);
-      if (aResFeature) {
-        return updateFeature(aResFeature);
-      }
+  // execute in try-catch to avoid internal problems of the feature
+  ModelAPI_ExecState aState = ModelAPI_StateDone;
+  theFeature->data()->execState(ModelAPI_StateDone);
+  try {
+    theFeature->execute();
+    myJustUpdated.erase(theFeature);
+    if (theFeature->data()->execState() != ModelAPI_StateDone) {
+      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");
+  }
+  if (aState != ModelAPI_StateDone) {
+    theFeature->eraseResults();
   }
-  */
-  return myInitial.find(theObject) != myInitial.end();
+  theFeature->data()->setUpdateID(ModelAPI_Session::get()->transactionID());
+  redisplayWithResults(theFeature, aState);
 }