src/PartSet/PartSet_TreeNodes.cpp

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