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