1 // Copyright (C) 2014-2019 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 email : webmaster.salome@opencascade.com
20 #include "PartSet_TreeNodes.h"
21 #include "PartSet_Tools.h"
23 #include <ModuleBase_IconFactory.h>
24 #include <ModuleBase_IWorkshop.h>
25 #include <ModuleBase_Tools.h>
27 #include <PartSetPlugin_Part.h>
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>
47 #define ACTIVE_COLOR QColor(Qt::black)
48 #define SELECTABLE_COLOR QColor(100, 100, 100)
49 #define DISABLED_COLOR QColor(200, 200, 200)
51 Qt::ItemFlags aNullFlag;
52 Qt::ItemFlags aDefaultFlag = Qt::ItemIsSelectable | Qt::ItemIsEnabled;
53 Qt::ItemFlags aEditingFlag = Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsEditable;
56 ResultPartPtr getPartResult(const ObjectPtr& theObj)
58 FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(theObj);
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())
68 return ResultPartPtr();
71 bool isCurrentFeature(const ObjectPtr& theObj)
73 SessionPtr aSession = ModelAPI_Session::get();
74 DocumentPtr aCurDoc = aSession->activeDocument();
75 FeaturePtr aFeature = aCurDoc->currentFeature(true);
76 return aFeature == theObj;
79 //////////////////////////////////////////////////////////////////////////////////
80 QVariant PartSet_TreeNode::data(int theColumn, int theRole) const
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);
90 return ModuleBase_ITreeNode::data(theColumn, theRole);
94 //////////////////////////////////////////////////////////////////////////////////
95 QVariant PartSet_ObjectNode::data(int theColumn, int theRole) const
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;
108 return myObject->data()->name().c_str();
111 case Qt::DecorationRole:
114 switch (visibilityState()) {
118 return QIcon(":pictures/eyeopen.png");
120 return QIcon(":pictures/eyemiclosed.png");
122 return QIcon(":pictures/eyeclosed.png");
125 return ModuleBase_IconFactory::get()->getIcon(myObject);
127 if (isCurrentFeature(myObject))
128 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);
275 else if (aFieldRes.get()) {
276 FieldStepPtr aStep = aFieldRes->step(i);
277 if (i < myChildren.size()) {
278 PartSet_StepNode* aStepNode = static_cast<PartSet_StepNode*>(myChildren.at(i));
279 if (aStepNode->object() != aStep) {
280 aStepNode->setObject(aStep);
284 aNode = new PartSet_StepNode(aStep, this);
285 myChildren.append(aNode);
289 // Delete extra objects
290 while (myChildren.size() > aNb) {
291 aNode = myChildren.takeLast();
294 foreach(ModuleBase_ITreeNode* aNode, myChildren) {
303 QTreeNodesList PartSet_ObjectNode::objectCreated(const QObjectPtrList& theObjects)
305 QTreeNodesList aResult;
306 int aNb = numberOfSubs();
308 ModuleBase_ITreeNode* aNode;
309 ResultFieldPtr aFieldRes = std::dynamic_pointer_cast<ModelAPI_ResultField>(myObject);
312 for (i = 0; i < aNb; i++) {
313 aBody = subObject(i);
315 if (i < myChildren.size()) {
316 aNode = myChildren.at(i);
317 if (aNode->object() != aBody) {
318 ((PartSet_ObjectNode*)aNode)->setObject(aBody);
319 aResult.append(aNode);
323 aNode = new PartSet_ObjectNode(aBody, this);
324 myChildren.append(aNode);
325 aResult.append(aNode);
330 FieldStepPtr aStep = aFieldRes->step(i);
331 if (i < myChildren.size()) {
332 PartSet_StepNode* aStepNode = static_cast<PartSet_StepNode*>(myChildren.at(i));
333 if (aStepNode->object() != aStep) {
334 aStepNode->setObject(aStep);
338 aNode = new PartSet_StepNode(aStep, this);
339 myChildren.append(aNode);
343 foreach(ModuleBase_ITreeNode* aNode, myChildren) {
344 aResult.append(aNode->objectCreated(theObjects));
350 QTreeNodesList PartSet_ObjectNode::objectsDeleted(
351 const DocumentPtr& theDoc, const QString& theGroup)
353 QTreeNodesList aResult;
354 int aNb = numberOfSubs();
355 if (aNb != myChildren.size()) {
358 aResult.append(this);
361 // Delete extra objects
362 bool isDeleted = false;
364 ModuleBase_ITreeNode* aNode;
366 while (aId < myChildren.size()) {
367 aNode = myChildren.at(aId);
368 aObj = subObject(aId);
369 if (aNode->object() != aObj) {
370 myChildren.removeAll(aNode);
378 aResult.append(this);
381 foreach(ModuleBase_ITreeNode* aNode, myChildren) {
382 aBody = subObject(i);
383 ((PartSet_ObjectNode*)aNode)->setObject(aBody);
384 aResult.append(aNode->objectsDeleted(theDoc, theGroup));
391 //////////////////////////////////////////////////////////////////////////////////
392 PartSet_FolderNode::PartSet_FolderNode(ModuleBase_ITreeNode* theParent,
394 : PartSet_TreeNode(theParent), myType(theType)
398 QString PartSet_FolderNode::name() const
401 case ParametersFolder:
402 return QObject::tr("Parameters");
403 case ConstructionFolder:
404 return QObject::tr("Constructions");
406 return QObject::tr("Parts");
408 return QObject::tr("Results");
410 return QObject::tr("Fields");
412 return QObject::tr("Groups");
418 QVariant PartSet_FolderNode::data(int theColumn, int theRole) const
420 static QIcon aParamsIco(":pictures/params_folder.png");
421 static QIcon aConstrIco(":pictures/constr_folder.png");
423 if (theColumn == 1) {
425 case Qt::DisplayRole:
426 return name() + QString(" (%1)").arg(childrenCount());
427 case Qt::DecorationRole:
429 case ParametersFolder:
431 case ConstructionFolder:
444 if ((theColumn == 2) && (theRole == Qt::DecorationRole)) {
445 if (document().get()) {
446 SessionPtr aSession = ModelAPI_Session::get();
447 if (document() != aSession->activeDocument())
450 FeaturePtr aFeature = document()->currentFeature(true);
451 if (!aFeature.get()) { // There is no current feature
452 ModuleBase_ITreeNode* aLastFolder = 0;
453 foreach(ModuleBase_ITreeNode* aNode, parent()->children()) {
454 if (aNode->type() == PartSet_FolderNode::typeId())
459 if (aLastFolder == this)
460 return QIcon(":pictures/arrow.png");
466 return PartSet_TreeNode::data(theColumn, theRole);
469 Qt::ItemFlags PartSet_FolderNode::flags(int theColumn) const
471 SessionPtr aSession = ModelAPI_Session::get();
472 DocumentPtr aActiveDoc = aSession->activeDocument();
473 if (theColumn == 1) {
474 if (document() == aActiveDoc)
480 ModuleBase_ITreeNode* PartSet_FolderNode::createNode(const ObjectPtr& theObj)
482 //ResultCompSolidPtr aCompRes = std::dynamic_pointer_cast<ModelAPI_ResultCompSolid>(theObj);
483 //if (aCompRes.get())
484 // return new PartSet_CompsolidNode(theObj, this);
485 ModuleBase_ITreeNode* aNode = new PartSet_ObjectNode(theObj, this);
490 void PartSet_FolderNode::update()
492 DocumentPtr aDoc = document();
496 // Remove extra sub-nodes
499 while (aId < myChildren.size()) {
500 ModuleBase_ITreeNode* aNode = myChildren.at(aId);
501 aIndex = aDoc->index(aNode->object(), true);
502 if ((aIndex == -1) || (aId != aIndex)) {
503 myChildren.removeAll(aNode);
510 std::string aGroup = groupName();
511 int aSize = aDoc->size(aGroup, true);
512 for (int i = 0; i < aSize; i++) {
513 ObjectPtr aObj = aDoc->object(aGroup, i, true);
514 if (i < myChildren.size()) {
515 if (myChildren.at(i)->object() != aObj) {
516 ModuleBase_ITreeNode* aNode = createNode(aObj);
517 myChildren.insert(i, aNode);
520 ModuleBase_ITreeNode* aNode = createNode(aObj);
521 myChildren.append(aNode);
525 foreach(ModuleBase_ITreeNode* aNode, myChildren) {
530 std::string PartSet_FolderNode::groupName() const
533 case ParametersFolder:
534 return ModelAPI_ResultParameter::group();
535 case ConstructionFolder:
536 return ModelAPI_ResultConstruction::group();
538 return ModelAPI_ResultPart::group();
540 return ModelAPI_ResultBody::group();
542 return ModelAPI_ResultField::group();
544 return ModelAPI_ResultGroup::group();
549 QTreeNodesList PartSet_FolderNode::objectCreated(const QObjectPtrList& theObjects)
551 QTreeNodesList aResult;
552 std::string aName = groupName();
553 DocumentPtr aDoc = document();
555 QMap<int, ModuleBase_ITreeNode*> aNewNodes;
556 foreach(ObjectPtr aObj, theObjects) {
557 if ((aObj->document() == aDoc) && (aObj->groupName() == aName)) {
558 aIdx = aDoc->index(aObj, true);
560 bool aHasObject = (aIdx < myChildren.size()) && (myChildren.at(aIdx)->object() == aObj);
562 ModuleBase_ITreeNode* aNode = createNode(aObj);
563 aNewNodes[aIdx] = aNode;
564 aResult.append(aNode);
570 // Add nodes in correct order
571 if (aNewNodes.size() > 0) {
573 for (i = 0; i < myChildren.size(); i++) {
574 if (aNewNodes.contains(i)) {
575 myChildren.insert(i, aNewNodes[i]);
579 while (aNewNodes.size()) {
580 i = myChildren.size();
581 myChildren.append(aNewNodes[i]);
585 foreach(ModuleBase_ITreeNode* aNode, myChildren) {
586 aResult.append(aNode->objectCreated(theObjects));
591 QTreeNodesList PartSet_FolderNode::objectsDeleted(const DocumentPtr& theDoc,
592 const QString& theGroup)
594 DocumentPtr aDoc = document();
595 QTreeNodesList aResult;
596 if ((theGroup.toStdString() == groupName()) && (theDoc == aDoc)) {
597 QTreeNodesList aDelList;
600 bool aRemoved = false;
601 bool aToSort = false;
602 while (aId < myChildren.size()) {
603 ModuleBase_ITreeNode* aNode = myChildren.at(aId);
604 aIndex = aDoc->index(aNode->object(), true);
605 aToSort |= ((aIndex != -1) && (aId != aIndex));
607 myChildren.removeAll(aNode);
615 aResult.append(this);
618 foreach(ModuleBase_ITreeNode* aNode, myChildren) {
619 aResult.append(aNode->objectsDeleted(theDoc, theGroup));
625 //////////////////////////////////////////////////////////////////////////////////
626 QTreeNodesList PartSet_FeatureFolderNode::objectCreated(const QObjectPtrList& theObjects)
628 QTreeNodesList aResult;
629 // Process the root sub-objects
630 DocumentPtr aDoc = document();
632 int aNb = numberOfFolders();
633 QMap<int, ModuleBase_ITreeNode*> aNewNodes;
634 foreach(ObjectPtr aObj, theObjects) {
635 if (aDoc == aObj->document()) {
636 if ((aObj->groupName() == ModelAPI_Feature::group()) ||
637 (aObj->groupName() == ModelAPI_Folder::group())){
638 aIdx = aDoc->index(aObj, true);
640 ModuleBase_ITreeNode* aNode = createNode(aObj);
642 bool aHasObject = (aIdx < myChildren.size()) && (myChildren.at(aIdx)->object() == aObj);
644 aNewNodes[aIdx] = aNode;
645 aResult.append(aNode);
652 // To add in correct order
653 if (aNewNodes.size() > 0) {
655 for (i = 0; i < myChildren.size(); i++) {
656 if (aNewNodes.contains(i)) {
657 myChildren.insert(i, aNewNodes[i]);
661 while (aNewNodes.size()) {
662 i = myChildren.size();
663 if (aNewNodes.contains(i)) {
664 myChildren.append(aNewNodes[i]);
669 // Update sub-folders
670 foreach(ModuleBase_ITreeNode* aNode, myChildren) {
671 aResult.append(aNode->objectCreated(theObjects));
676 QTreeNodesList PartSet_FeatureFolderNode::objectsDeleted(const DocumentPtr& theDoc,
677 const QString& theGroup)
679 QTreeNodesList aResult;
681 // Process sub-folders
682 foreach(ModuleBase_ITreeNode* aNode, myChildren) {
683 if (aNode->childrenCount() > 0) { // aFolder node
684 QTreeNodesList aList = aNode->objectsDeleted(theDoc, theGroup);
685 if (aList.size() > 0)
686 aResult.append(aList);
691 DocumentPtr aDoc = document();
692 int aNb = numberOfFolders();
693 bool isGroup = ((theGroup.toStdString() == ModelAPI_Feature::group()) ||
694 (theGroup.toStdString() == ModelAPI_Folder::group()));
695 if ((theDoc == aDoc) && isGroup) {
698 bool aRemoved = false;
699 bool aToSort = false;
700 while (aId < myChildren.size()) {
701 ModuleBase_ITreeNode* aNode = myChildren.at(aId);
702 if (aNode->object().get()) {
703 aIndex = aDoc->index(aNode->object(), true);
704 aToSort |= ((aIndex != -1) && (aId != (aIndex + aNb)));
706 myChildren.removeAll(aNode);
715 aResult.append(this);
722 ModuleBase_ITreeNode* PartSet_FeatureFolderNode::findParent(const DocumentPtr& theDoc,
725 ModuleBase_ITreeNode* aResult = 0;
726 foreach(ModuleBase_ITreeNode* aNode, myChildren) {
727 aResult = aNode->findParent(theDoc, theGroup);
732 bool isGroup = ((theGroup.toStdString() == ModelAPI_Feature::group()) ||
733 (theGroup.toStdString() == ModelAPI_Folder::group()));
734 if ((theDoc == document()) && isGroup)
740 //////////////////////////////////////////////////////////////////////////////////
741 PartSet_RootNode::PartSet_RootNode() : PartSet_FeatureFolderNode(0), myWorkshop(0)
743 SessionPtr aSession = ModelAPI_Session::get();
744 DocumentPtr aDoc = aSession->moduleDocument();
746 myParamsFolder = new PartSet_FolderNode(this, PartSet_FolderNode::ParametersFolder);
747 myConstrFolder = new PartSet_FolderNode(this, PartSet_FolderNode::ConstructionFolder);
748 myPartsFolder = new PartSet_FolderNode(this, PartSet_FolderNode::PartsFolder);
750 myChildren.append(myParamsFolder);
751 myChildren.append(myConstrFolder);
752 myChildren.append(myPartsFolder);
758 void PartSet_RootNode::update()
760 myParamsFolder->update();
761 myConstrFolder->update();
762 myPartsFolder->update();
764 // Update features content
765 DocumentPtr aDoc = document();
766 int aNb = numberOfFolders();
768 // Remove extra sub-nodes
771 while (aId < myChildren.size()) {
772 ModuleBase_ITreeNode* aNode = myChildren.at(aId);
773 if (aNode->object().get()) {
774 aIndex = aDoc->index(aNode->object(), true);
775 if ((aIndex == -1) || (aId != (aIndex + aNb))) {
776 myChildren.removeAll(aNode);
785 std::string aGroup = ModelAPI_Feature::group();
786 int aSize = aDoc->size(aGroup, true);
788 for (int i = 0; i < aSize; i++) {
789 ObjectPtr aObj = aDoc->object(aGroup, i, true);
790 aId = i + aNb; // Take into account existing folders
791 if (aId < myChildren.size()) {
792 if (myChildren.at(aId)->object() != aObj) {
793 ModuleBase_ITreeNode* aNode = createNode(aObj);
794 myChildren.insert(aId, aNode);
797 ModuleBase_ITreeNode* aNode = createNode(aObj);
798 myChildren.append(aNode);
801 // Update sub-folders
802 foreach(ModuleBase_ITreeNode* aNode, myChildren) {
803 if ((aNode->type() == PartSet_ObjectFolderNode::typeId()) ||
804 (aNode->type() == PartSet_PartRootNode::typeId()))
809 DocumentPtr PartSet_RootNode::document() const
811 return ModelAPI_Session::get()->moduleDocument();
814 ModuleBase_ITreeNode* PartSet_RootNode::createNode(const ObjectPtr& theObj)
816 if (theObj->groupName() == ModelAPI_Folder::group())
817 return new PartSet_ObjectFolderNode(theObj, this);
819 FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(theObj);
820 if (aFeature->getKind() == PartSetPlugin_Part::ID())
821 return new PartSet_PartRootNode(theObj, this);
823 PartSet_ObjectNode* aNode = new PartSet_ObjectNode(theObj, this);
828 //////////////////////////////////////////////////////////////////////////////////
829 PartSet_PartRootNode::PartSet_PartRootNode(const ObjectPtr& theObj, ModuleBase_ITreeNode* theParent)
830 : PartSet_FeatureFolderNode(theParent), myObject(theObj)
832 myParamsFolder = new PartSet_FolderNode(this, PartSet_FolderNode::ParametersFolder);
833 myConstrFolder = new PartSet_FolderNode(this, PartSet_FolderNode::ConstructionFolder);
834 myResultsFolder = new PartSet_FolderNode(this, PartSet_FolderNode::ResultsFolder);
835 myFieldsFolder = new PartSet_FolderNode(this, PartSet_FolderNode::FieldsFolder);
836 myGroupsFolder = new PartSet_FolderNode(this, PartSet_FolderNode::GroupsFolder);
838 myChildren.append(myParamsFolder);
839 myChildren.append(myConstrFolder);
840 myChildren.append(myResultsFolder);
845 void PartSet_PartRootNode::deleteChildren()
847 if (!myFieldsFolder->childrenCount()) {
848 delete myFieldsFolder;
850 if (!myGroupsFolder->childrenCount()) {
851 delete myGroupsFolder;
853 PartSet_FeatureFolderNode::deleteChildren();
857 void PartSet_PartRootNode::update()
859 DocumentPtr aDoc = document();
863 myParamsFolder->update();
864 myConstrFolder->update();
865 myResultsFolder->update();
866 myFieldsFolder->update();
867 myGroupsFolder->update();
869 bool aHasFields = myFieldsFolder->childrenCount() > 0;
870 bool aHasGroups = myGroupsFolder->childrenCount() > 0;
872 if (!myChildren.contains(myFieldsFolder)) {
873 myChildren.insert(3, myFieldsFolder);
875 } else if (myChildren.contains(myFieldsFolder)) {
876 myChildren.removeAll(myFieldsFolder);
879 if (!myChildren.contains(myGroupsFolder)) {
880 myChildren.insert(aHasFields ? 4 : 3, myGroupsFolder);
882 } else if (myChildren.contains(myGroupsFolder)) {
883 myChildren.removeAll(myGroupsFolder);
886 // Update features content
887 int aRows = numberOfFolders();
889 // Remove extra sub-nodes
892 QMap<int, ModuleBase_ITreeNode*> aExistingNodes;
893 while (aId < myChildren.size()) {
894 ModuleBase_ITreeNode* aNode = myChildren.at(aId);
895 if (aNode->object().get()) {
896 aIndex = aDoc->index(aNode->object(), true);
897 if ((aIndex == -1) || (aId != (aIndex + aRows))) {
898 myChildren.removeAll(aNode);
902 aExistingNodes[aIndex + aRows] = aNode;
909 std::string aGroup = ModelAPI_Feature::group();
910 int aSize = aDoc->size(aGroup, true);
912 for (int i = 0; i < aSize; i++) {
913 ObjectPtr aObj = aDoc->object(aGroup, i, true);
914 aId = i + aRows; // Take into account existing folders
915 if (aId < myChildren.size()) {
916 if (myChildren.at(aId)->object() != aObj) {
917 if (aExistingNodes.contains(aId)) {
918 myChildren.insert(aId, aExistingNodes[aId]);
919 aExistingNodes.remove(aId);
922 myChildren.insert(aId, createNode(aObj));
926 if (aExistingNodes.contains(myChildren.size()))
927 myChildren.append(aExistingNodes[myChildren.size()]);
929 myChildren.append(createNode(aObj));
932 // Update sub-folders
933 foreach(ModuleBase_ITreeNode* aNode, myChildren) {
934 if (aNode->type() == PartSet_ObjectFolderNode::typeId())
939 DocumentPtr PartSet_PartRootNode::document() const
941 ResultPartPtr aPartRes = getPartResult(myObject);
943 return aPartRes->partDoc();
944 return DocumentPtr();
947 QVariant PartSet_PartRootNode::data(int theColumn, int theRole) const
952 case Qt::DisplayRole:
954 ResultPartPtr aPartRes = getPartResult(myObject);
955 if (aPartRes.get()) {
956 if (aPartRes->partDoc().get() == NULL)
957 return QString(myObject->data()->name().c_str()) + " (Not loaded)";
959 return QString(myObject->data()->name().c_str());
961 case Qt::DecorationRole:
962 return ModuleBase_IconFactory::get()->getIcon(myObject);
965 if (theRole == Qt::DecorationRole) {
966 if (isCurrentFeature(myObject))
967 return QIcon(":pictures/arrow.png");
972 return PartSet_TreeNode::data(theColumn, theRole);
975 Qt::ItemFlags PartSet_PartRootNode::flags(int theColumn) const
977 if (myObject->isDisabled())
978 return (theColumn == 2) ? Qt::ItemIsSelectable : aNullFlag;
980 SessionPtr aSession = ModelAPI_Session::get();
981 DocumentPtr aActiveDoc = aSession->activeDocument();
982 if ((aActiveDoc == document()) || (myObject->document() == aActiveDoc))
987 ModuleBase_ITreeNode* PartSet_PartRootNode::createNode(const ObjectPtr& theObj)
989 if (theObj->groupName() == ModelAPI_Folder::group())
990 return new PartSet_ObjectFolderNode(theObj, this);
991 PartSet_ObjectNode* aNode = new PartSet_ObjectNode(theObj, this);
996 int PartSet_PartRootNode::numberOfFolders() const
999 if (myFieldsFolder->childrenCount() > 0)
1001 if (myGroupsFolder->childrenCount() > 0)
1006 QTreeNodesList PartSet_PartRootNode::objectCreated(const QObjectPtrList& theObjects)
1008 QTreeNodesList aResult = PartSet_FeatureFolderNode::objectCreated(theObjects);
1009 if (!myFieldsFolder->childrenCount()) {
1010 QTreeNodesList aList = myFieldsFolder->objectCreated(theObjects);
1012 myChildren.insert(3, myFieldsFolder);
1013 aResult.append(myFieldsFolder);
1014 aResult.append(aList);
1017 if (!myGroupsFolder->childrenCount()) {
1018 QTreeNodesList aList = myGroupsFolder->objectCreated(theObjects);
1020 myChildren.insert(myFieldsFolder->childrenCount()? 4 : 3, myGroupsFolder);
1021 aResult.append(myGroupsFolder);
1022 aResult.append(aList);
1028 QTreeNodesList PartSet_PartRootNode::objectsDeleted(const DocumentPtr& theDoc,
1029 const QString& theGroup)
1031 QTreeNodesList aResult;
1032 if (myFieldsFolder->childrenCount()) {
1033 QTreeNodesList aList = myFieldsFolder->objectsDeleted(theDoc, theGroup);
1035 aResult.append(aList);
1036 if (!myFieldsFolder->childrenCount())
1037 myChildren.removeAll(myFieldsFolder);
1040 if (myGroupsFolder->childrenCount()) {
1041 QTreeNodesList aList = myGroupsFolder->objectsDeleted(theDoc, theGroup);
1043 aResult.append(aList);
1044 if (!myGroupsFolder->childrenCount())
1045 myChildren.removeAll(myGroupsFolder);
1048 aResult.append(PartSet_FeatureFolderNode::objectsDeleted(theDoc, theGroup));
1052 //////////////////////////////////////////////////////////////////////////////////
1053 void PartSet_ObjectFolderNode::update()
1055 int aFirst = -1, aLast = -1;
1056 PartSet_Tools::getFirstAndLastIndexInFolder(myObject, aFirst, aLast);
1057 if ((aFirst == -1) || (aLast == -1)) {
1062 int aNbItems = aLast - aFirst + 1;
1068 DocumentPtr aDoc = myObject->document();
1069 if (aNbItems < myChildren.size()) {
1070 // Delete obsolete nodes
1072 int aNbOfFeatures = aDoc->size(ModelAPI_Feature::group(), true);
1073 while (aId < myChildren.size()) {
1074 ModuleBase_ITreeNode* aNode = myChildren.at(aId);
1075 if ((aFirst + aId) < aNbOfFeatures) {
1076 if (aNode->object() != aDoc->object(ModelAPI_Feature::group(), aFirst + aId)) {
1077 myChildren.removeAll(aNode);
1083 myChildren.removeAll(aNode);
1090 if (aNbItems > myChildren.size()) {
1092 ModuleBase_ITreeNode* aNode;
1093 for (int i = 0; i < aNbItems; i++) {
1094 ObjectPtr aObj = aDoc->object(ModelAPI_Feature::group(), aFirst + i);
1095 if (i < myChildren.size()) {
1096 if (aObj != myChildren.at(i)->object()) {
1097 aNode = new PartSet_ObjectNode(aObj, this);
1098 myChildren.insert(i, aNode);
1103 aNode = new PartSet_ObjectNode(aObj, this);
1104 myChildren.append(aNode);
1111 QTreeNodesList PartSet_ObjectFolderNode::objectCreated(const QObjectPtrList& theObjects)
1113 QTreeNodesList aResult;
1114 int aFirst = -1, aLast = -1;
1115 PartSet_Tools::getFirstAndLastIndexInFolder(myObject, aFirst, aLast);
1116 if ((aFirst == -1) || (aLast == -1)) {
1119 int aNbItems = aLast - aFirst + 1;
1123 DocumentPtr aDoc = myObject->document();
1125 ModuleBase_ITreeNode* aNode;
1126 for (int i = 0; i < aNbItems; i++) {
1127 ObjectPtr aObj = aDoc->object(ModelAPI_Feature::group(), aFirst + i);
1128 if (i < myChildren.size()) {
1129 if (aObj != myChildren.at(i)->object()) {
1130 aNode = new PartSet_ObjectNode(aObj, this);
1131 myChildren.insert(i, aNode);
1132 aResult.append(aNode);
1136 aNode = new PartSet_ObjectNode(aObj, this);
1137 myChildren.append(aNode);
1138 aResult.append(aNode);
1145 QTreeNodesList PartSet_ObjectFolderNode::objectsDeleted(const DocumentPtr& theDoc,
1146 const QString& theGroup)
1148 QTreeNodesList aResult;
1149 int aFirst = -1, aLast = -1;
1150 PartSet_Tools::getFirstAndLastIndexInFolder(myObject, aFirst, aLast);
1151 if ((aFirst == -1) || (aLast == -1)) {
1154 int aNbItems = aLast - aFirst + 1;
1158 if (aNbItems >= myChildren.size()) // Nothing was deleted here
1161 DocumentPtr aDoc = myObject->document();
1162 // Delete obsolete nodes
1163 bool aRemoved = false;
1165 int aNbOfFeatures = aDoc->size(ModelAPI_Feature::group(), true);
1166 while (aId < myChildren.size()) {
1167 ModuleBase_ITreeNode* aNode = myChildren.at(aId);
1168 if ((aFirst + aId) < aNbOfFeatures) {
1169 if (aNode->object() != aDoc->object(ModelAPI_Feature::group(), aFirst + aId)) {
1170 myChildren.removeAll(aNode);
1177 myChildren.removeAll(aNode);
1178 aResult.removeAll(aNode);
1186 aResult.append(this);
1193 //////////////////////////////////////////////////////////////////////////////////
1194 QVariant PartSet_StepNode::data(int theColumn, int theRole) const
1196 if ((theColumn == 1) && (theRole == Qt::DisplayRole)) {
1197 FieldStepPtr aStep =
1198 std::dynamic_pointer_cast<ModelAPI_ResultField::ModelAPI_FieldStep>(myObject);
1200 return "Step " + QString::number(aStep->id() + 1) + " " +
1201 aStep->field()->textLine(aStep->id()).c_str();
1203 return PartSet_ObjectNode::data(theColumn, theRole);
1206 ModuleBase_ITreeNode::VisibilityState PartSet_StepNode::visibilityState() const
1208 Qt::ItemFlags aFlags = flags(1);
1209 if (aFlags == Qt::ItemFlags())
1212 ModuleBase_IWorkshop* aWork = workshop();
1213 if (aWork->isVisible(myObject))