1 // Copyright (C) 2014-2017 CEA/DEN, EDF R&D
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.
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.
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
17 // See http://www.salome-platform.org/ or
18 // email : webmaster.salome@opencascade.com<mailto:webmaster.salome@opencascade.com>
21 #include "PartSet_TreeNodes.h"
23 #include <ModuleBase_IconFactory.h>
24 #include <ModuleBase_IWorkshop.h>
26 #include <PartSetPlugin_Part.h>
28 #include <ModelAPI_Session.h>
29 #include <ModelAPI_ResultParameter.h>
30 #include <ModelAPI_ResultField.h>
31 #include <ModelAPI_ResultGroup.h>
32 #include <ModelAPI_ResultConstruction.h>
33 #include <ModelAPI_ResultPart.h>
34 #include <ModelAPI_ResultBody.h>
35 #include <ModelAPI_Tools.h>
36 #include <ModelAPI_ResultBody.h>
37 #include <ModelAPI_CompositeFeature.h>
38 #include <ModelAPI_AttributeDouble.h>
39 #include <ModelAPI_Folder.h>
40 #include <ModelAPI_AttributeReference.h>
46 #define ACTIVE_COLOR QColor(Qt::black)
47 #define SELECTABLE_COLOR QColor(100, 100, 100)
48 #define DISABLED_COLOR QColor(200, 200, 200)
50 Qt::ItemFlags aNullFlag;
51 Qt::ItemFlags aDefaultFlag = Qt::ItemIsSelectable | Qt::ItemIsEnabled;
52 Qt::ItemFlags aEditingFlag = Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsEditable;
55 ResultPartPtr getPartResult(const ObjectPtr& theObj)
57 FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(theObj);
59 ResultPtr aRes = aFeature->firstResult();
60 if (aRes.get() && (aRes->groupName() == ModelAPI_ResultPart::group())) {
61 ResultPartPtr aPartRes = std::dynamic_pointer_cast<ModelAPI_ResultPart>(aRes);
62 // Use only original parts, not a placement results
63 if (aPartRes == aPartRes->original())
67 return ResultPartPtr();
70 bool isCurrentFeature(const ObjectPtr& theObj)
72 SessionPtr aSession = ModelAPI_Session::get();
73 DocumentPtr aCurDoc = aSession->activeDocument();
74 FeaturePtr aFeature = aCurDoc->currentFeature(true);
75 return aFeature == theObj;
78 //////////////////////////////////////////////////////////////////////////////////
79 QVariant PartSet_TreeNode::data(int theColumn, int theRole) const
81 if ((theColumn == 1) && (theRole == Qt::ForegroundRole)) {
82 Qt::ItemFlags aFlags = flags(theColumn);
83 if (aFlags == Qt::ItemFlags())
84 return QBrush(DISABLED_COLOR);
85 if (!aFlags.testFlag(Qt::ItemIsEditable))
86 return QBrush(SELECTABLE_COLOR);
89 return ModuleBase_ITreeNode::data(theColumn, theRole);
93 //////////////////////////////////////////////////////////////////////////////////
94 QVariant PartSet_ObjectNode::data(int theColumn, int theRole) const
99 if (myObject->groupName() == ModelAPI_ResultParameter::group()) {
100 ResultParameterPtr aParam = std::dynamic_pointer_cast<ModelAPI_ResultParameter>(myObject);
101 AttributeDoublePtr aValueAttribute =
102 aParam->data()->real(ModelAPI_ResultParameter::VALUE());
103 QString aVal = QString::number(aValueAttribute->value());
104 QString aTitle = QString(myObject->data()->name().c_str());
105 return aTitle + " = " + aVal;
107 return myObject->data()->name().c_str();
110 case Qt::DecorationRole:
113 switch (visibilityState()) {
117 return QIcon(":pictures/eyeopen.png");
119 return QIcon(":pictures/eyemiclosed.png");
121 return QIcon(":pictures/eyeclosed.png");
124 if (myObject->groupName() == ModelAPI_Folder::group())
125 return QIcon(":pictures/features_folder.png");
127 return ModuleBase_IconFactory::get()->getIcon(myObject);
129 if (isCurrentFeature(myObject))
130 return QIcon(":pictures/arrow.png");
133 return PartSet_TreeNode::data(theColumn, theRole);
136 Qt::ItemFlags PartSet_ObjectNode::flags(int theColumn) const
138 if (myObject->isDisabled()) {
139 return (theColumn == 2) ? Qt::ItemIsSelectable : aNullFlag;
141 DocumentPtr aDoc = myObject->document();
142 SessionPtr aSession = ModelAPI_Session::get();
143 if (aSession->activeDocument() == aDoc)
149 PartSet_ObjectNode::VisibilityState PartSet_ObjectNode::visibilityState() const
151 Qt::ItemFlags aFlags = flags(1);
152 if (aFlags == Qt::ItemFlags())
155 if (myObject->groupName() == ModelAPI_ResultParameter::group())
157 ResultPtr aResObj = std::dynamic_pointer_cast<ModelAPI_Result>(myObject);
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;
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)
176 else if (aState != aS) {
177 aState = SemiVisible;
184 if (aWork->isVisible(aResObj))
193 int PartSet_ObjectNode::numberOfSubs() const
195 ResultBodyPtr aCompRes = std::dynamic_pointer_cast<ModelAPI_ResultBody>(myObject);
197 return aCompRes->numberOfSubs(true);
199 CompositeFeaturePtr aCompFeature =
200 std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(myObject);
201 if (aCompFeature.get() && aCompFeature->data()->isValid())
202 return aCompFeature->numberOfSubs(true);
204 ResultFieldPtr aFieldRes = std::dynamic_pointer_cast<ModelAPI_ResultField>(myObject);
206 return aFieldRes->stepsSize();
213 ObjectPtr PartSet_ObjectNode::subObject(int theId) const
215 ResultBodyPtr aCompRes = std::dynamic_pointer_cast<ModelAPI_ResultBody>(myObject);
217 return aCompRes->subResult(theId, true);
219 CompositeFeaturePtr aCompFeature =
220 std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(myObject);
221 if (aCompFeature.get())
222 return aCompFeature->subFeature(theId, true);
227 void PartSet_ObjectNode::update()
229 int aNb = numberOfSubs();
231 ResultFieldPtr aFieldRes = std::dynamic_pointer_cast<ModelAPI_ResultField>(myObject);
233 // If the object is a field result then delete extra sub-objects
234 if (aFieldRes.get()) {
235 while (myChildren.size() > aNb) {
236 ModuleBase_ITreeNode* aNode = myChildren.last();
237 myChildren.removeAll(aNode);
243 ModuleBase_ITreeNode* aNode;
245 while (aId < myChildren.size()) {
246 aNode = myChildren.at(aId);
247 aObj = subObject(aId);
248 if (aNode->object() != aObj) {
249 myChildren.removeAll(aNode);
257 ModuleBase_ITreeNode* aNode;
260 for (i = 0; i < aNb; i++) {
261 aBody = subObject(i);
263 if (i < myChildren.size()) {
264 aNode = myChildren.at(i);
265 if (aNode->object() != aBody) {
266 ((PartSet_ObjectNode*)aNode)->setObject(aBody);
270 aNode = new PartSet_ObjectNode(aBody, this);
271 myChildren.append(aNode);
274 else if (aFieldRes.get()) {
275 ModelAPI_ResultField::ModelAPI_FieldStep* aStep = aFieldRes->step(i);
276 if (i < myChildren.size()) {
277 PartSet_StepNode* aStepNode = static_cast<PartSet_StepNode*>(myChildren.at(i));
278 if (aStepNode->entity() != aStep) {
279 aStepNode->setEntity(aStep);
283 aNode = new PartSet_StepNode(aStep, this);
284 myChildren.append(aNode);
288 // Delete extra objects
289 while (myChildren.size() > aNb) {
290 aNode = myChildren.takeLast();
293 foreach(ModuleBase_ITreeNode* aNode, myChildren) {
302 QTreeNodesList PartSet_ObjectNode::objectCreated(const QObjectPtrList& theObjects)
304 QTreeNodesList aResult;
305 int aNb = numberOfSubs();
307 ModuleBase_ITreeNode* aNode;
308 ResultFieldPtr aFieldRes = std::dynamic_pointer_cast<ModelAPI_ResultField>(myObject);
311 for (i = 0; i < aNb; i++) {
312 aBody = subObject(i);
314 if (i < myChildren.size()) {
315 aNode = myChildren.at(i);
316 if (aNode->object() != aBody) {
317 ((PartSet_ObjectNode*)aNode)->setObject(aBody);
318 aResult.append(aNode);
322 aNode = new PartSet_ObjectNode(aBody, this);
323 myChildren.append(aNode);
324 aResult.append(aNode);
329 ModelAPI_ResultField::ModelAPI_FieldStep* aStep = aFieldRes->step(i);
330 if (i < myChildren.size()) {
331 PartSet_StepNode* aStepNode = static_cast<PartSet_StepNode*>(myChildren.at(i));
332 if (aStepNode->entity() != aStep) {
333 aStepNode->setEntity(aStep);
337 aNode = new PartSet_StepNode(aStep, this);
338 myChildren.append(aNode);
342 foreach(ModuleBase_ITreeNode* aNode, myChildren) {
343 aResult.append(aNode->objectCreated(theObjects));
349 QTreeNodesList PartSet_ObjectNode::objectsDeleted(
350 const DocumentPtr& theDoc, const QString& theGroup)
352 QTreeNodesList aResult;
353 int aNb = numberOfSubs();
354 if (aNb != myChildren.size()) {
357 aResult.append(this);
360 // Delete extra objects
361 bool isDeleted = false;
363 ModuleBase_ITreeNode* aNode;
365 while (aId < myChildren.size()) {
366 aNode = myChildren.at(aId);
367 aObj = subObject(aId);
368 if (aNode->object() != aObj) {
369 myChildren.removeAll(aNode);
377 aResult.append(this);
380 foreach(ModuleBase_ITreeNode* aNode, myChildren) {
381 aBody = subObject(i);
382 ((PartSet_ObjectNode*)aNode)->setObject(aBody);
383 aResult.append(aNode->objectsDeleted(theDoc, theGroup));
390 //////////////////////////////////////////////////////////////////////////////////
391 PartSet_FolderNode::PartSet_FolderNode(ModuleBase_ITreeNode* theParent,
393 : PartSet_TreeNode(theParent), myType(theType)
397 QString PartSet_FolderNode::name() const
400 case ParametersFolder:
401 return QObject::tr("Parameters");
402 case ConstructionFolder:
403 return QObject::tr("Constructions");
405 return QObject::tr("Parts");
407 return QObject::tr("Results");
409 return QObject::tr("Fields");
411 return QObject::tr("Groups");
417 QVariant PartSet_FolderNode::data(int theColumn, int theRole) const
419 static QIcon aParamsIco(":pictures/params_folder.png");
420 static QIcon aConstrIco(":pictures/constr_folder.png");
422 if (theColumn == 1) {
424 case Qt::DisplayRole:
425 return name() + QString(" (%1)").arg(childrenCount());
426 case Qt::DecorationRole:
428 case ParametersFolder:
430 case ConstructionFolder:
443 if ((theColumn == 2) && (theRole == Qt::DecorationRole)) {
444 if (document().get()) {
445 FeaturePtr aFeature = document()->currentFeature(true);
446 if (!aFeature.get()) { // There is no current feature
447 ModuleBase_ITreeNode* aLastFolder = 0;
448 foreach(ModuleBase_ITreeNode* aNode, parent()->children()) {
449 if (aNode->type() == PartSet_FolderNode::typeId())
454 if (aLastFolder == this)
455 return QIcon(":pictures/arrow.png");
459 return PartSet_TreeNode::data(theColumn, theRole);
462 Qt::ItemFlags PartSet_FolderNode::flags(int theColumn) const
464 SessionPtr aSession = ModelAPI_Session::get();
465 DocumentPtr aActiveDoc = aSession->activeDocument();
466 if (theColumn == 1) {
467 if (document() == aActiveDoc)
473 ModuleBase_ITreeNode* PartSet_FolderNode::createNode(const ObjectPtr& theObj)
475 //ResultCompSolidPtr aCompRes = std::dynamic_pointer_cast<ModelAPI_ResultCompSolid>(theObj);
476 //if (aCompRes.get())
477 // return new PartSet_CompsolidNode(theObj, this);
478 return new PartSet_ObjectNode(theObj, this);
481 void PartSet_FolderNode::update()
483 DocumentPtr aDoc = document();
487 // Remove extra sub-nodes
490 while (aId < myChildren.size()) {
491 ModuleBase_ITreeNode* aNode = myChildren.at(aId);
492 aIndex = aDoc->index(aNode->object(), true);
493 if ((aIndex == -1) || (aId != aIndex)) {
494 myChildren.removeAll(aNode);
501 std::string aGroup = groupName();
502 int aSize = aDoc->size(aGroup, true);
503 for (int i = 0; i < aSize; i++) {
504 ObjectPtr aObj = aDoc->object(aGroup, i, true);
505 if (i < myChildren.size()) {
506 if (myChildren.at(i)->object() != aObj) {
507 ModuleBase_ITreeNode* aNode = createNode(aObj);
508 myChildren.insert(i, aNode);
511 ModuleBase_ITreeNode* aNode = createNode(aObj);
512 myChildren.append(aNode);
516 foreach(ModuleBase_ITreeNode* aNode, myChildren) {
521 std::string PartSet_FolderNode::groupName() const
524 case ParametersFolder:
525 return ModelAPI_ResultParameter::group();
526 case ConstructionFolder:
527 return ModelAPI_ResultConstruction::group();
529 return ModelAPI_ResultPart::group();
531 return ModelAPI_ResultBody::group();
533 return ModelAPI_ResultField::group();
535 return ModelAPI_ResultGroup::group();
540 QTreeNodesList PartSet_FolderNode::objectCreated(const QObjectPtrList& theObjects)
542 QTreeNodesList aResult;
543 std::string aName = groupName();
544 DocumentPtr aDoc = document();
546 QMap<int, ModuleBase_ITreeNode*> aNewNodes;
547 foreach(ObjectPtr aObj, theObjects) {
548 if ((aObj->document() == aDoc) && (aObj->groupName() == aName)) {
549 aIdx = aDoc->index(aObj, true);
551 bool aHasObject = (aIdx < myChildren.size()) && (myChildren.at(aIdx)->object() == aObj);
553 ModuleBase_ITreeNode* aNode = createNode(aObj);
554 aNewNodes[aIdx] = aNode;
555 aResult.append(aNode);
561 // Add nodes in correct order
563 for (i = 0; i < myChildren.size(); i++) {
564 if (aNewNodes.contains(i)) {
565 myChildren.insert(i, aNewNodes[i]);
569 while (aNewNodes.size()) {
570 i = myChildren.size();
571 myChildren.append(aNewNodes[i]);
574 foreach(ModuleBase_ITreeNode* aNode, myChildren) {
575 aResult.append(aNode->objectCreated(theObjects));
580 QTreeNodesList PartSet_FolderNode::objectsDeleted(const DocumentPtr& theDoc,
581 const QString& theGroup)
583 DocumentPtr aDoc = document();
584 QTreeNodesList aResult;
585 if ((theGroup.toStdString() == groupName()) && (theDoc == aDoc)) {
586 QTreeNodesList aDelList;
589 bool aRemoved = false;
590 bool aToSort = false;
591 while (aId < myChildren.size()) {
592 ModuleBase_ITreeNode* aNode = myChildren.at(aId);
593 aIndex = aDoc->index(aNode->object(), true);
594 aToSort |= ((aIndex != -1) && (aId != aIndex));
596 myChildren.removeAll(aNode);
604 aResult.append(this);
607 foreach(ModuleBase_ITreeNode* aNode, myChildren) {
608 aResult.append(aNode->objectsDeleted(theDoc, theGroup));
614 //////////////////////////////////////////////////////////////////////////////////
615 QTreeNodesList PartSet_FeatureFolderNode::objectCreated(const QObjectPtrList& theObjects)
617 QTreeNodesList aResult;
618 // Process the root sub-objects
619 DocumentPtr aDoc = document();
621 int aNb = numberOfFolders();
622 QMap<int, ModuleBase_ITreeNode*> aNewNodes;
623 foreach(ObjectPtr aObj, theObjects) {
624 if (aDoc == aObj->document()) {
625 if ((aObj->groupName() == ModelAPI_Feature::group()) ||
626 (aObj->groupName() == ModelAPI_Folder::group())){
627 aIdx = aDoc->index(aObj, true);
629 ModuleBase_ITreeNode* aNode = createNode(aObj);
631 bool aHasObject = (aIdx < myChildren.size()) && (myChildren.at(aIdx)->object() == aObj);
633 aNewNodes[aIdx] = aNode;
634 aResult.append(aNode);
641 // To add in correct order
643 for (i = 0; i < myChildren.size(); i++) {
644 if (aNewNodes.contains(i)) {
645 myChildren.insert(i, aNewNodes[i]);
649 while (aNewNodes.size()) {
650 i = myChildren.size();
651 myChildren.append(aNewNodes[i]);
655 // Update sub-folders
656 foreach(ModuleBase_ITreeNode* aNode, myChildren) {
657 aResult.append(aNode->objectCreated(theObjects));
662 QTreeNodesList PartSet_FeatureFolderNode::objectsDeleted(const DocumentPtr& theDoc,
663 const QString& theGroup)
665 QTreeNodesList aResult;
667 // Process sub-folders
668 foreach(ModuleBase_ITreeNode* aNode, myChildren) {
669 if (aNode->childrenCount() > 0) { // aFolder node
670 QTreeNodesList aList = aNode->objectsDeleted(theDoc, theGroup);
671 if (aList.size() > 0)
672 aResult.append(aList);
677 DocumentPtr aDoc = document();
678 int aNb = numberOfFolders();
679 bool isGroup = ((theGroup.toStdString() == ModelAPI_Feature::group()) ||
680 (theGroup.toStdString() == ModelAPI_Folder::group()));
681 if ((theDoc == aDoc) && isGroup) {
684 bool aRemoved = false;
685 bool aToSort = false;
686 while (aId < myChildren.size()) {
687 ModuleBase_ITreeNode* aNode = myChildren.at(aId);
688 if (aNode->object().get()) {
689 aIndex = aDoc->index(aNode->object(), true);
690 aToSort |= ((aIndex != -1) && (aId != (aIndex + aNb)));
692 myChildren.removeAll(aNode);
701 aResult.append(this);
708 ModuleBase_ITreeNode* PartSet_FeatureFolderNode::findParent(const DocumentPtr& theDoc,
711 ModuleBase_ITreeNode* aResult = 0;
712 foreach(ModuleBase_ITreeNode* aNode, myChildren) {
713 aResult = aNode->findParent(theDoc, theGroup);
718 bool isGroup = ((theGroup.toStdString() == ModelAPI_Feature::group()) ||
719 (theGroup.toStdString() == ModelAPI_Folder::group()));
720 if ((theDoc == document()) && isGroup)
726 //////////////////////////////////////////////////////////////////////////////////
727 PartSet_RootNode::PartSet_RootNode() : PartSet_FeatureFolderNode(0), myWorkshop(0)
729 SessionPtr aSession = ModelAPI_Session::get();
730 DocumentPtr aDoc = aSession->moduleDocument();
732 myParamsFolder = new PartSet_FolderNode(this, PartSet_FolderNode::ParametersFolder);
733 myConstrFolder = new PartSet_FolderNode(this, PartSet_FolderNode::ConstructionFolder);
734 myPartsFolder = new PartSet_FolderNode(this, PartSet_FolderNode::PartsFolder);
736 myChildren.append(myParamsFolder);
737 myChildren.append(myConstrFolder);
738 myChildren.append(myPartsFolder);
744 void PartSet_RootNode::update()
746 myParamsFolder->update();
747 myConstrFolder->update();
748 myPartsFolder->update();
750 // Update features content
751 DocumentPtr aDoc = document();
752 int aNb = numberOfFolders();
754 // Remove extra sub-nodes
757 while (aId < myChildren.size()) {
758 ModuleBase_ITreeNode* aNode = myChildren.at(aId);
759 if (aNode->object().get()) {
760 aIndex = aDoc->index(aNode->object(), true);
761 if ((aIndex == -1) || (aId != (aIndex + aNb))) {
762 myChildren.removeAll(aNode);
771 std::string aGroup = ModelAPI_Feature::group();
772 int aSize = aDoc->size(aGroup, true);
774 for (int i = 0; i < aSize; i++) {
775 ObjectPtr aObj = aDoc->object(aGroup, i, true);
776 aId = i + aNb; // Take into account existing folders
777 if (aId < myChildren.size()) {
778 if (myChildren.at(aId)->object() != aObj) {
779 ModuleBase_ITreeNode* aNode = createNode(aObj);
780 myChildren.insert(aId, aNode);
783 ModuleBase_ITreeNode* aNode = createNode(aObj);
784 myChildren.append(aNode);
787 // Update sub-folders
788 foreach(ModuleBase_ITreeNode* aNode, myChildren) {
789 if ((aNode->type() == PartSet_ObjectFolderNode::typeId()) ||
790 (aNode->type() == PartSet_PartRootNode::typeId()))
795 DocumentPtr PartSet_RootNode::document() const
797 return ModelAPI_Session::get()->moduleDocument();
800 ModuleBase_ITreeNode* PartSet_RootNode::createNode(const ObjectPtr& theObj)
802 if (theObj->groupName() == ModelAPI_Folder::group())
803 return new PartSet_ObjectFolderNode(theObj, this);
805 FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(theObj);
806 if (aFeature->getKind() == PartSetPlugin_Part::ID())
807 return new PartSet_PartRootNode(theObj, this);
809 return new PartSet_ObjectNode(theObj, this);
812 //////////////////////////////////////////////////////////////////////////////////
813 PartSet_PartRootNode::PartSet_PartRootNode(const ObjectPtr& theObj, ModuleBase_ITreeNode* theParent)
814 : PartSet_FeatureFolderNode(theParent), myObject(theObj)
816 myParamsFolder = new PartSet_FolderNode(this, PartSet_FolderNode::ParametersFolder);
817 myConstrFolder = new PartSet_FolderNode(this, PartSet_FolderNode::ConstructionFolder);
818 myResultsFolder = new PartSet_FolderNode(this, PartSet_FolderNode::ResultsFolder);
819 myFieldsFolder = new PartSet_FolderNode(this, PartSet_FolderNode::FieldsFolder);
820 myGroupsFolder = new PartSet_FolderNode(this, PartSet_FolderNode::GroupsFolder);
822 myChildren.append(myParamsFolder);
823 myChildren.append(myConstrFolder);
824 myChildren.append(myResultsFolder);
829 void PartSet_PartRootNode::deleteChildren()
831 if (!myFieldsFolder->childrenCount()) {
832 delete myFieldsFolder;
834 if (!myGroupsFolder->childrenCount()) {
835 delete myGroupsFolder;
837 PartSet_FeatureFolderNode::deleteChildren();
841 void PartSet_PartRootNode::update()
843 DocumentPtr aDoc = document();
847 myParamsFolder->update();
848 myConstrFolder->update();
849 myResultsFolder->update();
850 myFieldsFolder->update();
851 myGroupsFolder->update();
853 bool aHasFields = myFieldsFolder->childrenCount() > 0;
854 bool aHasGroups = myGroupsFolder->childrenCount() > 0;
855 if (aHasFields && (!myChildren.contains(myFieldsFolder))) {
856 myChildren.insert(3, myFieldsFolder);
858 if (aHasGroups && (!myChildren.contains(myGroupsFolder))) {
859 myChildren.insert(aHasFields ? 4 : 3, myGroupsFolder);
862 // Update features content
863 int aRows = numberOfFolders();
865 // Remove extra sub-nodes
868 while (aId < myChildren.size()) {
869 ModuleBase_ITreeNode* aNode = myChildren.at(aId);
870 if (aNode->object().get()) {
871 aIndex = aDoc->index(aNode->object(), true);
872 if ((aIndex == -1) || (aId != (aIndex + aRows))) {
873 myChildren.removeAll(aNode);
881 std::string aGroup = ModelAPI_Feature::group();
882 int aSize = aDoc->size(aGroup, true);
884 for (int i = 0; i < aSize; i++) {
885 ObjectPtr aObj = aDoc->object(aGroup, i, true);
886 aId = i + aRows; // Take into account existing folders
887 if (aId < myChildren.size()) {
888 if (myChildren.at(aId)->object() != aObj) {
889 ModuleBase_ITreeNode* aNode = createNode(aObj);
890 myChildren.insert(aId, aNode);
893 ModuleBase_ITreeNode* aNode = createNode(aObj);
894 myChildren.append(aNode);
897 // Update sub-folders
898 foreach(ModuleBase_ITreeNode* aNode, myChildren) {
899 if (aNode->type() == PartSet_ObjectFolderNode::typeId())
904 DocumentPtr PartSet_PartRootNode::document() const
906 ResultPartPtr aPartRes = getPartResult(myObject);
908 return aPartRes->partDoc();
909 return DocumentPtr();
912 QVariant PartSet_PartRootNode::data(int theColumn, int theRole) const
917 case Qt::DisplayRole:
919 ResultPartPtr aPartRes = getPartResult(myObject);
920 if (aPartRes.get()) {
921 if (aPartRes->partDoc().get() == NULL)
922 return QString(myObject->data()->name().c_str()) + " (Not loaded)";
924 return QString(myObject->data()->name().c_str());
926 case Qt::DecorationRole:
927 return ModuleBase_IconFactory::get()->getIcon(myObject);
930 return PartSet_TreeNode::data(theColumn, theRole);
933 Qt::ItemFlags PartSet_PartRootNode::flags(int theColumn) const
935 SessionPtr aSession = ModelAPI_Session::get();
936 DocumentPtr aActiveDoc = aSession->activeDocument();
937 if ((aActiveDoc == document()) || (myObject->document() == aActiveDoc))
942 ModuleBase_ITreeNode* PartSet_PartRootNode::createNode(const ObjectPtr& theObj)
944 if (theObj->groupName() == ModelAPI_Folder::group())
945 return new PartSet_ObjectFolderNode(theObj, this);
946 return new PartSet_ObjectNode(theObj, this);
949 int PartSet_PartRootNode::numberOfFolders() const
952 if (myFieldsFolder->childrenCount() > 0)
954 if (myGroupsFolder->childrenCount() > 0)
959 QTreeNodesList PartSet_PartRootNode::objectCreated(const QObjectPtrList& theObjects)
961 QTreeNodesList aResult = PartSet_FeatureFolderNode::objectCreated(theObjects);
962 if (!myFieldsFolder->childrenCount()) {
963 QTreeNodesList aList = myFieldsFolder->objectCreated(theObjects);
965 myChildren.insert(3, myFieldsFolder);
966 aResult.append(myFieldsFolder);
967 aResult.append(aList);
970 if (!myGroupsFolder->childrenCount()) {
971 QTreeNodesList aList = myGroupsFolder->objectCreated(theObjects);
973 myChildren.insert(myFieldsFolder->childrenCount()? 4 : 3, myGroupsFolder);
974 aResult.append(myGroupsFolder);
975 aResult.append(aList);
981 QTreeNodesList PartSet_PartRootNode::objectsDeleted(const DocumentPtr& theDoc,
982 const QString& theGroup)
984 QTreeNodesList aResult;
985 if (myFieldsFolder->childrenCount()) {
986 QTreeNodesList aList = myFieldsFolder->objectsDeleted(theDoc, theGroup);
988 aResult.append(aList);
989 if (!myFieldsFolder->childrenCount())
990 myChildren.removeAll(myFieldsFolder);
993 if (myGroupsFolder->childrenCount()) {
994 QTreeNodesList aList = myGroupsFolder->objectsDeleted(theDoc, theGroup);
996 aResult.append(aList);
997 if (!myGroupsFolder->childrenCount())
998 myChildren.removeAll(myGroupsFolder);
1001 aResult.append(PartSet_FeatureFolderNode::objectsDeleted(theDoc, theGroup));
1005 //////////////////////////////////////////////////////////////////////////////////
1006 void PartSet_ObjectFolderNode::update()
1009 getFirstAndLastIndex(aFirst, aLast);
1010 if ((aFirst == -1) || (aLast == -1)) {
1015 int aNbItems = aLast - aFirst + 1;
1021 DocumentPtr aDoc = myObject->document();
1022 if (aNbItems < myChildren.size()) {
1023 // Delete obsolete nodes
1025 int aNbOfFeatures = aDoc->size(ModelAPI_Feature::group(), true);
1026 while (aId < myChildren.size()) {
1027 ModuleBase_ITreeNode* aNode = myChildren.at(aId);
1028 if ((aFirst + aId) < aNbOfFeatures) {
1029 if (aNode->object() != aDoc->object(ModelAPI_Feature::group(), aFirst + aId)) {
1030 myChildren.removeAll(aNode);
1036 myChildren.removeAll(aNode);
1043 if (aNbItems > myChildren.size()) {
1045 ModuleBase_ITreeNode* aNode;
1046 for (int i = 0; i < aNbItems; i++) {
1047 ObjectPtr aObj = aDoc->object(ModelAPI_Feature::group(), aFirst + i);
1048 if (i < myChildren.size()) {
1049 if (aObj != myChildren.at(i)->object()) {
1050 aNode = new PartSet_ObjectNode(aObj, this);
1051 myChildren.insert(i, aNode);
1055 aNode = new PartSet_ObjectNode(aObj, this);
1056 myChildren.append(aNode);
1062 QTreeNodesList PartSet_ObjectFolderNode::objectCreated(const QObjectPtrList& theObjects)
1064 QTreeNodesList aResult;
1066 getFirstAndLastIndex(aFirst, aLast);
1067 if ((aFirst == -1) || (aLast == -1)) {
1070 int aNbItems = aLast - aFirst + 1;
1074 DocumentPtr aDoc = myObject->document();
1076 ModuleBase_ITreeNode* aNode;
1077 for (int i = 0; i < aNbItems; i++) {
1078 ObjectPtr aObj = aDoc->object(ModelAPI_Feature::group(), aFirst + i);
1079 if (i < myChildren.size()) {
1080 if (aObj != myChildren.at(i)->object()) {
1081 aNode = new PartSet_ObjectNode(aObj, this);
1082 myChildren.insert(i, aNode);
1083 aResult.append(aNode);
1086 aNode = new PartSet_ObjectNode(aObj, this);
1087 myChildren.append(aNode);
1088 aResult.append(aNode);
1094 QTreeNodesList PartSet_ObjectFolderNode::objectsDeleted(const DocumentPtr& theDoc,
1095 const QString& theGroup)
1097 QTreeNodesList aResult;
1099 getFirstAndLastIndex(aFirst, aLast);
1100 if ((aFirst == -1) || (aLast == -1)) {
1103 int aNbItems = aLast - aFirst + 1;
1107 if (aNbItems >= myChildren.size()) // Nothing was deleted here
1110 DocumentPtr aDoc = myObject->document();
1111 // Delete obsolete nodes
1112 bool aRemoved = false;
1114 int aNbOfFeatures = aDoc->size(ModelAPI_Feature::group(), true);
1115 while (aId < myChildren.size()) {
1116 ModuleBase_ITreeNode* aNode = myChildren.at(aId);
1117 if ((aFirst + aId) < aNbOfFeatures) {
1118 if (aNode->object() != aDoc->object(ModelAPI_Feature::group(), aFirst + aId)) {
1119 myChildren.removeAll(aNode);
1126 myChildren.removeAll(aNode);
1134 aResult.append(this);
1139 FeaturePtr PartSet_ObjectFolderNode::getFeature(const std::string& theId) const
1141 FolderPtr aFolder = std::dynamic_pointer_cast<ModelAPI_Folder>(myObject);
1142 AttributeReferencePtr aFeatAttr = aFolder->data()->reference(theId);
1144 return ModelAPI_Feature::feature(aFeatAttr->value());
1145 return FeaturePtr();
1148 void PartSet_ObjectFolderNode::getFirstAndLastIndex(int& theFirst, int& theLast) const
1150 DocumentPtr aDoc = myObject->document();
1151 FolderPtr aFolder = std::dynamic_pointer_cast<ModelAPI_Folder>(myObject);
1153 FeaturePtr aFirstFeatureInFolder = getFeature(ModelAPI_Folder::FIRST_FEATURE_ID());
1154 if (!aFirstFeatureInFolder.get()) {
1158 FeaturePtr aLastFeatureInFolder = getFeature(ModelAPI_Folder::LAST_FEATURE_ID());
1159 if (!aLastFeatureInFolder.get()) {
1164 theFirst = aDoc->index(aFirstFeatureInFolder);
1165 theLast = aDoc->index(aLastFeatureInFolder);
1169 //////////////////////////////////////////////////////////////////////////////////
1170 QVariant PartSet_StepNode::data(int theColumn, int theRole) const
1172 if ((theColumn == 1) && (theRole == Qt::DisplayRole)) {
1173 ModelAPI_ResultField::ModelAPI_FieldStep* aStep =
1174 dynamic_cast<ModelAPI_ResultField::ModelAPI_FieldStep*>(myEntity);
1176 return "Step " + QString::number(aStep->id() + 1) + " " +
1177 aStep->field()->textLine(aStep->id()).c_str();
1179 return PartSet_TreeNode::data(theColumn, theRole);