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           aNode->update();
 274         }
 275       }
 276       else if (aFieldRes.get()) {
 277         ModelAPI_ResultField::ModelAPI_FieldStep* aStep = aFieldRes->step(i);
 278         if (i < myChildren.size()) {
 279           PartSet_StepNode* aStepNode = static_cast<PartSet_StepNode*>(myChildren.at(i));
 280           if (aStepNode->entity() != aStep) {
 281             aStepNode->setEntity(aStep);
 282           }
 283         }
 284         else {
 285           aNode = new PartSet_StepNode(aStep, this);
 286           myChildren.append(aNode);
 287         }
 288       }
 289     }
 290     // Delete extra objects
 291     while (myChildren.size() > aNb) {
 292       aNode = myChildren.takeLast();
 293       delete aNode;
 294     }
 295     foreach(ModuleBase_ITreeNode* aNode, myChildren) {
 296       aNode->update();
 297     }
 298   }
 299   else {
 300     deleteChildren();
 301   }
 302 }
 303
 304 QTreeNodesList PartSet_ObjectNode::objectCreated(const QObjectPtrList& theObjects)
 305 {
 306   QTreeNodesList aResult;
 307   int aNb = numberOfSubs();
 308   if (aNb > 0) {
 309     ModuleBase_ITreeNode* aNode;
 310     ResultFieldPtr aFieldRes = std::dynamic_pointer_cast<ModelAPI_ResultField>(myObject);
 311     ObjectPtr aBody;
 312     int i;
 313     for (i = 0; i < aNb; i++) {
 314       aBody = subObject(i);
 315       if (aBody.get()) {
 316         if (i < myChildren.size()) {
 317           aNode = myChildren.at(i);
 318           if (aNode->object() != aBody) {
 319             ((PartSet_ObjectNode*)aNode)->setObject(aBody);
 320             aResult.append(aNode);
 321           }
 322         }
 323         else {
 324           aNode = new PartSet_ObjectNode(aBody, this);
 325           myChildren.append(aNode);
 326           aResult.append(aNode);
 327           aNode->update();
 328         }
 329       }
 330       else {
 331         ModelAPI_ResultField::ModelAPI_FieldStep* aStep = aFieldRes->step(i);
 332         if (i < myChildren.size()) {
 333           PartSet_StepNode* aStepNode = static_cast<PartSet_StepNode*>(myChildren.at(i));
 334           if (aStepNode->entity() != aStep) {
 335             aStepNode->setEntity(aStep);
 336           }
 337         }
 338         else {
 339           aNode = new PartSet_StepNode(aStep, this);
 340           myChildren.append(aNode);
 341         }
 342       }
 343     }
 344     foreach(ModuleBase_ITreeNode* aNode, myChildren) {
 345       aResult.append(aNode->objectCreated(theObjects));
 346     }
 347   }
 348   return aResult;
 349 }
 350
 351 QTreeNodesList PartSet_ObjectNode::objectsDeleted(
 352   const DocumentPtr& theDoc, const QString& theGroup)
 353 {
 354   QTreeNodesList aResult;
 355   int aNb = numberOfSubs();
 356   if (aNb != myChildren.size()) {
 357     if (aNb == 0) {
 358       deleteChildren();
 359       aResult.append(this);
 360     }
 361     else {
 362       // Delete extra objects
 363       bool isDeleted = false;
 364       ObjectPtr aObj;
 365       ModuleBase_ITreeNode* aNode;
 366       int aId = 0;
 367       while (aId < myChildren.size()) {
 368         aNode = myChildren.at(aId);
 369         aObj = subObject(aId);
 370         if (aNode->object() != aObj) {
 371           myChildren.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   ModuleBase_ITreeNode* aNode = new PartSet_ObjectNode(theObj, this);
 487   aNode->update();
 488   return aNode;
 489 }
 490
 491 void PartSet_FolderNode::update()
 492 {
 493   DocumentPtr aDoc = document();
 494   if (!aDoc.get())
 495     return;
 496
 497   // Remove extra sub-nodes
 498   int aIndex;
 499   int aId = 0;
 500   while (aId < myChildren.size()) {
 501     ModuleBase_ITreeNode* aNode = myChildren.at(aId);
 502     aIndex = aDoc->index(aNode->object(), true);
 503     if ((aIndex == -1) || (aId != aIndex)) {
 504       myChildren.removeAll(aNode);
 505       delete aNode;
 506     } else
 507       aId++;
 508   }
 509
 510   // Add new nodes
 511   std::string aGroup = groupName();
 512   int aSize = aDoc->size(aGroup, true);
 513   for (int i = 0; i < aSize; i++) {
 514     ObjectPtr aObj = aDoc->object(aGroup, i, true);
 515     if (i < myChildren.size()) {
 516       if (myChildren.at(i)->object() != aObj) {
 517         ModuleBase_ITreeNode* aNode = createNode(aObj);
 518         myChildren.insert(i, aNode);
 519       }
 520     } else {
 521       ModuleBase_ITreeNode* aNode = createNode(aObj);
 522       myChildren.append(aNode);
 523     }
 524   }
 525
 526   foreach(ModuleBase_ITreeNode* aNode, myChildren) {
 527     aNode->update();
 528   }
 529 }
 530
 531 std::string PartSet_FolderNode::groupName() const
 532 {
 533   switch (myType) {
 534   case ParametersFolder:
 535     return ModelAPI_ResultParameter::group();
 536   case ConstructionFolder:
 537     return ModelAPI_ResultConstruction::group();
 538   case PartsFolder:
 539     return ModelAPI_ResultPart::group();
 540   case ResultsFolder:
 541     return ModelAPI_ResultBody::group();
 542   case FieldsFolder:
 543     return ModelAPI_ResultField::group();
 544   case GroupsFolder:
 545     return ModelAPI_ResultGroup::group();
 546   }
 547   return "";
 548 }
 549
 550 QTreeNodesList PartSet_FolderNode::objectCreated(const QObjectPtrList& theObjects)
 551 {
 552   QTreeNodesList aResult;
 553   std::string aName = groupName();
 554   DocumentPtr aDoc = document();
 555   int aIdx = -1;
 556   QMap<int, ModuleBase_ITreeNode*> aNewNodes;
 557   foreach(ObjectPtr aObj, theObjects) {
 558     if ((aObj->document() == aDoc) && (aObj->groupName() == aName)) {
 559       aIdx = aDoc->index(aObj, true);
 560       if (aIdx != -1) {
 561         bool aHasObject = (aIdx < myChildren.size()) && (myChildren.at(aIdx)->object() == aObj);
 562         if (!aHasObject) {
 563           ModuleBase_ITreeNode* aNode = createNode(aObj);
 564           aNewNodes[aIdx] = aNode;
 565           aResult.append(aNode);
 566           aNode->update();
 567         }
 568       }
 569     }
 570   }
 571   // Add nodes in correct order
 572   if (aNewNodes.size() > 0) {
 573     int i;
 574     for (i = 0; i < myChildren.size(); i++) {
 575       if (aNewNodes.contains(i)) {
 576         myChildren.insert(i, aNewNodes[i]);
 577         aNewNodes.remove(i);
 578       }
 579     }
 580     while (aNewNodes.size()) {
 581       i = myChildren.size();
 582       myChildren.append(aNewNodes[i]);
 583       aNewNodes.remove(i);
 584     }
 585   }
 586   foreach(ModuleBase_ITreeNode* aNode, myChildren) {
 587     aResult.append(aNode->objectCreated(theObjects));
 588   }
 589   return aResult;
 590 }
 591
 592 QTreeNodesList PartSet_FolderNode::objectsDeleted(const DocumentPtr& theDoc,
 593   const QString& theGroup)
 594 {
 595   DocumentPtr aDoc = document();
 596   QTreeNodesList aResult;
 597   if ((theGroup.toStdString() == groupName()) && (theDoc == aDoc)) {
 598     QTreeNodesList aDelList;
 599     int aIndex;
 600     int aId = 0;
 601     bool aRemoved = false;
 602     bool aToSort = false;
 603     while (aId < myChildren.size()) {
 604       ModuleBase_ITreeNode* aNode = myChildren.at(aId);
 605       aIndex = aDoc->index(aNode->object(), true);
 606       aToSort |= ((aIndex != -1) && (aId != aIndex));
 607       if (aIndex == -1) {
 608         myChildren.removeAll(aNode);
 609         delete aNode;
 610         aRemoved = true;
 611       }
 612       else
 613         aId++;
 614     }
 615     if (aRemoved)
 616       aResult.append(this);
 617     if (aToSort)
 618       sortChildren();
 619     foreach(ModuleBase_ITreeNode* aNode, myChildren) {
 620       aResult.append(aNode->objectsDeleted(theDoc, theGroup));
 621     }
 622   }
 623   return aResult;
 624 }
 625
 626 //////////////////////////////////////////////////////////////////////////////////
 627 QTreeNodesList PartSet_FeatureFolderNode::objectCreated(const QObjectPtrList& theObjects)
 628 {
 629   QTreeNodesList aResult;
 630   // Process the root sub-objects
 631   DocumentPtr aDoc = document();
 632   int aIdx = -1;
 633   int aNb = numberOfFolders();
 634   QMap<int, ModuleBase_ITreeNode*> aNewNodes;
 635   foreach(ObjectPtr aObj, theObjects) {
 636     if (aDoc == aObj->document()) {
 637       if ((aObj->groupName() == ModelAPI_Feature::group()) ||
 638         (aObj->groupName() == ModelAPI_Folder::group())){
 639         aIdx = aDoc->index(aObj, true);
 640         if (aIdx != -1) {
 641           ModuleBase_ITreeNode* aNode = createNode(aObj);
 642           aIdx += aNb;
 643           bool aHasObject = (aIdx < myChildren.size()) && (myChildren.at(aIdx)->object() == aObj);
 644           if (!aHasObject) {
 645             aNewNodes[aIdx] = aNode;
 646             aResult.append(aNode);
 647             aNode->update();
 648           }
 649         }
 650       }
 651     }
 652   }
 653   // To add in correct order
 654   if (aNewNodes.size() > 0) {
 655     int i;
 656     for (i = 0; i < myChildren.size(); i++) {
 657       if (aNewNodes.contains(i)) {
 658         myChildren.insert(i, aNewNodes[i]);
 659         aNewNodes.remove(i);
 660       }
 661     }
 662     while (aNewNodes.size()) {
 663       i = myChildren.size();
 664       if (aNewNodes.contains(i)) {
 665         myChildren.append(aNewNodes[i]);
 666         aNewNodes.remove(i);
 667       }
 668     }
 669   }
 670   // Update sub-folders
 671   foreach(ModuleBase_ITreeNode* aNode, myChildren) {
 672     aResult.append(aNode->objectCreated(theObjects));
 673   }
 674   return aResult;
 675 }
 676
 677 QTreeNodesList PartSet_FeatureFolderNode::objectsDeleted(const DocumentPtr& theDoc,
 678   const QString& theGroup)
 679 {
 680   QTreeNodesList aResult;
 681
 682   // Process sub-folders
 683   foreach(ModuleBase_ITreeNode* aNode, myChildren) {
 684     if (aNode->childrenCount() > 0) { // aFolder node
 685       QTreeNodesList aList = aNode->objectsDeleted(theDoc, theGroup);
 686       if (aList.size() > 0)
 687         aResult.append(aList);
 688     }
 689   }
 690
 691   // Process root
 692   DocumentPtr aDoc = document();
 693   int aNb = numberOfFolders();
 694   bool isGroup = ((theGroup.toStdString() == ModelAPI_Feature::group()) ||
 695     (theGroup.toStdString() == ModelAPI_Folder::group()));
 696   if ((theDoc == aDoc) && isGroup) {
 697     int aIndex;
 698     int aId = 0;
 699     bool aRemoved = false;
 700     bool aToSort = false;
 701     while (aId < myChildren.size()) {
 702       ModuleBase_ITreeNode* aNode = myChildren.at(aId);
 703       if (aNode->object().get()) {
 704         aIndex = aDoc->index(aNode->object(), true);
 705         aToSort |= ((aIndex != -1) && (aId != (aIndex + aNb)));
 706         if (aIndex == -1) {
 707           myChildren.removeAll(aNode);
 708           delete aNode;
 709           aRemoved = true;
 710           continue;
 711         }
 712       }
 713       aId++;
 714     }
 715     if (aRemoved)
 716       aResult.append(this);
 717     if (aToSort)
 718       sortChildren();
 719   }
 720   return aResult;
 721 }
 722
 723 ModuleBase_ITreeNode* PartSet_FeatureFolderNode::findParent(const DocumentPtr& theDoc,
 724   QString theGroup)
 725 {
 726   ModuleBase_ITreeNode* aResult = 0;
 727   foreach(ModuleBase_ITreeNode* aNode, myChildren) {
 728     aResult = aNode->findParent(theDoc, theGroup);
 729     if (aResult) {
 730       return aResult;
 731     }
 732   }
 733   bool isGroup = ((theGroup.toStdString() == ModelAPI_Feature::group()) ||
 734     (theGroup.toStdString() == ModelAPI_Folder::group()));
 735   if ((theDoc == document()) && isGroup)
 736     return this;
 737   return 0;
 738 }
 739
 740
 741 //////////////////////////////////////////////////////////////////////////////////
 742 PartSet_RootNode::PartSet_RootNode() : PartSet_FeatureFolderNode(0), myWorkshop(0)
 743 {
 744   SessionPtr aSession = ModelAPI_Session::get();
 745   DocumentPtr aDoc = aSession->moduleDocument();
 746
 747   myParamsFolder = new PartSet_FolderNode(this, PartSet_FolderNode::ParametersFolder);
 748   myConstrFolder = new PartSet_FolderNode(this, PartSet_FolderNode::ConstructionFolder);
 749   myPartsFolder = new PartSet_FolderNode(this, PartSet_FolderNode::PartsFolder);
 750
 751   myChildren.append(myParamsFolder);
 752   myChildren.append(myConstrFolder);
 753   myChildren.append(myPartsFolder);
 754
 755   update();
 756 }
 757
 758
 759 void PartSet_RootNode::update()
 760 {
 761   myParamsFolder->update();
 762   myConstrFolder->update();
 763   myPartsFolder->update();
 764
 765   // Update features content
 766   DocumentPtr aDoc = document();
 767   int aNb = numberOfFolders();
 768
 769   // Remove extra sub-nodes
 770   int aIndex;
 771   int aId = 0;
 772   while (aId < myChildren.size()) {
 773     ModuleBase_ITreeNode* aNode = myChildren.at(aId);
 774     if (aNode->object().get()) {
 775       aIndex = aDoc->index(aNode->object(), true);
 776       if ((aIndex == -1) || (aId != (aIndex + aNb))) {
 777         myChildren.removeAll(aNode);
 778         delete aNode;
 779         continue;
 780       }
 781     }
 782     aId++;
 783   }
 784
 785   // Add new nodes
 786   std::string aGroup = ModelAPI_Feature::group();
 787   int aSize = aDoc->size(aGroup, true);
 788   FeaturePtr aFeature;
 789   for (int i = 0; i < aSize; i++) {
 790     ObjectPtr aObj = aDoc->object(aGroup, i, true);
 791     aId = i + aNb; // Take into account existing folders
 792     if (aId < myChildren.size()) {
 793       if (myChildren.at(aId)->object() != aObj) {
 794         ModuleBase_ITreeNode* aNode = createNode(aObj);
 795         myChildren.insert(aId, aNode);
 796       }
 797     } else {
 798       ModuleBase_ITreeNode* aNode = createNode(aObj);
 799       myChildren.append(aNode);
 800     }
 801   }
 802   // Update sub-folders
 803   foreach(ModuleBase_ITreeNode* aNode, myChildren) {
 804     if ((aNode->type() == PartSet_ObjectFolderNode::typeId()) ||
 805       (aNode->type() == PartSet_PartRootNode::typeId()))
 806       aNode->update();
 807   }
 808 }
 809
 810 DocumentPtr PartSet_RootNode::document() const
 811 {
 812   return ModelAPI_Session::get()->moduleDocument();
 813 }
 814
 815 ModuleBase_ITreeNode* PartSet_RootNode::createNode(const ObjectPtr& theObj)
 816 {
 817   if (theObj->groupName() == ModelAPI_Folder::group())
 818     return new PartSet_ObjectFolderNode(theObj, this);
 819
 820   FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(theObj);
 821   if (aFeature->getKind() == PartSetPlugin_Part::ID())
 822     return new PartSet_PartRootNode(theObj, this);
 823
 824   PartSet_ObjectNode* aNode = new PartSet_ObjectNode(theObj, this);
 825   aNode->update();
 826   return aNode;
 827 }
 828
 829 //////////////////////////////////////////////////////////////////////////////////
 830 PartSet_PartRootNode::PartSet_PartRootNode(const ObjectPtr& theObj, ModuleBase_ITreeNode* theParent)
 831   : PartSet_FeatureFolderNode(theParent), myObject(theObj)
 832 {
 833   myParamsFolder = new PartSet_FolderNode(this, PartSet_FolderNode::ParametersFolder);
 834   myConstrFolder = new PartSet_FolderNode(this, PartSet_FolderNode::ConstructionFolder);
 835   myResultsFolder = new PartSet_FolderNode(this, PartSet_FolderNode::ResultsFolder);
 836   myFieldsFolder = new PartSet_FolderNode(this, PartSet_FolderNode::FieldsFolder);
 837   myGroupsFolder = new PartSet_FolderNode(this, PartSet_FolderNode::GroupsFolder);
 838
 839   myChildren.append(myParamsFolder);
 840   myChildren.append(myConstrFolder);
 841   myChildren.append(myResultsFolder);
 842
 843   update();
 844 }
 845
 846 void PartSet_PartRootNode::deleteChildren()
 847 {
 848   if (!myFieldsFolder->childrenCount()) {
 849     delete myFieldsFolder;
 850   }
 851   if (!myGroupsFolder->childrenCount()) {
 852     delete myGroupsFolder;
 853   }
 854   PartSet_FeatureFolderNode::deleteChildren();
 855 }
 856
 857
 858 void PartSet_PartRootNode::update()
 859 {
 860   DocumentPtr aDoc = document();
 861   if (!aDoc.get())
 862     return;
 863
 864   myParamsFolder->update();
 865   myConstrFolder->update();
 866   myResultsFolder->update();
 867   myFieldsFolder->update();
 868   myGroupsFolder->update();
 869
 870   bool aHasFields = myFieldsFolder->childrenCount() > 0;
 871   bool aHasGroups = myGroupsFolder->childrenCount() > 0;
 872   if (aHasFields) {
 873     if (!myChildren.contains(myFieldsFolder)) {
 874       myChildren.insert(3, myFieldsFolder);
 875     }
 876   } else if (myChildren.contains(myFieldsFolder)) {
 877     myChildren.removeAll(myFieldsFolder);
 878   }
 879   if (aHasGroups) {
 880     if (!myChildren.contains(myGroupsFolder)) {
 881       myChildren.insert(aHasFields ? 4 : 3, myGroupsFolder);
 882     }
 883   } else if (myChildren.contains(myGroupsFolder)) {
 884     myChildren.removeAll(myGroupsFolder);
 885   }
 886
 887   // Update features content
 888   int aRows = numberOfFolders();
 889
 890   // Remove extra sub-nodes
 891   int aIndex = -1;
 892   int aId = aRows;
 893   QMap<int, ModuleBase_ITreeNode*> aExistingNodes;
 894   while (aId < myChildren.size()) {
 895     ModuleBase_ITreeNode* aNode = myChildren.at(aId);
 896     if (aNode->object().get()) {
 897       aIndex = aDoc->index(aNode->object(), true);
 898       if ((aIndex == -1) || (aId != (aIndex + aRows))) {
 899         myChildren.removeAll(aNode);
 900         if (aIndex == -1)
 901           delete aNode;
 902         else
 903           aExistingNodes[aIndex + aRows] = aNode;
 904         continue;
 905       }
 906     }
 907     aId++;
 908   }
 909
 910   std::string aGroup = ModelAPI_Feature::group();
 911   int aSize = aDoc->size(aGroup, true);
 912   FeaturePtr aFeature;
 913   for (int i = 0; i < aSize; i++) {
 914     ObjectPtr aObj = aDoc->object(aGroup, i, true);
 915     aId = i + aRows; // Take into account existing folders
 916     if (aId < myChildren.size()) {
 917       if (myChildren.at(aId)->object() != aObj) {
 918         if (aExistingNodes.contains(aId)) {
 919           myChildren.insert(aId, aExistingNodes[aId]);
 920           aExistingNodes.remove(aId);
 921         }
 922         else {
 923           myChildren.insert(aId, createNode(aObj));
 924         }
 925       }
 926     } else {
 927       if (aExistingNodes.contains(myChildren.size()))
 928         myChildren.append(aExistingNodes[myChildren.size()]);
 929       else
 930         myChildren.append(createNode(aObj));
 931     }
 932   }
 933   // Update sub-folders
 934   foreach(ModuleBase_ITreeNode* aNode, myChildren) {
 935     if (aNode->type() == PartSet_ObjectFolderNode::typeId())
 936       aNode->update();
 937   }
 938 }
 939
 940 DocumentPtr PartSet_PartRootNode::document() const
 941 {
 942   ResultPartPtr aPartRes = getPartResult(myObject);
 943   if (aPartRes.get())
 944     return aPartRes->partDoc();
 945   return DocumentPtr();
 946 }
 947
 948 QVariant PartSet_PartRootNode::data(int theColumn, int theRole) const
 949 {
 950   switch (theColumn) {
 951   case 1:
 952     switch (theRole) {
 953     case Qt::DisplayRole:
 954     {
 955       ResultPartPtr aPartRes = getPartResult(myObject);
 956       if (aPartRes.get()) {
 957         if (aPartRes->partDoc().get() == NULL)
 958           return QString(myObject->data()->name().c_str()) + " (Not loaded)";
 959       }
 960       return QString(myObject->data()->name().c_str());
 961     }
 962     case Qt::DecorationRole:
 963       return ModuleBase_IconFactory::get()->getIcon(myObject);
 964     }
 965   case 2:
 966     if (theRole == Qt::DecorationRole) {
 967       if (isCurrentFeature(myObject))
 968         return QIcon(":pictures/arrow.png");
 969       else
 970         return QIcon();
 971     }
 972   }
 973   return PartSet_TreeNode::data(theColumn, theRole);
 974 }
 975
 976 Qt::ItemFlags PartSet_PartRootNode::flags(int theColumn) const
 977 {
 978   if (myObject->isDisabled())
 979     return (theColumn == 2) ? Qt::ItemIsSelectable : aNullFlag;
 980
 981   SessionPtr aSession = ModelAPI_Session::get();
 982   DocumentPtr aActiveDoc = aSession->activeDocument();
 983   if ((aActiveDoc == document()) || (myObject->document() == aActiveDoc))
 984     return aEditingFlag;
 985   return aDefaultFlag;
 986 }
 987
 988 ModuleBase_ITreeNode* PartSet_PartRootNode::createNode(const ObjectPtr& theObj)
 989 {
 990   if (theObj->groupName() == ModelAPI_Folder::group())
 991     return new PartSet_ObjectFolderNode(theObj, this);
 992   PartSet_ObjectNode* aNode = new PartSet_ObjectNode(theObj, this);
 993   aNode->update();
 994   return aNode;
 995 }
 996
 997 int PartSet_PartRootNode::numberOfFolders() const
 998 {
 999   int aNb = 3;
1000   if (myFieldsFolder->childrenCount() > 0)
1001     aNb++;
1002   if (myGroupsFolder->childrenCount() > 0)
1003     aNb++;
1004   return aNb;
1005 }
1006
1007 QTreeNodesList PartSet_PartRootNode::objectCreated(const QObjectPtrList& theObjects)
1008 {
1009   QTreeNodesList aResult = PartSet_FeatureFolderNode::objectCreated(theObjects);
1010   if (!myFieldsFolder->childrenCount()) {
1011     QTreeNodesList aList = myFieldsFolder->objectCreated(theObjects);
1012     if (aList.size()) {
1013       myChildren.insert(3, myFieldsFolder);
1014       aResult.append(myFieldsFolder);
1015       aResult.append(aList);
1016     }
1017   }
1018   if (!myGroupsFolder->childrenCount()) {
1019     QTreeNodesList aList = myGroupsFolder->objectCreated(theObjects);
1020     if (aList.size()) {
1021       myChildren.insert(myFieldsFolder->childrenCount()? 4 : 3, myGroupsFolder);
1022       aResult.append(myGroupsFolder);
1023       aResult.append(aList);
1024     }
1025   }
1026   return aResult;
1027 }
1028
1029 QTreeNodesList PartSet_PartRootNode::objectsDeleted(const DocumentPtr& theDoc,
1030   const QString& theGroup)
1031 {
1032   QTreeNodesList aResult;
1033   if (myFieldsFolder->childrenCount()) {
1034     QTreeNodesList aList = myFieldsFolder->objectsDeleted(theDoc, theGroup);
1035     if (aList.size()) {
1036       aResult.append(aList);
1037       if (!myFieldsFolder->childrenCount())
1038         myChildren.removeAll(myFieldsFolder);
1039     }
1040   }
1041   if (myGroupsFolder->childrenCount()) {
1042     QTreeNodesList aList = myGroupsFolder->objectsDeleted(theDoc, theGroup);
1043     if (aList.size()) {
1044       aResult.append(aList);
1045       if (!myGroupsFolder->childrenCount())
1046         myChildren.removeAll(myGroupsFolder);
1047     }
1048   }
1049   aResult.append(PartSet_FeatureFolderNode::objectsDeleted(theDoc, theGroup));
1050   return aResult;
1051 }
1052
1053 //////////////////////////////////////////////////////////////////////////////////
1054 void PartSet_ObjectFolderNode::update()
1055 {
1056   int aFirst = -1, aLast = -1;
1057   PartSet_Tools::getFirstAndLastIndexInFolder(myObject, aFirst, aLast);
1058   if ((aFirst == -1) || (aLast == -1)) {
1059     deleteChildren();
1060     return;
1061   }
1062
1063   int aNbItems = aLast - aFirst + 1;
1064   if (!aNbItems) {
1065     deleteChildren();
1066     return;
1067   }
1068
1069   DocumentPtr aDoc = myObject->document();
1070   if (aNbItems < myChildren.size()) {
1071     // Delete obsolete nodes
1072     int aId = 0;
1073     int aNbOfFeatures = aDoc->size(ModelAPI_Feature::group(), true);
1074     while (aId < myChildren.size()) {
1075       ModuleBase_ITreeNode* aNode = myChildren.at(aId);
1076       if ((aFirst + aId) < aNbOfFeatures) {
1077         if (aNode->object() != aDoc->object(ModelAPI_Feature::group(), aFirst + aId)) {
1078           myChildren.removeAll(aNode);
1079           delete aNode;
1080           continue;
1081         }
1082       }
1083       else {
1084         myChildren.removeAll(aNode);
1085         delete aNode;
1086         continue;
1087       }
1088       aId++;
1089     }
1090   }
1091   if (aNbItems > myChildren.size()) {
1092     // Add new nodes
1093     ModuleBase_ITreeNode* aNode;
1094     for (int i = 0; i < aNbItems; i++) {
1095       ObjectPtr aObj = aDoc->object(ModelAPI_Feature::group(), aFirst + i);
1096       if (i < myChildren.size()) {
1097         if (aObj != myChildren.at(i)->object()) {
1098           aNode = new PartSet_ObjectNode(aObj, this);
1099           myChildren.insert(i, aNode);
1100           aNode->update();
1101         }
1102       }
1103       else {
1104         aNode = new PartSet_ObjectNode(aObj, this);
1105         myChildren.append(aNode);
1106         aNode->update();
1107       }
1108     }
1109   }
1110 }
1111
1112 QTreeNodesList PartSet_ObjectFolderNode::objectCreated(const QObjectPtrList& theObjects)
1113 {
1114   QTreeNodesList aResult;
1115   int aFirst = -1, aLast = -1;
1116   PartSet_Tools::getFirstAndLastIndexInFolder(myObject, aFirst, aLast);
1117   if ((aFirst == -1) || (aLast == -1)) {
1118     return aResult;
1119   }
1120   int aNbItems = aLast - aFirst + 1;
1121   if (!aNbItems) {
1122     return aResult;
1123   }
1124   DocumentPtr aDoc = myObject->document();
1125   // Add new nodes
1126   ModuleBase_ITreeNode* aNode;
1127   for (int i = 0; i < aNbItems; i++) {
1128     ObjectPtr aObj = aDoc->object(ModelAPI_Feature::group(), aFirst + i);
1129     if (i < myChildren.size()) {
1130       if (aObj != myChildren.at(i)->object()) {
1131         aNode = new PartSet_ObjectNode(aObj, this);
1132         myChildren.insert(i, aNode);
1133         aResult.append(aNode);
1134         aNode->update();
1135       }
1136     } else {
1137       aNode = new PartSet_ObjectNode(aObj, this);
1138       myChildren.append(aNode);
1139       aResult.append(aNode);
1140       aNode->update();
1141     }
1142   }
1143   return aResult;
1144 }
1145
1146 QTreeNodesList PartSet_ObjectFolderNode::objectsDeleted(const DocumentPtr& theDoc,
1147   const QString& theGroup)
1148 {
1149   QTreeNodesList aResult;
1150   int aFirst = -1, aLast = -1;
1151   PartSet_Tools::getFirstAndLastIndexInFolder(myObject, aFirst, aLast);
1152   if ((aFirst == -1) || (aLast == -1)) {
1153     return aResult;
1154   }
1155   int aNbItems = aLast - aFirst + 1;
1156   if (!aNbItems) {
1157     return aResult;
1158   }
1159   if (aNbItems >= myChildren.size()) // Nothing was deleted here
1160     return aResult;
1161
1162   DocumentPtr aDoc = myObject->document();
1163   // Delete obsolete nodes
1164   bool aRemoved = false;
1165   int aId = 0;
1166   int aNbOfFeatures = aDoc->size(ModelAPI_Feature::group(), true);
1167   while (aId < myChildren.size()) {
1168     ModuleBase_ITreeNode* aNode = myChildren.at(aId);
1169     if ((aFirst + aId) < aNbOfFeatures) {
1170       if (aNode->object() != aDoc->object(ModelAPI_Feature::group(), aFirst + aId)) {
1171         myChildren.removeAll(aNode);
1172         delete aNode;
1173         aRemoved = true;
1174         continue;
1175       }
1176     }
1177     else {
1178       myChildren.removeAll(aNode);
1179       aResult.removeAll(aNode);
1180       delete aNode;
1181       aRemoved = true;
1182       continue;
1183     }
1184     aId++;
1185   }
1186   if (aRemoved) {
1187     aResult.append(this);
1188   }
1189   return aResult;
1190 }
1191
1192
1193
1194 //////////////////////////////////////////////////////////////////////////////////
1195 QVariant PartSet_StepNode::data(int theColumn, int theRole) const
1196 {
1197   if ((theColumn == 1) && (theRole == Qt::DisplayRole)) {
1198     ModelAPI_ResultField::ModelAPI_FieldStep* aStep =
1199       dynamic_cast<ModelAPI_ResultField::ModelAPI_FieldStep*>(myEntity);
1200
1201     return "Step " + QString::number(aStep->id() + 1) + " " +
1202       aStep->field()->textLine(aStep->id()).c_str();
1203   }
1204   return PartSet_TreeNode::data(theColumn, theRole);
1205 }