X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FPartSet%2FPartSet_TreeNodes.cpp;h=b8434fbff6d7ca2b8bec9fb89c944a258747dde3;hb=384c819a1edf4b726e3a523c1ffd2b5e6b16a4c0;hp=6c1c9dd89267c5444c17225efdbaacfc47ad1fdc;hpb=0698959843945efd4d1007b85e918e8b6db31c32;p=modules%2Fshaper.git

diff --git a/src/PartSet/PartSet_TreeNodes.cpp b/src/PartSet/PartSet_TreeNodes.cpp
index 6c1c9dd89..b8434fbff 100644
--- a/src/PartSet/PartSet_TreeNodes.cpp
+++ b/src/PartSet/PartSet_TreeNodes.cpp
@@ -19,9 +19,11 @@
 //
 
 #include "PartSet_TreeNodes.h"
+#include "PartSet_Tools.h"
 
 #include <ModuleBase_IconFactory.h>
 #include <ModuleBase_IWorkshop.h>
+#include <ModuleBase_Tools.h>
 
 #include <PartSetPlugin_Part.h>
 
@@ -32,14 +34,15 @@
 #include <ModelAPI_ResultConstruction.h>
 #include <ModelAPI_ResultPart.h>
 #include <ModelAPI_ResultBody.h>
-#include <ModelAPI_Feature.h>
 #include <ModelAPI_Tools.h>
-#include <ModelAPI_ResultCompSolid.h>
+#include <ModelAPI_ResultBody.h>
 #include <ModelAPI_CompositeFeature.h>
 #include <ModelAPI_AttributeDouble.h>
-
+#include <ModelAPI_Folder.h>
+#include <ModelAPI_AttributeReference.h>
 
 #include <QBrush>
+#include <QMap>
 
 
 #define ACTIVE_COLOR QColor(Qt::black)
@@ -109,7 +112,7 @@ QVariant PartSet_ObjectNode::data(int theColumn, int theRole) const
   case Qt::DecorationRole:
     switch (theColumn) {
     case 0:
-      switch (getVisibilityState()) {
+      switch (visibilityState()) {
       case NoneState:
         return QIcon();
       case Visible:
@@ -124,6 +127,8 @@ QVariant PartSet_ObjectNode::data(int theColumn, int theRole) const
     case 2:
       if (isCurrentFeature(myObject))
         return QIcon(":pictures/arrow.png");
+      else
+        return QIcon();
     }
   }
   return PartSet_TreeNode::data(theColumn, theRole);
@@ -131,7 +136,9 @@ QVariant PartSet_ObjectNode::data(int theColumn, int theRole) const
 
 Qt::ItemFlags PartSet_ObjectNode::flags(int theColumn) const
 {
-  if (!myObject->isDisabled()) {
+  if (myObject->isDisabled()) {
+    return (theColumn == 2) ? Qt::ItemIsSelectable : aNullFlag;
+  } else {
     DocumentPtr aDoc = myObject->document();
     SessionPtr aSession = ModelAPI_Session::get();
     if (aSession->activeDocument() == aDoc)
@@ -140,7 +147,7 @@ Qt::ItemFlags PartSet_ObjectNode::flags(int theColumn) const
   return aDefaultFlag;
 }
 
-PartSet_ObjectNode::VisibilityState PartSet_ObjectNode::getVisibilityState() const
+PartSet_ObjectNode::VisibilityState PartSet_ObjectNode::visibilityState() const
 {
   Qt::ItemFlags aFlags = flags(1);
   if (aFlags == Qt::ItemFlags())
@@ -151,18 +158,26 @@ PartSet_ObjectNode::VisibilityState PartSet_ObjectNode::getVisibilityState() con
   ResultPtr aResObj = std::dynamic_pointer_cast<ModelAPI_Result>(myObject);
   if (aResObj.get()) {
     ModuleBase_IWorkshop* aWork = workshop();
-    ResultCompSolidPtr aCompRes = std::dynamic_pointer_cast<ModelAPI_ResultCompSolid>(aResObj);
+    ResultBodyPtr aCompRes = std::dynamic_pointer_cast<ModelAPI_ResultBody>(aResObj);
     if (aCompRes.get()) {
-      VisibilityState aState = aCompRes->numberOfSubs(true) == 0 ?
+      std::list<ResultPtr> aResultsList;
+      ModelAPI_Tools::allSubs(aCompRes, aResultsList);
+      VisibilityState aState = aResultsList.size() == 0 ?
         (aWork->isVisible(aCompRes) ? Visible : Hidden) : NoneState;
-      for (int i = 0; i < aCompRes->numberOfSubs(true); i++) {
-        ResultPtr aSubRes = aCompRes->subResult(i, true);
-        VisibilityState aS = aWork->isVisible(aSubRes) ? Visible : Hidden;
-        if (aState == NoneState)
-          aState = aS;
-        else if (aState != aS) {
-          aState = SemiVisible;
-          break;
+
+      std::list<ResultPtr>::const_iterator aIt;
+      ResultBodyPtr aCompSub;
+      for (aIt = aResultsList.cbegin(); aIt != aResultsList.cend(); aIt++) {
+        ResultPtr aSubRes = (*aIt);
+        aCompSub = std::dynamic_pointer_cast<ModelAPI_ResultBody>(aSubRes);
+        if (!(aCompSub.get() && aCompSub->numberOfSubs() > 0)) {
+          VisibilityState aS = aWork->isVisible(aSubRes) ? Visible : Hidden;
+          if (aState == NoneState)
+            aState = aS;
+          else if (aState != aS) {
+            aState = SemiVisible;
+            break;
+          }
         }
       }
       return aState;
@@ -176,21 +191,209 @@ PartSet_ObjectNode::VisibilityState PartSet_ObjectNode::getVisibilityState() con
   return NoneState;
 }
 
+int PartSet_ObjectNode::numberOfSubs() const
+{
+  ResultBodyPtr aCompRes = std::dynamic_pointer_cast<ModelAPI_ResultBody>(myObject);
+  if (aCompRes.get())
+   return aCompRes->numberOfSubs(true);
+  else {
+    CompositeFeaturePtr aCompFeature =
+      std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(myObject);
+    if (aCompFeature.get() && aCompFeature->data()->isValid())
+      return aCompFeature->numberOfSubs(true);
+    else {
+      ResultFieldPtr aFieldRes = std::dynamic_pointer_cast<ModelAPI_ResultField>(myObject);
+      if (aFieldRes.get())
+        return aFieldRes->stepsSize();
+    }
+  }
+  return 0;
+}
 
-//////////////////////////////////////////////////////////////////////////////////
-PartSet_FolderNode::PartSet_FolderNode(ModuleBase_ITreeNode* theParent,
-  FolderType theType)
-  : PartSet_TreeNode(theParent), myType(theType)
+
+ObjectPtr PartSet_ObjectNode::subObject(int theId) const
 {
+  ResultBodyPtr aCompRes = std::dynamic_pointer_cast<ModelAPI_ResultBody>(myObject);
+  if (aCompRes.get())
+    return aCompRes->subResult(theId, true);
+  else {
+    CompositeFeaturePtr aCompFeature =
+      std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(myObject);
+    if (aCompFeature.get())
+      return aCompFeature->subFeature(theId, true);
+  }
+  return ObjectPtr();
 }
 
-PartSet_FolderNode::~PartSet_FolderNode()
+void PartSet_ObjectNode::update()
 {
-  while (myChildren.length() > 0) {
-    ModuleBase_ITreeNode* aNode = myChildren.last();
-    myChildren.removeAll(aNode);
-    delete aNode;
+  int aNb = numberOfSubs();
+  if (aNb > 0) {
+    ResultFieldPtr aFieldRes = std::dynamic_pointer_cast<ModelAPI_ResultField>(myObject);
+
+    // If the object is a field result then delete extra sub-objects
+    if (aFieldRes.get()) {
+      while (myChildren.size() > aNb) {
+        ModuleBase_ITreeNode* aNode = myChildren.last();
+        myChildren.removeAll(aNode);
+        delete aNode;
+      }
+    }
+    else {
+      ObjectPtr aObj;
+      ModuleBase_ITreeNode* aNode;
+      int aId = 0;
+      while (aId < myChildren.size()) {
+        aNode = myChildren.at(aId);
+        aObj = subObject(aId);
+        if (aNode->object() != aObj) {
+          myChildren.removeAll(aNode);
+          delete aNode;
+        }
+        else
+          aId++;
+      }
+    }
+
+    ModuleBase_ITreeNode* aNode;
+    ObjectPtr aBody;
+    int i;
+    for (i = 0; i < aNb; i++) {
+      aBody = subObject(i);
+      if (aBody.get()) {
+        if (i < myChildren.size()) {
+          aNode = myChildren.at(i);
+          if (aNode->object() != aBody) {
+            ((PartSet_ObjectNode*)aNode)->setObject(aBody);
+          }
+        }
+        else {
+          aNode = new PartSet_ObjectNode(aBody, this);
+          myChildren.append(aNode);
+          aNode->update();
+        }
+      }
+      else if (aFieldRes.get()) {
+        ModelAPI_ResultField::ModelAPI_FieldStep* aStep = aFieldRes->step(i);
+        if (i < myChildren.size()) {
+          PartSet_StepNode* aStepNode = static_cast<PartSet_StepNode*>(myChildren.at(i));
+          if (aStepNode->entity() != aStep) {
+            aStepNode->setEntity(aStep);
+          }
+        }
+        else {
+          aNode = new PartSet_StepNode(aStep, this);
+          myChildren.append(aNode);
+        }
+      }
+    }
+    // Delete extra objects
+    while (myChildren.size() > aNb) {
+      aNode = myChildren.takeLast();
+      delete aNode;
+    }
+    foreach(ModuleBase_ITreeNode* aNode, myChildren) {
+      aNode->update();
+    }
+  }
+  else {
+    deleteChildren();
+  }
+}
+
+QTreeNodesList PartSet_ObjectNode::objectCreated(const QObjectPtrList& theObjects)
+{
+  QTreeNodesList aResult;
+  int aNb = numberOfSubs();
+  if (aNb > 0) {
+    ModuleBase_ITreeNode* aNode;
+    ResultFieldPtr aFieldRes = std::dynamic_pointer_cast<ModelAPI_ResultField>(myObject);
+    ObjectPtr aBody;
+    int i;
+    for (i = 0; i < aNb; i++) {
+      aBody = subObject(i);
+      if (aBody.get()) {
+        if (i < myChildren.size()) {
+          aNode = myChildren.at(i);
+          if (aNode->object() != aBody) {
+            ((PartSet_ObjectNode*)aNode)->setObject(aBody);
+            aResult.append(aNode);
+          }
+        }
+        else {
+          aNode = new PartSet_ObjectNode(aBody, this);
+          myChildren.append(aNode);
+          aResult.append(aNode);
+          aNode->update();
+        }
+      }
+      else {
+        ModelAPI_ResultField::ModelAPI_FieldStep* aStep = aFieldRes->step(i);
+        if (i < myChildren.size()) {
+          PartSet_StepNode* aStepNode = static_cast<PartSet_StepNode*>(myChildren.at(i));
+          if (aStepNode->entity() != aStep) {
+            aStepNode->setEntity(aStep);
+          }
+        }
+        else {
+          aNode = new PartSet_StepNode(aStep, this);
+          myChildren.append(aNode);
+        }
+      }
+    }
+    foreach(ModuleBase_ITreeNode* aNode, myChildren) {
+      aResult.append(aNode->objectCreated(theObjects));
+    }
+  }
+  return aResult;
+}
+
+QTreeNodesList PartSet_ObjectNode::objectsDeleted(
+  const DocumentPtr& theDoc, const QString& theGroup)
+{
+  QTreeNodesList aResult;
+  int aNb = numberOfSubs();
+  if (aNb != myChildren.size()) {
+    if (aNb == 0) {
+      deleteChildren();
+      aResult.append(this);
+    }
+    else {
+      // Delete extra objects
+      bool isDeleted = false;
+      ObjectPtr aObj;
+      ModuleBase_ITreeNode* aNode;
+      int aId = 0;
+      while (aId < myChildren.size()) {
+        aNode = myChildren.at(aId);
+        aObj = subObject(aId);
+        if (aNode->object() != aObj) {
+          myChildren.removeAll(aNode);
+          delete aNode;
+          isDeleted = true;
+        }
+        else
+          aId++;
+      }
+      if (isDeleted)
+        aResult.append(this);
+      int i = 0;
+      ObjectPtr aBody;
+      foreach(ModuleBase_ITreeNode* aNode, myChildren) {
+        aBody = subObject(i);
+        ((PartSet_ObjectNode*)aNode)->setObject(aBody);
+        aResult.append(aNode->objectsDeleted(theDoc, theGroup));
+        i++;
+      }
+    }
   }
+  return aResult;
+}
+//////////////////////////////////////////////////////////////////////////////////
+PartSet_FolderNode::PartSet_FolderNode(ModuleBase_ITreeNode* theParent,
+  FolderType theType)
+  : PartSet_TreeNode(theParent), myType(theType)
+{
 }
 
 QString PartSet_FolderNode::name() const
@@ -239,6 +442,28 @@ QVariant PartSet_FolderNode::data(int theColumn, int theRole) const
       }
     }
   }
+  if ((theColumn == 2) && (theRole == Qt::DecorationRole)) {
+    if (document().get()) {
+      SessionPtr aSession = ModelAPI_Session::get();
+      if (document() != aSession->activeDocument())
+          return QIcon();
+
+      FeaturePtr aFeature = document()->currentFeature(true);
+      if (!aFeature.get()) { // There is no current feature
+        ModuleBase_ITreeNode* aLastFolder = 0;
+        foreach(ModuleBase_ITreeNode* aNode, parent()->children()) {
+          if (aNode->type() == PartSet_FolderNode::typeId())
+            aLastFolder = aNode;
+          else
+            break;
+        }
+        if (aLastFolder == this)
+          return QIcon(":pictures/arrow.png");
+        else
+          return QIcon();
+      }
+    }
+  }
   return PartSet_TreeNode::data(theColumn, theRole);
 }
 
@@ -253,6 +478,16 @@ Qt::ItemFlags PartSet_FolderNode::flags(int theColumn) const
   return aDefaultFlag;
 }
 
+ModuleBase_ITreeNode* PartSet_FolderNode::createNode(const ObjectPtr& theObj)
+{
+  //ResultCompSolidPtr aCompRes = std::dynamic_pointer_cast<ModelAPI_ResultCompSolid>(theObj);
+  //if (aCompRes.get())
+  //  return new PartSet_CompsolidNode(theObj, this);
+  ModuleBase_ITreeNode* aNode = new PartSet_ObjectNode(theObj, this);
+  aNode->update();
+  return aNode;
+}
+
 void PartSet_FolderNode::update()
 {
   DocumentPtr aDoc = document();
@@ -260,31 +495,37 @@ void PartSet_FolderNode::update()
     return;
 
   // Remove extra sub-nodes
-  QTreeNodesList aDelList;
-  foreach(ModuleBase_ITreeNode* aNode, myChildren) {
-    if (aDoc->index(aNode->object()) == -1)
-      aDelList.append(aNode);
-  }
-  foreach(ModuleBase_ITreeNode* aNode, aDelList) {
-    myChildren.removeAll(aNode);
-    delete aNode;
+  int aIndex;
+  int aId = 0;
+  while (aId < myChildren.size()) {
+    ModuleBase_ITreeNode* aNode = myChildren.at(aId);
+    aIndex = aDoc->index(aNode->object(), true);
+    if ((aIndex == -1) || (aId != aIndex)) {
+      myChildren.removeAll(aNode);
+      delete aNode;
+    } else
+      aId++;
   }
 
   // Add new nodes
   std::string aGroup = groupName();
-  int aSize = aDoc->size(aGroup);
+  int aSize = aDoc->size(aGroup, true);
   for (int i = 0; i < aSize; i++) {
-    ObjectPtr aObj = aDoc->object(aGroup, i);
+    ObjectPtr aObj = aDoc->object(aGroup, i, true);
     if (i < myChildren.size()) {
       if (myChildren.at(i)->object() != aObj) {
-        PartSet_ObjectNode* aNode = new PartSet_ObjectNode(aObj, this);
+        ModuleBase_ITreeNode* aNode = createNode(aObj);
         myChildren.insert(i, aNode);
       }
     } else {
-      PartSet_ObjectNode* aNode = new PartSet_ObjectNode(aObj, this);
+      ModuleBase_ITreeNode* aNode = createNode(aObj);
       myChildren.append(aNode);
     }
   }
+
+  foreach(ModuleBase_ITreeNode* aNode, myChildren) {
+    aNode->update();
+  }
 }
 
 std::string PartSet_FolderNode::groupName() const
@@ -312,22 +553,37 @@ QTreeNodesList PartSet_FolderNode::objectCreated(const QObjectPtrList& theObject
   std::string aName = groupName();
   DocumentPtr aDoc = document();
   int aIdx = -1;
+  QMap<int, ModuleBase_ITreeNode*> aNewNodes;
   foreach(ObjectPtr aObj, theObjects) {
     if ((aObj->document() == aDoc) && (aObj->groupName() == aName)) {
-      aIdx = aDoc->index(aObj);
+      aIdx = aDoc->index(aObj, true);
       if (aIdx != -1) {
         bool aHasObject = (aIdx < myChildren.size()) && (myChildren.at(aIdx)->object() == aObj);
         if (!aHasObject) {
-          PartSet_ObjectNode* aNode = new PartSet_ObjectNode(aObj, this);
+          ModuleBase_ITreeNode* aNode = createNode(aObj);
+          aNewNodes[aIdx] = aNode;
           aResult.append(aNode);
-          if (aIdx < myChildren.size())
-            myChildren.insert(aIdx, aNode);
-          else
-            myChildren.append(aNode);
+          aNode->update();
         }
       }
     }
   }
+  // Add nodes in correct order
+  int i;
+  for (i = 0; i < myChildren.size(); i++) {
+    if (aNewNodes.contains(i)) {
+      myChildren.insert(i, aNewNodes[i]);
+      aNewNodes.remove(i);
+    }
+  }
+  while (aNewNodes.size()) {
+    i = myChildren.size();
+    myChildren.append(aNewNodes[i]);
+    aNewNodes.remove(i);
+  }
+  foreach(ModuleBase_ITreeNode* aNode, myChildren) {
+    aResult.append(aNode->objectCreated(theObjects));
+  }
   return aResult;
 }
 
@@ -338,16 +594,28 @@ QTreeNodesList PartSet_FolderNode::objectsDeleted(const DocumentPtr& theDoc,
   QTreeNodesList aResult;
   if ((theGroup.toStdString() == groupName()) && (theDoc == aDoc)) {
     QTreeNodesList aDelList;
-    foreach(ModuleBase_ITreeNode* aNode, myChildren) {
-      if (aDoc->index(aNode->object()) == -1)
-        aDelList.append(aNode);
-    }
-    if (aDelList.size() > 0) {
-      foreach(ModuleBase_ITreeNode* aNode, aDelList) {
+    int aIndex;
+    int aId = 0;
+    bool aRemoved = false;
+    bool aToSort = false;
+    while (aId < myChildren.size()) {
+      ModuleBase_ITreeNode* aNode = myChildren.at(aId);
+      aIndex = aDoc->index(aNode->object(), true);
+      aToSort |= ((aIndex != -1) && (aId != aIndex));
+      if (aIndex == -1) {
         myChildren.removeAll(aNode);
         delete aNode;
+        aRemoved = true;
       }
+      else
+        aId++;
+    }
+    if (aRemoved)
       aResult.append(this);
+    if (aToSort)
+      sortChildren();
+    foreach(ModuleBase_ITreeNode* aNode, myChildren) {
+      aResult.append(aNode->objectsDeleted(theDoc, theGroup));
     }
   }
   return aResult;
@@ -357,39 +625,47 @@ QTreeNodesList PartSet_FolderNode::objectsDeleted(const DocumentPtr& theDoc,
 QTreeNodesList PartSet_FeatureFolderNode::objectCreated(const QObjectPtrList& theObjects)
 {
   QTreeNodesList aResult;
-  // Process all folders
-  ModuleBase_ITreeNode* aFoder = 0;
-  foreach(ModuleBase_ITreeNode* aNode, myChildren) {
-    aFoder = dynamic_cast<PartSet_FolderNode*>(aNode);
-    if (!aFoder)
-      aFoder = dynamic_cast<PartSet_FeatureFolderNode*>(aNode);
-
-    if (aFoder) { // aFolder node
-      QTreeNodesList aList = aNode->objectCreated(theObjects);
-      if (aList.size() > 0)
-        aResult.append(aList);
-    }
-  }
   // Process the root sub-objects
   DocumentPtr aDoc = document();
   int aIdx = -1;
   int aNb = numberOfFolders();
+  QMap<int, ModuleBase_ITreeNode*> aNewNodes;
   foreach(ObjectPtr aObj, theObjects) {
     if (aDoc == aObj->document()) {
-      if (aObj->groupName() == ModelAPI_Feature::group()) {
-        ModuleBase_ITreeNode* aNode = createNode(aObj);
-        aIdx = aDoc->index(aObj) + aNb;
-        bool aHasObject = (aIdx < myChildren.size()) && (myChildren.at(aIdx)->object() == aObj);
-        if (!aHasObject) {
-          if (aIdx < myChildren.size())
-            myChildren.insert(aIdx, aNode);
-          else
-            myChildren.append(aNode);
-          aResult.append(aNode);
+      if ((aObj->groupName() == ModelAPI_Feature::group()) ||
+        (aObj->groupName() == ModelAPI_Folder::group())){
+        aIdx = aDoc->index(aObj, true);
+        if (aIdx != -1) {
+          ModuleBase_ITreeNode* aNode = createNode(aObj);
+          aIdx += aNb;
+          bool aHasObject = (aIdx < myChildren.size()) && (myChildren.at(aIdx)->object() == aObj);
+          if (!aHasObject) {
+            aNewNodes[aIdx] = aNode;
+            aResult.append(aNode);
+            aNode->update();
+          }
         }
       }
     }
   }
+  // To add in correct order
+  int i;
+  for (i = 0; i < myChildren.size(); i++) {
+    if (aNewNodes.contains(i)) {
+      myChildren.insert(i, aNewNodes[i]);
+      aNewNodes.remove(i);
+    }
+  }
+  while (aNewNodes.size()) {
+    i = myChildren.size();
+    myChildren.append(aNewNodes[i]);
+    aNewNodes.remove(i);
+  }
+
+  // Update sub-folders
+  foreach(ModuleBase_ITreeNode* aNode, myChildren) {
+    aResult.append(aNode->objectCreated(theObjects));
+  }
   return aResult;
 }
 
@@ -397,6 +673,8 @@ QTreeNodesList PartSet_FeatureFolderNode::objectsDeleted(const DocumentPtr& theD
   const QString& theGroup)
 {
   QTreeNodesList aResult;
+
+  // Process sub-folders
   foreach(ModuleBase_ITreeNode* aNode, myChildren) {
     if (aNode->childrenCount() > 0) { // aFolder node
       QTreeNodesList aList = aNode->objectsDeleted(theDoc, theGroup);
@@ -404,22 +682,35 @@ QTreeNodesList PartSet_FeatureFolderNode::objectsDeleted(const DocumentPtr& theD
         aResult.append(aList);
     }
   }
+
+  // Process root
   DocumentPtr aDoc = document();
-  if ((theDoc == aDoc) && (theGroup.toStdString() == ModelAPI_Feature::group())) {
-    QTreeNodesList aDelList;
-    foreach(ModuleBase_ITreeNode* aNode, myChildren) {
+  int aNb = numberOfFolders();
+  bool isGroup = ((theGroup.toStdString() == ModelAPI_Feature::group()) ||
+    (theGroup.toStdString() == ModelAPI_Folder::group()));
+  if ((theDoc == aDoc) && isGroup) {
+    int aIndex;
+    int aId = 0;
+    bool aRemoved = false;
+    bool aToSort = false;
+    while (aId < myChildren.size()) {
+      ModuleBase_ITreeNode* aNode = myChildren.at(aId);
       if (aNode->object().get()) {
-        if (aDoc->index(aNode->object()) == -1)
-          aDelList.append(aNode);
+        aIndex = aDoc->index(aNode->object(), true);
+        aToSort |= ((aIndex != -1) && (aId != (aIndex + aNb)));
+        if (aIndex == -1) {
+          myChildren.removeAll(aNode);
+          delete aNode;
+          aRemoved = true;
+          continue;
+        }
       }
+      aId++;
     }
-    if (aDelList.size() > 0) {
-      foreach(ModuleBase_ITreeNode* aNode, aDelList) {
-        myChildren.removeAll(aNode);
-        delete aNode;
-      }
+    if (aRemoved)
       aResult.append(this);
-    }
+    if (aToSort)
+      sortChildren();
   }
   return aResult;
 }
@@ -434,7 +725,9 @@ ModuleBase_ITreeNode* PartSet_FeatureFolderNode::findParent(const DocumentPtr& t
       return aResult;
     }
   }
-  if ((theDoc == document()) && (theGroup.toStdString() == ModelAPI_Feature::group()))
+  bool isGroup = ((theGroup.toStdString() == ModelAPI_Feature::group()) ||
+    (theGroup.toStdString() == ModelAPI_Folder::group()));
+  if ((theDoc == document()) && isGroup)
     return this;
   return 0;
 }
@@ -457,13 +750,6 @@ PartSet_RootNode::PartSet_RootNode() : PartSet_FeatureFolderNode(0), myWorkshop(
   update();
 }
 
-PartSet_RootNode::~PartSet_RootNode()
-{
-  delete myParamsFolder;
-  delete myConstrFolder;
-  delete myPartsFolder;
-}
-
 
 void PartSet_RootNode::update()
 {
@@ -473,55 +759,46 @@ void PartSet_RootNode::update()
 
   // Update features content
   DocumentPtr aDoc = document();
+  int aNb = numberOfFolders();
 
   // Remove extra sub-nodes
-  QTreeNodesList aDelList;
-  foreach(ModuleBase_ITreeNode* aNode, myChildren) {
+  int aIndex;
+  int aId = 0;
+  while (aId < myChildren.size()) {
+    ModuleBase_ITreeNode* aNode = myChildren.at(aId);
     if (aNode->object().get()) {
-      if (aDoc->index(aNode->object()) == -1)
-        aDelList.append(aNode);
+      aIndex = aDoc->index(aNode->object(), true);
+      if ((aIndex == -1) || (aId != (aIndex + aNb))) {
+        myChildren.removeAll(aNode);
+        delete aNode;
+        continue;
+      }
     }
-  }
-  foreach(ModuleBase_ITreeNode* aNode, aDelList) {
-    myChildren.removeAll(aNode);
-    delete aNode;
+    aId++;
   }
 
   // Add new nodes
   std::string aGroup = ModelAPI_Feature::group();
-  int aSize = aDoc->size(aGroup);
-  int aId;
+  int aSize = aDoc->size(aGroup, true);
   FeaturePtr aFeature;
-  int aNb = numberOfFolders();
   for (int i = 0; i < aSize; i++) {
-    ObjectPtr aObj = aDoc->object(aGroup, i);
+    ObjectPtr aObj = aDoc->object(aGroup, i, true);
     aId = i + aNb; // Take into account existing folders
     if (aId < myChildren.size()) {
       if (myChildren.at(aId)->object() != aObj) {
-        aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aObj);
-        ModuleBase_ITreeNode* aNode;
-        if (aFeature->getKind() == PartSetPlugin_Part::ID())
-          aNode = new PartSet_PartRootNode(aObj, this);
-        else
-          aNode = new PartSet_ObjectNode(aObj, this);
+        ModuleBase_ITreeNode* aNode = createNode(aObj);
         myChildren.insert(aId, aNode);
       }
     } else {
-      aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aObj);
-      ModuleBase_ITreeNode* aNode;
-      if (aFeature->getKind() == PartSetPlugin_Part::ID())
-        aNode = new PartSet_PartRootNode(aObj, this);
-      else
-        aNode = new PartSet_ObjectNode(aObj, this);
+      ModuleBase_ITreeNode* aNode = createNode(aObj);
       myChildren.append(aNode);
     }
   }
   // Update sub-folders
-  ModuleBase_ITreeNode* aSubFolder = 0;
   foreach(ModuleBase_ITreeNode* aNode, myChildren) {
-    aSubFolder = dynamic_cast<PartSet_PartRootNode*>(aNode);
-    if (aSubFolder)
-      aSubFolder->update();
+    if ((aNode->type() == PartSet_ObjectFolderNode::typeId()) ||
+      (aNode->type() == PartSet_PartRootNode::typeId()))
+      aNode->update();
   }
 }
 
@@ -532,11 +809,16 @@ DocumentPtr PartSet_RootNode::document() const
 
 ModuleBase_ITreeNode* PartSet_RootNode::createNode(const ObjectPtr& theObj)
 {
+  if (theObj->groupName() == ModelAPI_Folder::group())
+    return new PartSet_ObjectFolderNode(theObj, this);
+
   FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(theObj);
   if (aFeature->getKind() == PartSetPlugin_Part::ID())
     return new PartSet_PartRootNode(theObj, this);
-  else
-    return new PartSet_ObjectNode(theObj, this);
+
+  PartSet_ObjectNode* aNode = new PartSet_ObjectNode(theObj, this);
+  aNode->update();
+  return aNode;
 }
 
 //////////////////////////////////////////////////////////////////////////////////
@@ -556,13 +838,15 @@ PartSet_PartRootNode::PartSet_PartRootNode(const ObjectPtr& theObj, ModuleBase_I
   update();
 }
 
-PartSet_PartRootNode::~PartSet_PartRootNode()
+void PartSet_PartRootNode::deleteChildren()
 {
-  delete myParamsFolder;
-  delete myConstrFolder;
-  delete myResultsFolder;
-  delete myFieldsFolder;
-  delete myGroupsFolder;
+  if (!myFieldsFolder->childrenCount()) {
+    delete myFieldsFolder;
+  }
+  if (!myGroupsFolder->childrenCount()) {
+    delete myGroupsFolder;
+  }
+  PartSet_FeatureFolderNode::deleteChildren();
 }
 
 
@@ -580,49 +864,61 @@ void PartSet_PartRootNode::update()
 
   bool aHasFields = myFieldsFolder->childrenCount() > 0;
   bool aHasGroups = myGroupsFolder->childrenCount() > 0;
-  if (aHasFields && (!myChildren.contains(myFieldsFolder))) {
-    myChildren.insert(3, myFieldsFolder);
+  if (aHasFields) {
+    if (!myChildren.contains(myFieldsFolder)) {
+      myChildren.insert(3, myFieldsFolder);
+    }
+  } else if (myChildren.contains(myFieldsFolder)) {
+    myChildren.removeAll(myFieldsFolder);
   }
-  if (aHasGroups && (!myChildren.contains(myGroupsFolder))) {
-    myChildren.insert(aHasFields ? 4 : 3, myGroupsFolder);
+  if (aHasGroups) {
+    if (!myChildren.contains(myGroupsFolder)) {
+      myChildren.insert(aHasFields ? 4 : 3, myGroupsFolder);
+    }
+  } else if (myChildren.contains(myGroupsFolder)) {
+    myChildren.removeAll(myGroupsFolder);
   }
 
   // Update features content
   int aRows = numberOfFolders();
 
   // Remove extra sub-nodes
-  QTreeNodesList aDelList;
   int aIndex = -1;
-  int aId = -1;
-  foreach(ModuleBase_ITreeNode* aNode, myChildren) {
-    aId++;
+  int aId = aRows;
+  while (aId < myChildren.size()) {
+    ModuleBase_ITreeNode* aNode = myChildren.at(aId);
     if (aNode->object().get()) {
-      aIndex = aDoc->index(aNode->object());
-      if ((aIndex == -1) || (aId != (aIndex + aRows)))
-        aDelList.append(aNode);
+      aIndex = aDoc->index(aNode->object(), true);
+      if ((aIndex == -1) || (aId != (aIndex + aRows))) {
+        myChildren.removeAll(aNode);
+        delete aNode;
+        continue;
+      }
     }
-  }
-  foreach(ModuleBase_ITreeNode* aNode, aDelList) {
-    myChildren.removeAll(aNode);
-    delete aNode;
+    aId++;
   }
 
   std::string aGroup = ModelAPI_Feature::group();
-  int aSize = aDoc->size(aGroup);
+  int aSize = aDoc->size(aGroup, true);
   FeaturePtr aFeature;
   for (int i = 0; i < aSize; i++) {
-    ObjectPtr aObj = aDoc->object(aGroup, i);
+    ObjectPtr aObj = aDoc->object(aGroup, i, true);
     aId = i + aRows; // Take into account existing folders
     if (aId < myChildren.size()) {
       if (myChildren.at(aId)->object() != aObj) {
-        ModuleBase_ITreeNode* aNode = new PartSet_ObjectNode(aObj, this);
+        ModuleBase_ITreeNode* aNode = createNode(aObj);
         myChildren.insert(aId, aNode);
       }
     } else {
-      ModuleBase_ITreeNode* aNode = new PartSet_ObjectNode(aObj, this);
+      ModuleBase_ITreeNode* aNode = createNode(aObj);
       myChildren.append(aNode);
     }
   }
+  // Update sub-folders
+  foreach(ModuleBase_ITreeNode* aNode, myChildren) {
+    if (aNode->type() == PartSet_ObjectFolderNode::typeId())
+      aNode->update();
+  }
 }
 
 DocumentPtr PartSet_PartRootNode::document() const
@@ -639,20 +935,33 @@ QVariant PartSet_PartRootNode::data(int theColumn, int theRole) const
   case 1:
     switch (theRole) {
     case Qt::DisplayRole:
+    {
+      ResultPartPtr aPartRes = getPartResult(myObject);
+      if (aPartRes.get()) {
+        if (aPartRes->partDoc().get() == NULL)
+          return QString(myObject->data()->name().c_str()) + " (Not loaded)";
+      }
       return QString(myObject->data()->name().c_str());
+    }
     case Qt::DecorationRole:
       return ModuleBase_IconFactory::get()->getIcon(myObject);
     }
   case 2:
-    if (theRole == Qt::DecorationRole)
+    if (theRole == Qt::DecorationRole) {
       if (isCurrentFeature(myObject))
         return QIcon(":pictures/arrow.png");
+      else
+        return QIcon();
+    }
   }
   return PartSet_TreeNode::data(theColumn, theRole);
 }
 
 Qt::ItemFlags PartSet_PartRootNode::flags(int theColumn) const
 {
+  if (myObject->isDisabled())
+    return (theColumn == 2) ? Qt::ItemIsSelectable : aNullFlag;
+
   SessionPtr aSession = ModelAPI_Session::get();
   DocumentPtr aActiveDoc = aSession->activeDocument();
   if ((aActiveDoc == document()) || (myObject->document() == aActiveDoc))
@@ -662,7 +971,11 @@ Qt::ItemFlags PartSet_PartRootNode::flags(int theColumn) const
 
 ModuleBase_ITreeNode* PartSet_PartRootNode::createNode(const ObjectPtr& theObj)
 {
-  return new PartSet_ObjectNode(theObj, this);
+  if (theObj->groupName() == ModelAPI_Folder::group())
+    return new PartSet_ObjectFolderNode(theObj, this);
+  PartSet_ObjectNode* aNode = new PartSet_ObjectNode(theObj, this);
+  aNode->update();
+  return aNode;
 }
 
 int PartSet_PartRootNode::numberOfFolders() const
@@ -720,3 +1033,157 @@ QTreeNodesList PartSet_PartRootNode::objectsDeleted(const DocumentPtr& theDoc,
   aResult.append(PartSet_FeatureFolderNode::objectsDeleted(theDoc, theGroup));
   return aResult;
 }
+
+//////////////////////////////////////////////////////////////////////////////////
+void PartSet_ObjectFolderNode::update()
+{
+  int aFirst = -1, aLast = -1;
+  PartSet_Tools::getFirstAndLastIndexInFolder(myObject, aFirst, aLast);
+  if ((aFirst == -1) || (aLast == -1)) {
+    deleteChildren();
+    return;
+  }
+
+  int aNbItems = aLast - aFirst + 1;
+  if (!aNbItems) {
+    deleteChildren();
+    return;
+  }
+
+  DocumentPtr aDoc = myObject->document();
+  if (aNbItems < myChildren.size()) {
+    // Delete obsolete nodes
+    int aId = 0;
+    int aNbOfFeatures = aDoc->size(ModelAPI_Feature::group(), true);
+    while (aId < myChildren.size()) {
+      ModuleBase_ITreeNode* aNode = myChildren.at(aId);
+      if ((aFirst + aId) < aNbOfFeatures) {
+        if (aNode->object() != aDoc->object(ModelAPI_Feature::group(), aFirst + aId)) {
+          myChildren.removeAll(aNode);
+          delete aNode;
+          continue;
+        }
+      }
+      else {
+        myChildren.removeAll(aNode);
+        delete aNode;
+        continue;
+      }
+      aId++;
+    }
+  }
+  if (aNbItems > myChildren.size()) {
+    // Add new nodes
+    ModuleBase_ITreeNode* aNode;
+    for (int i = 0; i < aNbItems; i++) {
+      ObjectPtr aObj = aDoc->object(ModelAPI_Feature::group(), aFirst + i);
+      if (i < myChildren.size()) {
+        if (aObj != myChildren.at(i)->object()) {
+          aNode = new PartSet_ObjectNode(aObj, this);
+          myChildren.insert(i, aNode);
+          aNode->update();
+        }
+      }
+      else {
+        aNode = new PartSet_ObjectNode(aObj, this);
+        myChildren.append(aNode);
+        aNode->update();
+      }
+    }
+  }
+}
+
+QTreeNodesList PartSet_ObjectFolderNode::objectCreated(const QObjectPtrList& theObjects)
+{
+  QTreeNodesList aResult;
+  int aFirst = -1, aLast = -1;
+  PartSet_Tools::getFirstAndLastIndexInFolder(myObject, aFirst, aLast);
+  if ((aFirst == -1) || (aLast == -1)) {
+    return aResult;
+  }
+  int aNbItems = aLast - aFirst + 1;
+  if (!aNbItems) {
+    return aResult;
+  }
+  DocumentPtr aDoc = myObject->document();
+  // Add new nodes
+  ModuleBase_ITreeNode* aNode;
+  for (int i = 0; i < aNbItems; i++) {
+    ObjectPtr aObj = aDoc->object(ModelAPI_Feature::group(), aFirst + i);
+    if (i < myChildren.size()) {
+      if (aObj != myChildren.at(i)->object()) {
+        aNode = new PartSet_ObjectNode(aObj, this);
+        myChildren.insert(i, aNode);
+        aResult.append(aNode);
+        aNode->update();
+      }
+    } else {
+      aNode = new PartSet_ObjectNode(aObj, this);
+      myChildren.append(aNode);
+      aResult.append(aNode);
+      aNode->update();
+    }
+  }
+  return aResult;
+}
+
+QTreeNodesList PartSet_ObjectFolderNode::objectsDeleted(const DocumentPtr& theDoc,
+  const QString& theGroup)
+{
+  QTreeNodesList aResult;
+  int aFirst = -1, aLast = -1;
+  PartSet_Tools::getFirstAndLastIndexInFolder(myObject, aFirst, aLast);
+  if ((aFirst == -1) || (aLast == -1)) {
+    return aResult;
+  }
+  int aNbItems = aLast - aFirst + 1;
+  if (!aNbItems) {
+    return aResult;
+  }
+  if (aNbItems >= myChildren.size()) // Nothing was deleted here
+    return aResult;
+
+  DocumentPtr aDoc = myObject->document();
+  // Delete obsolete nodes
+  bool aRemoved = false;
+  int aId = 0;
+  int aNbOfFeatures = aDoc->size(ModelAPI_Feature::group(), true);
+  while (aId < myChildren.size()) {
+    ModuleBase_ITreeNode* aNode = myChildren.at(aId);
+    if ((aFirst + aId) < aNbOfFeatures) {
+      if (aNode->object() != aDoc->object(ModelAPI_Feature::group(), aFirst + aId)) {
+        myChildren.removeAll(aNode);
+        delete aNode;
+        aRemoved = true;
+        continue;
+      }
+    }
+    else {
+      myChildren.removeAll(aNode);
+      aResult.removeAll(aNode);
+      delete aNode;
+      aRemoved = true;
+      continue;
+    }
+    aId++;
+  }
+  if (aRemoved) {
+    aResult.append(this);
+  }
+  return aResult;
+}
+
+
+
+//////////////////////////////////////////////////////////////////////////////////
+QVariant PartSet_StepNode::data(int theColumn, int theRole) const
+{
+  if ((theColumn == 1) && (theRole == Qt::DisplayRole)) {
+    ModelAPI_ResultField::ModelAPI_FieldStep* aStep =
+      dynamic_cast<ModelAPI_ResultField::ModelAPI_FieldStep*>(myEntity);
+
+    return "Step " + QString::number(aStep->id() + 1) + " " +
+      aStep->field()->textLine(aStep->id()).c_str();
+  }
+  return PartSet_TreeNode::data(theColumn, theRole);
+}