src/PartSet/PartSet_TreeNodes.cpp

   1 // Copyright (C) 2014-2017  CEA/DEN, EDF R&D
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License, or (at your option) any later version.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or
  18 // email : webmaster.salome@opencascade.com<mailto:webmaster.salome@opencascade.com>
  19 //
  20
  21 #include "PartSet_TreeNodes.h"
  22 #include "PartSet_Tools.h"
  23
  24 #include <ModuleBase_IconFactory.h>
  25 #include <ModuleBase_IWorkshop.h>
  26 #include <ModuleBase_Tools.h>
  27
  28 #include <PartSetPlugin_Part.h>
  29
  30 #include <ModelAPI_Session.h>
  31 #include <ModelAPI_ResultParameter.h>
  32 #include <ModelAPI_ResultField.h>
  33 #include <ModelAPI_ResultGroup.h>
  34 #include <ModelAPI_ResultConstruction.h>
  35 #include <ModelAPI_ResultPart.h>
  36 #include <ModelAPI_ResultBody.h>
  37 #include <ModelAPI_Tools.h>
  38 #include <ModelAPI_ResultBody.h>
  39 #include <ModelAPI_CompositeFeature.h>
  40 #include <ModelAPI_AttributeDouble.h>
  41 #include <ModelAPI_Folder.h>
  42 #include <ModelAPI_AttributeReference.h>
  43
  44 #include <QBrush>
  45 #include <QMap>
  46
  47
  48 #define ACTIVE_COLOR QColor(Qt::black)
  49 #define SELECTABLE_COLOR QColor(100, 100, 100)
  50 #define DISABLED_COLOR QColor(200, 200, 200)
  51
  52 Qt::ItemFlags aNullFlag;
  53 Qt::ItemFlags aDefaultFlag = Qt::ItemIsSelectable | Qt::ItemIsEnabled;
  54 Qt::ItemFlags aEditingFlag = Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsEditable;
  55
  56
  57 ResultPartPtr getPartResult(const ObjectPtr& theObj)
  58 {
  59   FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(theObj);
  60   if (aFeature) {
  61     ResultPtr aRes = aFeature->firstResult();
  62     if (aRes.get() && (aRes->groupName() == ModelAPI_ResultPart::group())) {
  63       ResultPartPtr aPartRes = std::dynamic_pointer_cast<ModelAPI_ResultPart>(aRes);
  64       // Use only original parts, not a placement results
  65       if (aPartRes == aPartRes->original())
  66         return aPartRes;
  67     }
  68   }
  69   return ResultPartPtr();
  70 }
  71
  72 bool isCurrentFeature(const ObjectPtr& theObj)
  73 {
  74   SessionPtr aSession = ModelAPI_Session::get();
  75   DocumentPtr aCurDoc = aSession->activeDocument();
  76   FeaturePtr aFeature = aCurDoc->currentFeature(true);
  77   return aFeature == theObj;
  78 }
  79
  80 //////////////////////////////////////////////////////////////////////////////////
  81 QVariant PartSet_TreeNode::data(int theColumn, int theRole) const
  82 {
  83   if ((theColumn == 1) && (theRole == Qt::ForegroundRole)) {
  84     Qt::ItemFlags aFlags = flags(theColumn);
  85     if (aFlags == Qt::ItemFlags())
  86       return QBrush(DISABLED_COLOR);
  87     if (!aFlags.testFlag(Qt::ItemIsEditable))
  88       return QBrush(SELECTABLE_COLOR);
  89     return ACTIVE_COLOR;
  90   }
  91   return ModuleBase_ITreeNode::data(theColumn, theRole);
  92 }
  93
  94
  95 //////////////////////////////////////////////////////////////////////////////////
  96 QVariant PartSet_ObjectNode::data(int theColumn, int theRole) const
  97 {
  98   switch (theRole) {
  99   case Qt::DisplayRole:
 100     if (theColumn == 1) {
 101       if (myObject->groupName() == ModelAPI_ResultParameter::group()) {
 102         ResultParameterPtr aParam = std::dynamic_pointer_cast<ModelAPI_ResultParameter>(myObject);
 103         AttributeDoublePtr aValueAttribute =
 104           aParam->data()->real(ModelAPI_ResultParameter::VALUE());
 105         QString aVal = QString::number(aValueAttribute->value());
 106         QString aTitle = QString(myObject->data()->name().c_str());
 107         return aTitle + " = " + aVal;
 108       }
 109       return myObject->data()->name().c_str();
 110     }
 111     break;
 112   case Qt::DecorationRole:
 113     switch (theColumn) {
 114     case 0:
 115       switch (visibilityState()) {
 116       case NoneState:
 117         return QIcon();
 118       case Visible:
 119         return QIcon(":pictures/eyeopen.png");
 120       case SemiVisible:
 121         return QIcon(":pictures/eyemiclosed.png");
 122       case Hidden:
 123         return QIcon(":pictures/eyeclosed.png");
 124       }
 125     case 1:
 126       return ModuleBase_IconFactory::get()->getIcon(myObject);
 127     case 2:
 128       if (isCurrentFeature(myObject))
 129         return QIcon(":pictures/arrow.png");
 130       else
 131         return QIcon();
 132     }
 133   }
 134   return PartSet_TreeNode::data(theColumn, theRole);
 135 }
 136
 137 Qt::ItemFlags PartSet_ObjectNode::flags(int theColumn) const
 138 {
 139   if (myObject->isDisabled()) {
 140     return (theColumn == 2) ? Qt::ItemIsSelectable : aNullFlag;
 141   } else {
 142     DocumentPtr aDoc = myObject->document();
 143     SessionPtr aSession = ModelAPI_Session::get();
 144     if (aSession->activeDocument() == aDoc)
 145       return aEditingFlag;
 146   }
 147   return aDefaultFlag;
 148 }
 149
 150 PartSet_ObjectNode::VisibilityState PartSet_ObjectNode::visibilityState() const
 151 {
 152   Qt::ItemFlags aFlags = flags(1);
 153   if (aFlags == Qt::ItemFlags())
 154     return NoneState;
 155
 156   if (myObject->groupName() == ModelAPI_ResultParameter::group())
 157     return NoneState;
 158   ResultPtr aResObj = std::dynamic_pointer_cast<ModelAPI_Result>(myObject);
 159   if (aResObj.get()) {
 160     ModuleBase_IWorkshop* aWork = workshop();
 161     ResultBodyPtr aCompRes = std::dynamic_pointer_cast<ModelAPI_ResultBody>(aResObj);
 162     if (aCompRes.get()) {
 163       std::list<ResultPtr> aResultsList;
 164       ModelAPI_Tools::allSubs(aCompRes, aResultsList);
 165       VisibilityState aState = aResultsList.size() == 0 ?
 166         (aWork->isVisible(aCompRes) ? Visible : Hidden) : NoneState;
 167
 168       std::list<ResultPtr>::const_iterator aIt;
 169       ResultBodyPtr aCompSub;
 170       for (aIt = aResultsList.cbegin(); aIt != aResultsList.cend(); aIt++) {
 171         ResultPtr aSubRes = (*aIt);
 172         aCompSub = std::dynamic_pointer_cast<ModelAPI_ResultBody>(aSubRes);
 173         if (!(aCompSub.get() && aCompSub->numberOfSubs() > 0)) {
 174           VisibilityState aS = aWork->isVisible(aSubRes) ? Visible : Hidden;
 175           if (aState == NoneState)
 176             aState = aS;
 177           else if (aState != aS) {
 178             aState = SemiVisible;
 179             break;
 180           }
 181         }
 182       }
 183       return aState;
 184     } else {
 185       if (aWork->isVisible(aResObj))
 186         return Visible;
 187       else
 188         return Hidden;
 189     }
 190   }
 191   return NoneState;
 192 }
 193
 194 int PartSet_ObjectNode::numberOfSubs() const
 195 {
 196   ResultBodyPtr aCompRes = std::dynamic_pointer_cast<ModelAPI_ResultBody>(myObject);
 197   if (aCompRes.get())
 198    return aCompRes->numberOfSubs(true);
 199   else {
 200     CompositeFeaturePtr aCompFeature =
 201       std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(myObject);
 202     if (aCompFeature.get() && aCompFeature->data()->isValid())
 203       return aCompFeature->numberOfSubs(true);
 204     else {
 205       ResultFieldPtr aFieldRes = std::dynamic_pointer_cast<ModelAPI_ResultField>(myObject);
 206       if (aFieldRes.get())
 207         return aFieldRes->stepsSize();
 208     }
 209   }
 210   return 0;
 211 }
 212
 213
 214 ObjectPtr PartSet_ObjectNode::subObject(int theId) const
 215 {
 216   ResultBodyPtr aCompRes = std::dynamic_pointer_cast<ModelAPI_ResultBody>(myObject);
 217   if (aCompRes.get())
 218     return aCompRes->subResult(theId, true);
 219   else {
 220     CompositeFeaturePtr aCompFeature =
 221       std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(myObject);
 222     if (aCompFeature.get())
 223       return aCompFeature->subFeature(theId, true);
 224   }
 225   return ObjectPtr();
 226 }
 227
 228 void PartSet_ObjectNode::update()
 229 {
 230   int aNb = numberOfSubs();
 231   if (aNb > 0) {
 232     ResultFieldPtr aFieldRes = std::dynamic_pointer_cast<ModelAPI_ResultField>(myObject);
 233
 234     // If the object is a field result then delete extra sub-objects
 235     if (aFieldRes.get()) {
 236       while (myChildren.size() > aNb) {
 237         ModuleBase_ITreeNode* aNode = myChildren.last();
 238         myChildren.removeAll(aNode);
 239         delete aNode;
 240       }
 241     }
 242     else {
 243       ObjectPtr aObj;
 244       ModuleBase_ITreeNode* aNode;
 245       int aId = 0;
 246       while (aId < myChildren.size()) {
 247         aNode = myChildren.at(aId);
 248         aObj = subObject(aId);
 249         if (aNode->object() != aObj) {
 250           myChildren.removeAll(aNode);
 251           delete aNode;
 252         }
 253         else
 254           aId++;
 255       }
 256     }
 257
 258     ModuleBase_ITreeNode* aNode;
 259     ObjectPtr aBody;
 260     int i;
 261     for (i = 0; i < aNb; i++) {
 262       aBody = subObject(i);
 263       if (aBody.get()) {
 264         if (i < myChildren.size()) {
 265           aNode = myChildren.at(i);
 266           if (aNode->object() != aBody) {
 267             ((PartSet_ObjectNode*)aNode)->setObject(aBody);
 268           }
 269         }
 270         else {
 271           aNode = new PartSet_ObjectNode(aBody, this);
 272           myChildren.append(aNode);
 273         }
 274       }
 275       else if (aFieldRes.get()) {
 276         ModelAPI_ResultField::ModelAPI_FieldStep* aStep = aFieldRes->step(i);
 277         if (i < myChildren.size()) {
 278           PartSet_StepNode* aStepNode = static_cast<PartSet_StepNode*>(myChildren.at(i));
 279           if (aStepNode->entity() != aStep) {
 280             aStepNode->setEntity(aStep);
 281           }
 282         }
 283         else {
 284           aNode = new PartSet_StepNode(aStep, this);
 285           myChildren.append(aNode);
 286         }
 287       }
 288     }
 289     // Delete extra objects
 290     while (myChildren.size() > aNb) {
 291       aNode = myChildren.takeLast();
 292       delete aNode;
 293     }
 294     foreach(ModuleBase_ITreeNode* aNode, myChildren) {
 295       aNode->update();
 296     }
 297   }
 298   else {
 299     deleteChildren();
 300   }
 301 }
 302
 303 QTreeNodesList PartSet_ObjectNode::objectCreated(const QObjectPtrList& theObjects)
 304 {
 305   QTreeNodesList aResult;
 306   int aNb = numberOfSubs();
 307   if (aNb > 0) {
 308     ModuleBase_ITreeNode* aNode;
 309     ResultFieldPtr aFieldRes = std::dynamic_pointer_cast<ModelAPI_ResultField>(myObject);
 310     ObjectPtr aBody;
 311     int i;
 312     for (i = 0; i < aNb; i++) {
 313       aBody = subObject(i);
 314       if (aBody.get()) {
 315         if (i < myChildren.size()) {
 316           aNode = myChildren.at(i);
 317           if (aNode->object() != aBody) {
 318             ((PartSet_ObjectNode*)aNode)->setObject(aBody);
 319             aResult.append(aNode);
 320           }
 321         }
 322         else {
 323           aNode = new PartSet_ObjectNode(aBody, this);
 324           myChildren.append(aNode);
 325           aResult.append(aNode);
 326           aNode->update();
 327         }
 328       }
 329       else {
 330         ModelAPI_ResultField::ModelAPI_FieldStep* aStep = aFieldRes->step(i);
 331         if (i < myChildren.size()) {
 332           PartSet_StepNode* aStepNode = static_cast<PartSet_StepNode*>(myChildren.at(i));
 333           if (aStepNode->entity() != aStep) {
 334             aStepNode->setEntity(aStep);
 335           }
 336         }
 337         else {
 338           aNode = new PartSet_StepNode(aStep, this);
 339           myChildren.append(aNode);
 340         }
 341       }
 342     }
 343     foreach(ModuleBase_ITreeNode* aNode, myChildren) {
 344       aResult.append(aNode->objectCreated(theObjects));
 345     }
 346   }
 347   return aResult;
 348 }
 349
 350 QTreeNodesList PartSet_ObjectNode::objectsDeleted(
 351   const DocumentPtr& theDoc, const QString& theGroup)
 352 {
 353   QTreeNodesList aResult;
 354   int aNb = numberOfSubs();
 355   if (aNb != myChildren.size()) {
 356     if (aNb == 0) {
 357       deleteChildren();
 358       aResult.append(this);
 359     }
 360     else {
 361       // Delete extra objects
 362       bool isDeleted = false;
 363       ObjectPtr aObj;
 364       ModuleBase_ITreeNode* aNode;
 365       int aId = 0;
 366       while (aId < myChildren.size()) {
 367         aNode = myChildren.at(aId);
 368         aObj = subObject(aId);
 369         if (aNode->object() != aObj) {
 370           myChildren.removeAll(aNode);
 371           aResult.removeAll(aNode);
 372           delete aNode;
 373           isDeleted = true;
 374         }
 375         else
 376           aId++;
 377       }
 378       if (isDeleted)
 379         aResult.append(this);
 380       int i = 0;
 381       ObjectPtr aBody;
 382       foreach(ModuleBase_ITreeNode* aNode, myChildren) {
 383         aBody = subObject(i);
 384         ((PartSet_ObjectNode*)aNode)->setObject(aBody);
 385         aResult.append(aNode->objectsDeleted(theDoc, theGroup));
 386         i++;
 387       }
 388     }
 389   }
 390   return aResult;
 391 }
 392 //////////////////////////////////////////////////////////////////////////////////
 393 PartSet_FolderNode::PartSet_FolderNode(ModuleBase_ITreeNode* theParent,
 394   FolderType theType)
 395   : PartSet_TreeNode(theParent), myType(theType)
 396 {
 397 }
 398
 399 QString PartSet_FolderNode::name() const
 400 {
 401   switch (myType) {
 402   case ParametersFolder:
 403     return QObject::tr("Parameters");
 404   case ConstructionFolder:
 405     return QObject::tr("Constructions");
 406   case PartsFolder:
 407     return QObject::tr("Parts");
 408   case ResultsFolder:
 409     return QObject::tr("Results");
 410   case FieldsFolder:
 411     return QObject::tr("Fields");
 412   case GroupsFolder:
 413     return QObject::tr("Groups");
 414   }
 415   return "NoName";
 416 }
 417
 418
 419 QVariant PartSet_FolderNode::data(int theColumn, int theRole) const
 420 {
 421   static QIcon aParamsIco(":pictures/params_folder.png");
 422   static QIcon aConstrIco(":pictures/constr_folder.png");
 423
 424   if (theColumn == 1) {
 425     switch (theRole) {
 426     case Qt::DisplayRole:
 427       return name() + QString(" (%1)").arg(childrenCount());
 428     case Qt::DecorationRole:
 429       switch (myType) {
 430       case ParametersFolder:
 431         return aParamsIco;
 432       case ConstructionFolder:
 433         return aConstrIco;
 434       case PartsFolder:
 435         return aConstrIco;
 436       case ResultsFolder:
 437         return aConstrIco;
 438       case FieldsFolder:
 439         return aConstrIco;
 440       case GroupsFolder:
 441         return aConstrIco;
 442       }
 443     }
 444   }
 445   if ((theColumn == 2) && (theRole == Qt::DecorationRole)) {
 446     if (document().get()) {
 447       SessionPtr aSession = ModelAPI_Session::get();
 448       if (document() != aSession->activeDocument())
 449           return QIcon();
 450
 451       FeaturePtr aFeature = document()->currentFeature(true);
 452       if (!aFeature.get()) { // There is no current feature
 453         ModuleBase_ITreeNode* aLastFolder = 0;
 454         foreach(ModuleBase_ITreeNode* aNode, parent()->children()) {
 455           if (aNode->type() == PartSet_FolderNode::typeId())
 456             aLastFolder = aNode;
 457           else
 458             break;
 459         }
 460         if (aLastFolder == this)
 461           return QIcon(":pictures/arrow.png");
 462         else
 463           return QIcon();
 464       }
 465     }
 466   }
 467   return PartSet_TreeNode::data(theColumn, theRole);
 468 }
 469
 470 Qt::ItemFlags PartSet_FolderNode::flags(int theColumn) const
 471 {
 472   SessionPtr aSession = ModelAPI_Session::get();
 473   DocumentPtr aActiveDoc = aSession->activeDocument();
 474   if (theColumn == 1) {
 475     if (document() == aActiveDoc)
 476       return aEditingFlag;
 477   }
 478   return aDefaultFlag;
 479 }
 480
 481 ModuleBase_ITreeNode* PartSet_FolderNode::createNode(const ObjectPtr& theObj)
 482 {
 483   //ResultCompSolidPtr aCompRes = std::dynamic_pointer_cast<ModelAPI_ResultCompSolid>(theObj);
 484   //if (aCompRes.get())
 485   //  return new PartSet_CompsolidNode(theObj, this);
 486   return new PartSet_ObjectNode(theObj, this);
 487 }
 488
 489 void PartSet_FolderNode::update()
 490 {
 491   DocumentPtr aDoc = document();
 492   if (!aDoc.get())
 493     return;
 494
 495   // Remove extra sub-nodes
 496   int aIndex;
 497   int aId = 0;
 498   while (aId < myChildren.size()) {
 499     ModuleBase_ITreeNode* aNode = myChildren.at(aId);
 500     aIndex = aDoc->index(aNode->object(), true);
 501     if ((aIndex == -1) || (aId != aIndex)) {
 502       myChildren.removeAll(aNode);
 503       delete aNode;
 504     } else
 505       aId++;
 506   }
 507
 508   // Add new nodes
 509   std::string aGroup = groupName();
 510   int aSize = aDoc->size(aGroup, true);
 511   for (int i = 0; i < aSize; i++) {
 512     ObjectPtr aObj = aDoc->object(aGroup, i, true);
 513     if (i < myChildren.size()) {
 514       if (myChildren.at(i)->object() != aObj) {
 515         ModuleBase_ITreeNode* aNode = createNode(aObj);
 516         myChildren.insert(i, aNode);
 517       }
 518     } else {
 519       ModuleBase_ITreeNode* aNode = createNode(aObj);
 520       myChildren.append(aNode);
 521     }
 522   }
 523
 524   foreach(ModuleBase_ITreeNode* aNode, myChildren) {
 525     aNode->update();
 526   }
 527 }
 528
 529 std::string PartSet_FolderNode::groupName() const
 530 {
 531   switch (myType) {
 532   case ParametersFolder:
 533     return ModelAPI_ResultParameter::group();
 534   case ConstructionFolder:
 535     return ModelAPI_ResultConstruction::group();
 536   case PartsFolder:
 537     return ModelAPI_ResultPart::group();
 538   case ResultsFolder:
 539     return ModelAPI_ResultBody::group();
 540   case FieldsFolder:
 541     return ModelAPI_ResultField::group();
 542   case GroupsFolder:
 543     return ModelAPI_ResultGroup::group();
 544   }
 545   return "";
 546 }
 547
 548 QTreeNodesList PartSet_FolderNode::objectCreated(const QObjectPtrList& theObjects)
 549 {
 550   QTreeNodesList aResult;
 551   std::string aName = groupName();
 552   DocumentPtr aDoc = document();
 553   int aIdx = -1;
 554   QMap<int, ModuleBase_ITreeNode*> aNewNodes;
 555   foreach(ObjectPtr aObj, theObjects) {
 556     if ((aObj->document() == aDoc) && (aObj->groupName() == aName)) {
 557       aIdx = aDoc->index(aObj, true);
 558       if (aIdx != -1) {
 559         bool aHasObject = (aIdx < myChildren.size()) && (myChildren.at(aIdx)->object() == aObj);
 560         if (!aHasObject) {
 561           ModuleBase_ITreeNode* aNode = createNode(aObj);
 562           aNewNodes[aIdx] = aNode;
 563           aResult.append(aNode);
 564           aNode->update();
 565         }
 566       }
 567     }
 568   }
 569   // Add nodes in correct order
 570   int i;
 571   for (i = 0; i < myChildren.size(); i++) {
 572     if (aNewNodes.contains(i)) {
 573       myChildren.insert(i, aNewNodes[i]);
 574       aNewNodes.remove(i);
 575     }
 576   }
 577   while (aNewNodes.size()) {
 578     i = myChildren.size();
 579     myChildren.append(aNewNodes[i]);
 580     aNewNodes.remove(i);
 581   }
 582   foreach(ModuleBase_ITreeNode* aNode, myChildren) {
 583     aResult.append(aNode->objectCreated(theObjects));
 584   }
 585   return aResult;
 586 }
 587
 588 QTreeNodesList PartSet_FolderNode::objectsDeleted(const DocumentPtr& theDoc,
 589   const QString& theGroup)
 590 {
 591   DocumentPtr aDoc = document();
 592   QTreeNodesList aResult;
 593   if ((theGroup.toStdString() == groupName()) && (theDoc == aDoc)) {
 594     QTreeNodesList aDelList;
 595     int aIndex;
 596     int aId = 0;
 597     bool aRemoved = false;
 598     bool aToSort = false;
 599     while (aId < myChildren.size()) {
 600       ModuleBase_ITreeNode* aNode = myChildren.at(aId);
 601       aIndex = aDoc->index(aNode->object(), true);
 602       aToSort |= ((aIndex != -1) && (aId != aIndex));
 603       if (aIndex == -1) {
 604         myChildren.removeAll(aNode);
 605         aResult.removeAll(aNode);
 606         delete aNode;
 607         aRemoved = true;
 608       }
 609       else
 610         aId++;
 611     }
 612     if (aRemoved)
 613       aResult.append(this);
 614     if (aToSort)
 615       sortChildren();
 616     foreach(ModuleBase_ITreeNode* aNode, myChildren) {
 617       aResult.append(aNode->objectsDeleted(theDoc, theGroup));
 618     }
 619   }
 620   return aResult;
 621 }
 622
 623 //////////////////////////////////////////////////////////////////////////////////
 624 QTreeNodesList PartSet_FeatureFolderNode::objectCreated(const QObjectPtrList& theObjects)
 625 {
 626   QTreeNodesList aResult;
 627   // Process the root sub-objects
 628   DocumentPtr aDoc = document();
 629   int aIdx = -1;
 630   int aNb = numberOfFolders();
 631   QMap<int, ModuleBase_ITreeNode*> aNewNodes;
 632   foreach(ObjectPtr aObj, theObjects) {
 633     if (aDoc == aObj->document()) {
 634       if ((aObj->groupName() == ModelAPI_Feature::group()) ||
 635         (aObj->groupName() == ModelAPI_Folder::group())){
 636         aIdx = aDoc->index(aObj, true);
 637         if (aIdx != -1) {
 638           ModuleBase_ITreeNode* aNode = createNode(aObj);
 639           aIdx += aNb;
 640           bool aHasObject = (aIdx < myChildren.size()) && (myChildren.at(aIdx)->object() == aObj);
 641           if (!aHasObject) {
 642             aNewNodes[aIdx] = aNode;
 643             aResult.append(aNode);
 644             aNode->update();
 645           }
 646         }
 647       }
 648     }
 649   }
 650   // To add in correct order
 651   int i;
 652   for (i = 0; i < myChildren.size(); i++) {
 653     if (aNewNodes.contains(i)) {
 654       myChildren.insert(i, aNewNodes[i]);
 655       aNewNodes.remove(i);
 656     }
 657   }
 658   while (aNewNodes.size()) {
 659     i = myChildren.size();
 660     myChildren.append(aNewNodes[i]);
 661     aNewNodes.remove(i);
 662   }
 663
 664   // Update sub-folders
 665   foreach(ModuleBase_ITreeNode* aNode, myChildren) {
 666     aResult.append(aNode->objectCreated(theObjects));
 667   }
 668   return aResult;
 669 }
 670
 671 QTreeNodesList PartSet_FeatureFolderNode::objectsDeleted(const DocumentPtr& theDoc,
 672   const QString& theGroup)
 673 {
 674   QTreeNodesList aResult;
 675
 676   // Process sub-folders
 677   foreach(ModuleBase_ITreeNode* aNode, myChildren) {
 678     if (aNode->childrenCount() > 0) { // aFolder node
 679       QTreeNodesList aList = aNode->objectsDeleted(theDoc, theGroup);
 680       if (aList.size() > 0)
 681         aResult.append(aList);
 682     }
 683   }
 684
 685   // Process root
 686   DocumentPtr aDoc = document();
 687   int aNb = numberOfFolders();
 688   bool isGroup = ((theGroup.toStdString() == ModelAPI_Feature::group()) ||
 689     (theGroup.toStdString() == ModelAPI_Folder::group()));
 690   if ((theDoc == aDoc) && isGroup) {
 691     int aIndex;
 692     int aId = 0;
 693     bool aRemoved = false;
 694     bool aToSort = false;
 695     while (aId < myChildren.size()) {
 696       ModuleBase_ITreeNode* aNode = myChildren.at(aId);
 697       if (aNode->object().get()) {
 698         aIndex = aDoc->index(aNode->object(), true);
 699         aToSort |= ((aIndex != -1) && (aId != (aIndex + aNb)));
 700         if (aIndex == -1) {
 701           myChildren.removeAll(aNode);
 702           aResult.removeAll(aNode);
 703           delete aNode;
 704           aRemoved = true;
 705           continue;
 706         }
 707       }
 708       aId++;
 709     }
 710     if (aRemoved)
 711       aResult.append(this);
 712     if (aToSort)
 713       sortChildren();
 714   }
 715   return aResult;
 716 }
 717
 718 ModuleBase_ITreeNode* PartSet_FeatureFolderNode::findParent(const DocumentPtr& theDoc,
 719   QString theGroup)
 720 {
 721   ModuleBase_ITreeNode* aResult = 0;
 722   foreach(ModuleBase_ITreeNode* aNode, myChildren) {
 723     aResult = aNode->findParent(theDoc, theGroup);
 724     if (aResult) {
 725       return aResult;
 726     }
 727   }
 728   bool isGroup = ((theGroup.toStdString() == ModelAPI_Feature::group()) ||
 729     (theGroup.toStdString() == ModelAPI_Folder::group()));
 730   if ((theDoc == document()) && isGroup)
 731     return this;
 732   return 0;
 733 }
 734
 735
 736 //////////////////////////////////////////////////////////////////////////////////
 737 PartSet_RootNode::PartSet_RootNode() : PartSet_FeatureFolderNode(0), myWorkshop(0)
 738 {
 739   SessionPtr aSession = ModelAPI_Session::get();
 740   DocumentPtr aDoc = aSession->moduleDocument();
 741
 742   myParamsFolder = new PartSet_FolderNode(this, PartSet_FolderNode::ParametersFolder);
 743   myConstrFolder = new PartSet_FolderNode(this, PartSet_FolderNode::ConstructionFolder);
 744   myPartsFolder = new PartSet_FolderNode(this, PartSet_FolderNode::PartsFolder);
 745
 746   myChildren.append(myParamsFolder);
 747   myChildren.append(myConstrFolder);
 748   myChildren.append(myPartsFolder);
 749
 750   update();
 751 }
 752
 753
 754 void PartSet_RootNode::update()
 755 {
 756   myParamsFolder->update();
 757   myConstrFolder->update();
 758   myPartsFolder->update();
 759
 760   // Update features content
 761   DocumentPtr aDoc = document();
 762   int aNb = numberOfFolders();
 763
 764   // Remove extra sub-nodes
 765   int aIndex;
 766   int aId = 0;
 767   while (aId < myChildren.size()) {
 768     ModuleBase_ITreeNode* aNode = myChildren.at(aId);
 769     if (aNode->object().get()) {
 770       aIndex = aDoc->index(aNode->object(), true);
 771       if ((aIndex == -1) || (aId != (aIndex + aNb))) {
 772         myChildren.removeAll(aNode);
 773         delete aNode;
 774         continue;
 775       }
 776     }
 777     aId++;
 778   }
 779
 780   // Add new nodes
 781   std::string aGroup = ModelAPI_Feature::group();
 782   int aSize = aDoc->size(aGroup, true);
 783   FeaturePtr aFeature;
 784   for (int i = 0; i < aSize; i++) {
 785     ObjectPtr aObj = aDoc->object(aGroup, i, true);
 786     aId = i + aNb; // Take into account existing folders
 787     if (aId < myChildren.size()) {
 788       if (myChildren.at(aId)->object() != aObj) {
 789         ModuleBase_ITreeNode* aNode = createNode(aObj);
 790         myChildren.insert(aId, aNode);
 791       }
 792     } else {
 793       ModuleBase_ITreeNode* aNode = createNode(aObj);
 794       myChildren.append(aNode);
 795     }
 796   }
 797   // Update sub-folders
 798   foreach(ModuleBase_ITreeNode* aNode, myChildren) {
 799     if ((aNode->type() == PartSet_ObjectFolderNode::typeId()) ||
 800       (aNode->type() == PartSet_PartRootNode::typeId()))
 801       aNode->update();
 802   }
 803 }
 804
 805 DocumentPtr PartSet_RootNode::document() const
 806 {
 807   return ModelAPI_Session::get()->moduleDocument();
 808 }
 809
 810 ModuleBase_ITreeNode* PartSet_RootNode::createNode(const ObjectPtr& theObj)
 811 {
 812   if (theObj->groupName() == ModelAPI_Folder::group())
 813     return new PartSet_ObjectFolderNode(theObj, this);
 814
 815   FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(theObj);
 816   if (aFeature->getKind() == PartSetPlugin_Part::ID())
 817     return new PartSet_PartRootNode(theObj, this);
 818
 819   return new PartSet_ObjectNode(theObj, this);
 820 }
 821
 822 //////////////////////////////////////////////////////////////////////////////////
 823 PartSet_PartRootNode::PartSet_PartRootNode(const ObjectPtr& theObj, ModuleBase_ITreeNode* theParent)
 824   : PartSet_FeatureFolderNode(theParent), myObject(theObj)
 825 {
 826   myParamsFolder = new PartSet_FolderNode(this, PartSet_FolderNode::ParametersFolder);
 827   myConstrFolder = new PartSet_FolderNode(this, PartSet_FolderNode::ConstructionFolder);
 828   myResultsFolder = new PartSet_FolderNode(this, PartSet_FolderNode::ResultsFolder);
 829   myFieldsFolder = new PartSet_FolderNode(this, PartSet_FolderNode::FieldsFolder);
 830   myGroupsFolder = new PartSet_FolderNode(this, PartSet_FolderNode::GroupsFolder);
 831
 832   myChildren.append(myParamsFolder);
 833   myChildren.append(myConstrFolder);
 834   myChildren.append(myResultsFolder);
 835
 836   update();
 837 }
 838
 839 void PartSet_PartRootNode::deleteChildren()
 840 {
 841   if (!myFieldsFolder->childrenCount()) {
 842     delete myFieldsFolder;
 843   }
 844   if (!myGroupsFolder->childrenCount()) {
 845     delete myGroupsFolder;
 846   }
 847   PartSet_FeatureFolderNode::deleteChildren();
 848 }
 849
 850
 851 void PartSet_PartRootNode::update()
 852 {
 853   DocumentPtr aDoc = document();
 854   if (!aDoc.get())
 855     return;
 856
 857   myParamsFolder->update();
 858   myConstrFolder->update();
 859   myResultsFolder->update();
 860   myFieldsFolder->update();
 861   myGroupsFolder->update();
 862
 863   bool aHasFields = myFieldsFolder->childrenCount() > 0;
 864   bool aHasGroups = myGroupsFolder->childrenCount() > 0;
 865   if (aHasFields && (!myChildren.contains(myFieldsFolder))) {
 866     myChildren.insert(3, myFieldsFolder);
 867   }
 868   else if (myChildren.contains(myFieldsFolder)) {
 869     myChildren.removeAll(myFieldsFolder);
 870   }
 871   if (aHasGroups && (!myChildren.contains(myGroupsFolder))) {
 872     myChildren.insert(aHasFields ? 4 : 3, myGroupsFolder);
 873   }
 874   else if (myChildren.contains(myGroupsFolder)) {
 875     myChildren.removeAll(myGroupsFolder);
 876   }
 877
 878   // Update features content
 879   int aRows = numberOfFolders();
 880
 881   // Remove extra sub-nodes
 882   int aIndex = -1;
 883   int aId = aRows;
 884   while (aId < myChildren.size()) {
 885     ModuleBase_ITreeNode* aNode = myChildren.at(aId);
 886     if (aNode->object().get()) {
 887       aIndex = aDoc->index(aNode->object(), true);
 888       if ((aIndex == -1) || (aId != (aIndex + aRows))) {
 889         myChildren.removeAll(aNode);
 890         delete aNode;
 891         continue;
 892       }
 893     }
 894     aId++;
 895   }
 896
 897   std::string aGroup = ModelAPI_Feature::group();
 898   int aSize = aDoc->size(aGroup, true);
 899   FeaturePtr aFeature;
 900   for (int i = 0; i < aSize; i++) {
 901     ObjectPtr aObj = aDoc->object(aGroup, i, true);
 902     aId = i + aRows; // Take into account existing folders
 903     if (aId < myChildren.size()) {
 904       if (myChildren.at(aId)->object() != aObj) {
 905         ModuleBase_ITreeNode* aNode = createNode(aObj);
 906         myChildren.insert(aId, aNode);
 907       }
 908     } else {
 909       ModuleBase_ITreeNode* aNode = createNode(aObj);
 910       myChildren.append(aNode);
 911     }
 912   }
 913   // Update sub-folders
 914   foreach(ModuleBase_ITreeNode* aNode, myChildren) {
 915     if (aNode->type() == PartSet_ObjectFolderNode::typeId())
 916       aNode->update();
 917   }
 918 }
 919
 920 DocumentPtr PartSet_PartRootNode::document() const
 921 {
 922   ResultPartPtr aPartRes = getPartResult(myObject);
 923   if (aPartRes.get())
 924     return aPartRes->partDoc();
 925   return DocumentPtr();
 926 }
 927
 928 QVariant PartSet_PartRootNode::data(int theColumn, int theRole) const
 929 {
 930   switch (theColumn) {
 931   case 1:
 932     switch (theRole) {
 933     case Qt::DisplayRole:
 934     {
 935       ResultPartPtr aPartRes = getPartResult(myObject);
 936       if (aPartRes.get()) {
 937         if (aPartRes->partDoc().get() == NULL)
 938           return QString(myObject->data()->name().c_str()) + " (Not loaded)";
 939       }
 940       return QString(myObject->data()->name().c_str());
 941     }
 942     case Qt::DecorationRole:
 943       return ModuleBase_IconFactory::get()->getIcon(myObject);
 944     }
 945   case 2:
 946     if (theRole == Qt::DecorationRole) {
 947       if (isCurrentFeature(myObject))
 948         return QIcon(":pictures/arrow.png");
 949       else
 950         return QIcon();
 951     }
 952   }
 953   return PartSet_TreeNode::data(theColumn, theRole);
 954 }
 955
 956 Qt::ItemFlags PartSet_PartRootNode::flags(int theColumn) const
 957 {
 958   if (myObject->isDisabled())
 959     return (theColumn == 2) ? Qt::ItemIsSelectable : aNullFlag;
 960
 961   SessionPtr aSession = ModelAPI_Session::get();
 962   DocumentPtr aActiveDoc = aSession->activeDocument();
 963   if ((aActiveDoc == document()) || (myObject->document() == aActiveDoc))
 964     return aEditingFlag;
 965   return aDefaultFlag;
 966 }
 967
 968 ModuleBase_ITreeNode* PartSet_PartRootNode::createNode(const ObjectPtr& theObj)
 969 {
 970   if (theObj->groupName() == ModelAPI_Folder::group())
 971     return new PartSet_ObjectFolderNode(theObj, this);
 972   return new PartSet_ObjectNode(theObj, this);
 973 }
 974
 975 int PartSet_PartRootNode::numberOfFolders() const
 976 {
 977   int aNb = 3;
 978   if (myFieldsFolder->childrenCount() > 0)
 979     aNb++;
 980   if (myGroupsFolder->childrenCount() > 0)
 981     aNb++;
 982   return aNb;
 983 }
 984
 985 QTreeNodesList PartSet_PartRootNode::objectCreated(const QObjectPtrList& theObjects)
 986 {
 987   QTreeNodesList aResult = PartSet_FeatureFolderNode::objectCreated(theObjects);
 988   if (!myFieldsFolder->childrenCount()) {
 989     QTreeNodesList aList = myFieldsFolder->objectCreated(theObjects);
 990     if (aList.size()) {
 991       myChildren.insert(3, myFieldsFolder);
 992       aResult.append(myFieldsFolder);
 993       aResult.append(aList);
 994     }
 995   }
 996   if (!myGroupsFolder->childrenCount()) {
 997     QTreeNodesList aList = myGroupsFolder->objectCreated(theObjects);
 998     if (aList.size()) {
 999       myChildren.insert(myFieldsFolder->childrenCount()? 4 : 3, myGroupsFolder);
1000       aResult.append(myGroupsFolder);
1001       aResult.append(aList);
1002     }
1003   }
1004   return aResult;
1005 }
1006
1007 QTreeNodesList PartSet_PartRootNode::objectsDeleted(const DocumentPtr& theDoc,
1008   const QString& theGroup)
1009 {
1010   QTreeNodesList aResult;
1011   if (myFieldsFolder->childrenCount()) {
1012     QTreeNodesList aList = myFieldsFolder->objectsDeleted(theDoc, theGroup);
1013     if (aList.size()) {
1014       aResult.append(aList);
1015       if (!myFieldsFolder->childrenCount())
1016         myChildren.removeAll(myFieldsFolder);
1017     }
1018   }
1019   if (myGroupsFolder->childrenCount()) {
1020     QTreeNodesList aList = myGroupsFolder->objectsDeleted(theDoc, theGroup);
1021     if (aList.size()) {
1022       aResult.append(aList);
1023       if (!myGroupsFolder->childrenCount())
1024         myChildren.removeAll(myGroupsFolder);
1025     }
1026   }
1027   aResult.append(PartSet_FeatureFolderNode::objectsDeleted(theDoc, theGroup));
1028   return aResult;
1029 }
1030
1031 //////////////////////////////////////////////////////////////////////////////////
1032 void PartSet_ObjectFolderNode::update()
1033 {
1034   int aFirst = -1, aLast = -1;
1035   PartSet_Tools::getFirstAndLastIndexInFolder(myObject, aFirst, aLast);
1036   if ((aFirst == -1) || (aLast == -1)) {
1037     deleteChildren();
1038     return;
1039   }
1040
1041   int aNbItems = aLast - aFirst + 1;
1042   if (!aNbItems) {
1043     deleteChildren();
1044     return;
1045   }
1046
1047   DocumentPtr aDoc = myObject->document();
1048   if (aNbItems < myChildren.size()) {
1049     // Delete obsolete nodes
1050     int aId = 0;
1051     int aNbOfFeatures = aDoc->size(ModelAPI_Feature::group(), true);
1052     while (aId < myChildren.size()) {
1053       ModuleBase_ITreeNode* aNode = myChildren.at(aId);
1054       if ((aFirst + aId) < aNbOfFeatures) {
1055         if (aNode->object() != aDoc->object(ModelAPI_Feature::group(), aFirst + aId)) {
1056           myChildren.removeAll(aNode);
1057           delete aNode;
1058           continue;
1059         }
1060       }
1061       else {
1062         myChildren.removeAll(aNode);
1063         delete aNode;
1064         continue;
1065       }
1066       aId++;
1067     }
1068   }
1069   if (aNbItems > myChildren.size()) {
1070     // Add new nodes
1071     ModuleBase_ITreeNode* aNode;
1072     for (int i = 0; i < aNbItems; i++) {
1073       ObjectPtr aObj = aDoc->object(ModelAPI_Feature::group(), aFirst + i);
1074       if (i < myChildren.size()) {
1075         if (aObj != myChildren.at(i)->object()) {
1076           aNode = new PartSet_ObjectNode(aObj, this);
1077           myChildren.insert(i, aNode);
1078         }
1079       }
1080       else {
1081         aNode = new PartSet_ObjectNode(aObj, this);
1082         myChildren.append(aNode);
1083       }
1084     }
1085   }
1086 }
1087
1088 QTreeNodesList PartSet_ObjectFolderNode::objectCreated(const QObjectPtrList& theObjects)
1089 {
1090   QTreeNodesList aResult;
1091   int aFirst = -1, aLast = -1;
1092   PartSet_Tools::getFirstAndLastIndexInFolder(myObject, aFirst, aLast);
1093   if ((aFirst == -1) || (aLast == -1)) {
1094     return aResult;
1095   }
1096   int aNbItems = aLast - aFirst + 1;
1097   if (!aNbItems) {
1098     return aResult;
1099   }
1100   DocumentPtr aDoc = myObject->document();
1101   // Add new nodes
1102   ModuleBase_ITreeNode* aNode;
1103   for (int i = 0; i < aNbItems; i++) {
1104     ObjectPtr aObj = aDoc->object(ModelAPI_Feature::group(), aFirst + i);
1105     if (i < myChildren.size()) {
1106       if (aObj != myChildren.at(i)->object()) {
1107         aNode = new PartSet_ObjectNode(aObj, this);
1108         myChildren.insert(i, aNode);
1109         aResult.append(aNode);
1110       }
1111     } else {
1112       aNode = new PartSet_ObjectNode(aObj, this);
1113       myChildren.append(aNode);
1114       aResult.append(aNode);
1115     }
1116   }
1117   return aResult;
1118 }
1119
1120 QTreeNodesList PartSet_ObjectFolderNode::objectsDeleted(const DocumentPtr& theDoc,
1121   const QString& theGroup)
1122 {
1123   QTreeNodesList aResult;
1124   int aFirst = -1, aLast = -1;
1125   PartSet_Tools::getFirstAndLastIndexInFolder(myObject, aFirst, aLast);
1126   if ((aFirst == -1) || (aLast == -1)) {
1127     return aResult;
1128   }
1129   int aNbItems = aLast - aFirst + 1;
1130   if (!aNbItems) {
1131     return aResult;
1132   }
1133   if (aNbItems >= myChildren.size()) // Nothing was deleted here
1134     return aResult;
1135
1136   DocumentPtr aDoc = myObject->document();
1137   // Delete obsolete nodes
1138   bool aRemoved = false;
1139   int aId = 0;
1140   int aNbOfFeatures = aDoc->size(ModelAPI_Feature::group(), true);
1141   while (aId < myChildren.size()) {
1142     ModuleBase_ITreeNode* aNode = myChildren.at(aId);
1143     if ((aFirst + aId) < aNbOfFeatures) {
1144       if (aNode->object() != aDoc->object(ModelAPI_Feature::group(), aFirst + aId)) {
1145         myChildren.removeAll(aNode);
1146         aResult.removeAll(aNode);
1147         delete aNode;
1148         aRemoved = true;
1149         continue;
1150       }
1151     }
1152     else {
1153       myChildren.removeAll(aNode);
1154       aResult.removeAll(aNode);
1155       delete aNode;
1156       aRemoved = true;
1157       continue;
1158     }
1159     aId++;
1160   }
1161   if (aRemoved) {
1162     aResult.append(this);
1163   }
1164   return aResult;
1165 }
1166
1167
1168
1169 //////////////////////////////////////////////////////////////////////////////////
1170 QVariant PartSet_StepNode::data(int theColumn, int theRole) const
1171 {
1172   if ((theColumn == 1) && (theRole == Qt::DisplayRole)) {
1173     ModelAPI_ResultField::ModelAPI_FieldStep* aStep =
1174       dynamic_cast<ModelAPI_ResultField::ModelAPI_FieldStep*>(myEntity);
1175
1176     return "Step " + QString::number(aStep->id() + 1) + " " +
1177       aStep->field()->textLine(aStep->id()).c_str();
1178   }
1179   return PartSet_TreeNode::data(theColumn, theRole);
1180 }