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"
22 #include "PartSet_Tools.h"
24 #include <ModuleBase_IconFactory.h>
25 #include <ModuleBase_IWorkshop.h>
26 #include <ModuleBase_Tools.h>
28 #include <PartSetPlugin_Part.h>
30 #include <ModelAPI_Session.h>
31 #include <ModelAPI_ResultParameter.h>
32 #include <ModelAPI_ResultField.h>
33 #include <ModelAPI_ResultGroup.h>
34 #include <ModelAPI_ResultConstruction.h>
35 #include <ModelAPI_ResultPart.h>
36 #include <ModelAPI_ResultBody.h>
37 #include <ModelAPI_Tools.h>
38 #include <ModelAPI_ResultBody.h>
39 #include <ModelAPI_CompositeFeature.h>
40 #include <ModelAPI_AttributeDouble.h>
41 #include <ModelAPI_Folder.h>
42 #include <ModelAPI_AttributeReference.h>
48 #define ACTIVE_COLOR QColor(Qt::black)
49 #define SELECTABLE_COLOR QColor(100, 100, 100)
50 #define DISABLED_COLOR QColor(200, 200, 200)
52 Qt::ItemFlags aNullFlag;
53 Qt::ItemFlags aDefaultFlag = Qt::ItemIsSelectable | Qt::ItemIsEnabled;
54 Qt::ItemFlags aEditingFlag = Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsEditable;
57 ResultPartPtr getPartResult(const ObjectPtr& theObj)
59 FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(theObj);
61 ResultPtr aRes = aFeature->firstResult();
62 if (aRes.get() && (aRes->groupName() == ModelAPI_ResultPart::group())) {
63 ResultPartPtr aPartRes = std::dynamic_pointer_cast<ModelAPI_ResultPart>(aRes);
64 // Use only original parts, not a placement results
65 if (aPartRes == aPartRes->original())
69 return ResultPartPtr();
72 bool isCurrentFeature(const ObjectPtr& theObj)
74 SessionPtr aSession = ModelAPI_Session::get();
75 DocumentPtr aCurDoc = aSession->activeDocument();
76 FeaturePtr aFeature = aCurDoc->currentFeature(true);
77 return aFeature == theObj;
80 //////////////////////////////////////////////////////////////////////////////////
81 QVariant PartSet_TreeNode::data(int theColumn, int theRole) const
83 if ((theColumn == 1) && (theRole == Qt::ForegroundRole)) {
84 Qt::ItemFlags aFlags = flags(theColumn);
85 if (aFlags == Qt::ItemFlags())
86 return QBrush(DISABLED_COLOR);
87 if (!aFlags.testFlag(Qt::ItemIsEditable))
88 return QBrush(SELECTABLE_COLOR);
91 return ModuleBase_ITreeNode::data(theColumn, theRole);
95 //////////////////////////////////////////////////////////////////////////////////
96 QVariant PartSet_ObjectNode::data(int theColumn, int theRole) const
100 if (theColumn == 1) {
101 if (myObject->groupName() == ModelAPI_ResultParameter::group()) {
102 ResultParameterPtr aParam = std::dynamic_pointer_cast<ModelAPI_ResultParameter>(myObject);
103 AttributeDoublePtr aValueAttribute =
104 aParam->data()->real(ModelAPI_ResultParameter::VALUE());
105 QString aVal = QString::number(aValueAttribute->value());
106 QString aTitle = QString(myObject->data()->name().c_str());
107 return aTitle + " = " + aVal;
109 return myObject->data()->name().c_str();
112 case Qt::DecorationRole:
115 switch (visibilityState()) {
119 return QIcon(":pictures/eyeopen.png");
121 return QIcon(":pictures/eyemiclosed.png");
123 return QIcon(":pictures/eyeclosed.png");
126 return ModuleBase_IconFactory::get()->getIcon(myObject);
128 if (isCurrentFeature(myObject))
129 return QIcon(":pictures/arrow.png");
134 return PartSet_TreeNode::data(theColumn, theRole);
137 Qt::ItemFlags PartSet_ObjectNode::flags(int theColumn) const
139 if (myObject->isDisabled()) {
140 return (theColumn == 2) ? Qt::ItemIsSelectable : aNullFlag;
142 DocumentPtr aDoc = myObject->document();
143 SessionPtr aSession = ModelAPI_Session::get();
144 if (aSession->activeDocument() == aDoc)
150 PartSet_ObjectNode::VisibilityState PartSet_ObjectNode::visibilityState() const
152 Qt::ItemFlags aFlags = flags(1);
153 if (aFlags == Qt::ItemFlags())
156 if (myObject->groupName() == ModelAPI_ResultParameter::group())
158 ResultPtr aResObj = std::dynamic_pointer_cast<ModelAPI_Result>(myObject);
160 ModuleBase_IWorkshop* aWork = workshop();
161 ResultBodyPtr aCompRes = std::dynamic_pointer_cast<ModelAPI_ResultBody>(aResObj);
162 if (aCompRes.get()) {
163 std::list<ResultPtr> aResultsList;
164 ModelAPI_Tools::allSubs(aCompRes, aResultsList);
165 VisibilityState aState = aResultsList.size() == 0 ?
166 (aWork->isVisible(aCompRes) ? Visible : Hidden) : NoneState;
168 std::list<ResultPtr>::const_iterator aIt;
169 ResultBodyPtr aCompSub;
170 for (aIt = aResultsList.cbegin(); aIt != aResultsList.cend(); aIt++) {
171 ResultPtr aSubRes = (*aIt);
172 aCompSub = std::dynamic_pointer_cast<ModelAPI_ResultBody>(aSubRes);
173 if (!(aCompSub.get() && aCompSub->numberOfSubs() > 0)) {
174 VisibilityState aS = aWork->isVisible(aSubRes) ? Visible : Hidden;
175 if (aState == NoneState)
177 else if (aState != aS) {
178 aState = SemiVisible;
185 if (aWork->isVisible(aResObj))
194 int PartSet_ObjectNode::numberOfSubs() const
196 ResultBodyPtr aCompRes = std::dynamic_pointer_cast<ModelAPI_ResultBody>(myObject);
198 return aCompRes->numberOfSubs(true);
200 CompositeFeaturePtr aCompFeature =
201 std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(myObject);
202 if (aCompFeature.get() && aCompFeature->data()->isValid())
203 return aCompFeature->numberOfSubs(true);
205 ResultFieldPtr aFieldRes = std::dynamic_pointer_cast<ModelAPI_ResultField>(myObject);
207 return aFieldRes->stepsSize();
214 ObjectPtr PartSet_ObjectNode::subObject(int theId) const
216 ResultBodyPtr aCompRes = std::dynamic_pointer_cast<ModelAPI_ResultBody>(myObject);
218 return aCompRes->subResult(theId, true);
220 CompositeFeaturePtr aCompFeature =
221 std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(myObject);
222 if (aCompFeature.get())
223 return aCompFeature->subFeature(theId, true);
228 void PartSet_ObjectNode::update()
230 int aNb = numberOfSubs();
232 ResultFieldPtr aFieldRes = std::dynamic_pointer_cast<ModelAPI_ResultField>(myObject);
234 // If the object is a field result then delete extra sub-objects
235 if (aFieldRes.get()) {
236 while (myChildren.size() > aNb) {
237 ModuleBase_ITreeNode* aNode = myChildren.last();
238 myChildren.removeAll(aNode);
244 ModuleBase_ITreeNode* aNode;
246 while (aId < myChildren.size()) {
247 aNode = myChildren.at(aId);
248 aObj = subObject(aId);
249 if (aNode->object() != aObj) {
250 myChildren.removeAll(aNode);
258 ModuleBase_ITreeNode* aNode;
261 for (i = 0; i < aNb; i++) {
262 aBody = subObject(i);
264 if (i < myChildren.size()) {
265 aNode = myChildren.at(i);
266 if (aNode->object() != aBody) {
267 ((PartSet_ObjectNode*)aNode)->setObject(aBody);
271 aNode = new PartSet_ObjectNode(aBody, this);
272 myChildren.append(aNode);
276 else if (aFieldRes.get()) {
277 ModelAPI_ResultField::ModelAPI_FieldStep* aStep = aFieldRes->step(i);
278 if (i < myChildren.size()) {
279 PartSet_StepNode* aStepNode = static_cast<PartSet_StepNode*>(myChildren.at(i));
280 if (aStepNode->entity() != aStep) {
281 aStepNode->setEntity(aStep);
285 aNode = new PartSet_StepNode(aStep, this);
286 myChildren.append(aNode);
290 // Delete extra objects
291 while (myChildren.size() > aNb) {
292 aNode = myChildren.takeLast();
295 foreach(ModuleBase_ITreeNode* aNode, myChildren) {
304 QTreeNodesList PartSet_ObjectNode::objectCreated(const QObjectPtrList& theObjects)
306 QTreeNodesList aResult;
307 int aNb = numberOfSubs();
309 ModuleBase_ITreeNode* aNode;
310 ResultFieldPtr aFieldRes = std::dynamic_pointer_cast<ModelAPI_ResultField>(myObject);
313 for (i = 0; i < aNb; i++) {
314 aBody = subObject(i);
316 if (i < myChildren.size()) {
317 aNode = myChildren.at(i);
318 if (aNode->object() != aBody) {
319 ((PartSet_ObjectNode*)aNode)->setObject(aBody);
320 aResult.append(aNode);
324 aNode = new PartSet_ObjectNode(aBody, this);
325 myChildren.append(aNode);
326 aResult.append(aNode);
331 ModelAPI_ResultField::ModelAPI_FieldStep* aStep = aFieldRes->step(i);
332 if (i < myChildren.size()) {
333 PartSet_StepNode* aStepNode = static_cast<PartSet_StepNode*>(myChildren.at(i));
334 if (aStepNode->entity() != aStep) {
335 aStepNode->setEntity(aStep);
339 aNode = new PartSet_StepNode(aStep, this);
340 myChildren.append(aNode);
344 foreach(ModuleBase_ITreeNode* aNode, myChildren) {
345 aResult.append(aNode->objectCreated(theObjects));
351 QTreeNodesList PartSet_ObjectNode::objectsDeleted(
352 const DocumentPtr& theDoc, const QString& theGroup)
354 QTreeNodesList aResult;
355 int aNb = numberOfSubs();
356 if (aNb != myChildren.size()) {
359 aResult.append(this);
362 // Delete extra objects
363 bool isDeleted = false;
365 ModuleBase_ITreeNode* aNode;
367 while (aId < myChildren.size()) {
368 aNode = myChildren.at(aId);
369 aObj = subObject(aId);
370 if (aNode->object() != aObj) {
371 myChildren.removeAll(aNode);
379 aResult.append(this);
382 foreach(ModuleBase_ITreeNode* aNode, myChildren) {
383 aBody = subObject(i);
384 ((PartSet_ObjectNode*)aNode)->setObject(aBody);
385 aResult.append(aNode->objectsDeleted(theDoc, theGroup));
392 //////////////////////////////////////////////////////////////////////////////////
393 PartSet_FolderNode::PartSet_FolderNode(ModuleBase_ITreeNode* theParent,
395 : PartSet_TreeNode(theParent), myType(theType)
399 QString PartSet_FolderNode::name() const
402 case ParametersFolder:
403 return QObject::tr("Parameters");
404 case ConstructionFolder:
405 return QObject::tr("Constructions");
407 return QObject::tr("Parts");
409 return QObject::tr("Results");
411 return QObject::tr("Fields");
413 return QObject::tr("Groups");
419 QVariant PartSet_FolderNode::data(int theColumn, int theRole) const
421 static QIcon aParamsIco(":pictures/params_folder.png");
422 static QIcon aConstrIco(":pictures/constr_folder.png");
424 if (theColumn == 1) {
426 case Qt::DisplayRole:
427 return name() + QString(" (%1)").arg(childrenCount());
428 case Qt::DecorationRole:
430 case ParametersFolder:
432 case ConstructionFolder:
445 if ((theColumn == 2) && (theRole == Qt::DecorationRole)) {
446 if (document().get()) {
447 SessionPtr aSession = ModelAPI_Session::get();
448 if (document() != aSession->activeDocument())
451 FeaturePtr aFeature = document()->currentFeature(true);
452 if (!aFeature.get()) { // There is no current feature
453 ModuleBase_ITreeNode* aLastFolder = 0;
454 foreach(ModuleBase_ITreeNode* aNode, parent()->children()) {
455 if (aNode->type() == PartSet_FolderNode::typeId())
460 if (aLastFolder == this)
461 return QIcon(":pictures/arrow.png");
467 return PartSet_TreeNode::data(theColumn, theRole);
470 Qt::ItemFlags PartSet_FolderNode::flags(int theColumn) const
472 SessionPtr aSession = ModelAPI_Session::get();
473 DocumentPtr aActiveDoc = aSession->activeDocument();
474 if (theColumn == 1) {
475 if (document() == aActiveDoc)
481 ModuleBase_ITreeNode* PartSet_FolderNode::createNode(const ObjectPtr& theObj)
483 //ResultCompSolidPtr aCompRes = std::dynamic_pointer_cast<ModelAPI_ResultCompSolid>(theObj);
484 //if (aCompRes.get())
485 // return new PartSet_CompsolidNode(theObj, this);
486 ModuleBase_ITreeNode* aNode = new PartSet_ObjectNode(theObj, this);
491 void PartSet_FolderNode::update()
493 DocumentPtr aDoc = document();
497 // Remove extra sub-nodes
500 while (aId < myChildren.size()) {
501 ModuleBase_ITreeNode* aNode = myChildren.at(aId);
502 aIndex = aDoc->index(aNode->object(), true);
503 if ((aIndex == -1) || (aId != aIndex)) {
504 myChildren.removeAll(aNode);
511 std::string aGroup = groupName();
512 int aSize = aDoc->size(aGroup, true);
513 for (int i = 0; i < aSize; i++) {
514 ObjectPtr aObj = aDoc->object(aGroup, i, true);
515 if (i < myChildren.size()) {
516 if (myChildren.at(i)->object() != aObj) {
517 ModuleBase_ITreeNode* aNode = createNode(aObj);
518 myChildren.insert(i, aNode);
521 ModuleBase_ITreeNode* aNode = createNode(aObj);
522 myChildren.append(aNode);
526 foreach(ModuleBase_ITreeNode* aNode, myChildren) {
531 std::string PartSet_FolderNode::groupName() const
534 case ParametersFolder:
535 return ModelAPI_ResultParameter::group();
536 case ConstructionFolder:
537 return ModelAPI_ResultConstruction::group();
539 return ModelAPI_ResultPart::group();
541 return ModelAPI_ResultBody::group();
543 return ModelAPI_ResultField::group();
545 return ModelAPI_ResultGroup::group();
550 QTreeNodesList PartSet_FolderNode::objectCreated(const QObjectPtrList& theObjects)
552 QTreeNodesList aResult;
553 std::string aName = groupName();
554 DocumentPtr aDoc = document();
556 QMap<int, ModuleBase_ITreeNode*> aNewNodes;
557 foreach(ObjectPtr aObj, theObjects) {
558 if ((aObj->document() == aDoc) && (aObj->groupName() == aName)) {
559 aIdx = aDoc->index(aObj, true);
561 bool aHasObject = (aIdx < myChildren.size()) && (myChildren.at(aIdx)->object() == aObj);
563 ModuleBase_ITreeNode* aNode = createNode(aObj);
564 aNewNodes[aIdx] = aNode;
565 aResult.append(aNode);
571 // Add nodes in correct order
572 if (aNewNodes.size() > 0) {
574 for (i = 0; i < myChildren.size(); i++) {
575 if (aNewNodes.contains(i)) {
576 myChildren.insert(i, aNewNodes[i]);
580 while (aNewNodes.size()) {
581 i = myChildren.size();
582 myChildren.append(aNewNodes[i]);
586 foreach(ModuleBase_ITreeNode* aNode, myChildren) {
587 aResult.append(aNode->objectCreated(theObjects));
592 QTreeNodesList PartSet_FolderNode::objectsDeleted(const DocumentPtr& theDoc,
593 const QString& theGroup)
595 DocumentPtr aDoc = document();
596 QTreeNodesList aResult;
597 if ((theGroup.toStdString() == groupName()) && (theDoc == aDoc)) {
598 QTreeNodesList aDelList;
601 bool aRemoved = false;
602 bool aToSort = false;
603 while (aId < myChildren.size()) {
604 ModuleBase_ITreeNode* aNode = myChildren.at(aId);
605 aIndex = aDoc->index(aNode->object(), true);
606 aToSort |= ((aIndex != -1) && (aId != aIndex));
608 myChildren.removeAll(aNode);
616 aResult.append(this);
619 foreach(ModuleBase_ITreeNode* aNode, myChildren) {
620 aResult.append(aNode->objectsDeleted(theDoc, theGroup));
626 //////////////////////////////////////////////////////////////////////////////////
627 QTreeNodesList PartSet_FeatureFolderNode::objectCreated(const QObjectPtrList& theObjects)
629 QTreeNodesList aResult;
630 // Process the root sub-objects
631 DocumentPtr aDoc = document();
633 int aNb = numberOfFolders();
634 QMap<int, ModuleBase_ITreeNode*> aNewNodes;
635 foreach(ObjectPtr aObj, theObjects) {
636 if (aDoc == aObj->document()) {
637 if ((aObj->groupName() == ModelAPI_Feature::group()) ||
638 (aObj->groupName() == ModelAPI_Folder::group())){
639 aIdx = aDoc->index(aObj, true);
641 ModuleBase_ITreeNode* aNode = createNode(aObj);
643 bool aHasObject = (aIdx < myChildren.size()) && (myChildren.at(aIdx)->object() == aObj);
645 aNewNodes[aIdx] = aNode;
646 aResult.append(aNode);
653 // To add in correct order
654 if (aNewNodes.size() > 0) {
656 for (i = 0; i < myChildren.size(); i++) {
657 if (aNewNodes.contains(i)) {
658 myChildren.insert(i, aNewNodes[i]);
662 while (aNewNodes.size()) {
663 i = myChildren.size();
664 if (aNewNodes.contains(i)) {
665 myChildren.append(aNewNodes[i]);
670 // Update sub-folders
671 foreach(ModuleBase_ITreeNode* aNode, myChildren) {
672 aResult.append(aNode->objectCreated(theObjects));
677 QTreeNodesList PartSet_FeatureFolderNode::objectsDeleted(const DocumentPtr& theDoc,
678 const QString& theGroup)
680 QTreeNodesList aResult;
682 // Process sub-folders
683 foreach(ModuleBase_ITreeNode* aNode, myChildren) {
684 if (aNode->childrenCount() > 0) { // aFolder node
685 QTreeNodesList aList = aNode->objectsDeleted(theDoc, theGroup);
686 if (aList.size() > 0)
687 aResult.append(aList);
692 DocumentPtr aDoc = document();
693 int aNb = numberOfFolders();
694 bool isGroup = ((theGroup.toStdString() == ModelAPI_Feature::group()) ||
695 (theGroup.toStdString() == ModelAPI_Folder::group()));
696 if ((theDoc == aDoc) && isGroup) {
699 bool aRemoved = false;
700 bool aToSort = false;
701 while (aId < myChildren.size()) {
702 ModuleBase_ITreeNode* aNode = myChildren.at(aId);
703 if (aNode->object().get()) {
704 aIndex = aDoc->index(aNode->object(), true);
705 aToSort |= ((aIndex != -1) && (aId != (aIndex + aNb)));
707 myChildren.removeAll(aNode);
716 aResult.append(this);
723 ModuleBase_ITreeNode* PartSet_FeatureFolderNode::findParent(const DocumentPtr& theDoc,
726 ModuleBase_ITreeNode* aResult = 0;
727 foreach(ModuleBase_ITreeNode* aNode, myChildren) {
728 aResult = aNode->findParent(theDoc, theGroup);
733 bool isGroup = ((theGroup.toStdString() == ModelAPI_Feature::group()) ||
734 (theGroup.toStdString() == ModelAPI_Folder::group()));
735 if ((theDoc == document()) && isGroup)
741 //////////////////////////////////////////////////////////////////////////////////
742 PartSet_RootNode::PartSet_RootNode() : PartSet_FeatureFolderNode(0), myWorkshop(0)
744 SessionPtr aSession = ModelAPI_Session::get();
745 DocumentPtr aDoc = aSession->moduleDocument();
747 myParamsFolder = new PartSet_FolderNode(this, PartSet_FolderNode::ParametersFolder);
748 myConstrFolder = new PartSet_FolderNode(this, PartSet_FolderNode::ConstructionFolder);
749 myPartsFolder = new PartSet_FolderNode(this, PartSet_FolderNode::PartsFolder);
751 myChildren.append(myParamsFolder);
752 myChildren.append(myConstrFolder);
753 myChildren.append(myPartsFolder);
759 void PartSet_RootNode::update()
761 myParamsFolder->update();
762 myConstrFolder->update();
763 myPartsFolder->update();
765 // Update features content
766 DocumentPtr aDoc = document();
767 int aNb = numberOfFolders();
769 // Remove extra sub-nodes
772 while (aId < myChildren.size()) {
773 ModuleBase_ITreeNode* aNode = myChildren.at(aId);
774 if (aNode->object().get()) {
775 aIndex = aDoc->index(aNode->object(), true);
776 if ((aIndex == -1) || (aId != (aIndex + aNb))) {
777 myChildren.removeAll(aNode);
786 std::string aGroup = ModelAPI_Feature::group();
787 int aSize = aDoc->size(aGroup, true);
789 for (int i = 0; i < aSize; i++) {
790 ObjectPtr aObj = aDoc->object(aGroup, i, true);
791 aId = i + aNb; // Take into account existing folders
792 if (aId < myChildren.size()) {
793 if (myChildren.at(aId)->object() != aObj) {
794 ModuleBase_ITreeNode* aNode = createNode(aObj);
795 myChildren.insert(aId, aNode);
798 ModuleBase_ITreeNode* aNode = createNode(aObj);
799 myChildren.append(aNode);
802 // Update sub-folders
803 foreach(ModuleBase_ITreeNode* aNode, myChildren) {
804 if ((aNode->type() == PartSet_ObjectFolderNode::typeId()) ||
805 (aNode->type() == PartSet_PartRootNode::typeId()))
810 DocumentPtr PartSet_RootNode::document() const
812 return ModelAPI_Session::get()->moduleDocument();
815 ModuleBase_ITreeNode* PartSet_RootNode::createNode(const ObjectPtr& theObj)
817 if (theObj->groupName() == ModelAPI_Folder::group())
818 return new PartSet_ObjectFolderNode(theObj, this);
820 FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(theObj);
821 if (aFeature->getKind() == PartSetPlugin_Part::ID())
822 return new PartSet_PartRootNode(theObj, this);
824 PartSet_ObjectNode* aNode = new PartSet_ObjectNode(theObj, this);
829 //////////////////////////////////////////////////////////////////////////////////
830 PartSet_PartRootNode::PartSet_PartRootNode(const ObjectPtr& theObj, ModuleBase_ITreeNode* theParent)
831 : PartSet_FeatureFolderNode(theParent), myObject(theObj)
833 myParamsFolder = new PartSet_FolderNode(this, PartSet_FolderNode::ParametersFolder);
834 myConstrFolder = new PartSet_FolderNode(this, PartSet_FolderNode::ConstructionFolder);
835 myResultsFolder = new PartSet_FolderNode(this, PartSet_FolderNode::ResultsFolder);
836 myFieldsFolder = new PartSet_FolderNode(this, PartSet_FolderNode::FieldsFolder);
837 myGroupsFolder = new PartSet_FolderNode(this, PartSet_FolderNode::GroupsFolder);
839 myChildren.append(myParamsFolder);
840 myChildren.append(myConstrFolder);
841 myChildren.append(myResultsFolder);
846 void PartSet_PartRootNode::deleteChildren()
848 if (!myFieldsFolder->childrenCount()) {
849 delete myFieldsFolder;
851 if (!myGroupsFolder->childrenCount()) {
852 delete myGroupsFolder;
854 PartSet_FeatureFolderNode::deleteChildren();
858 void PartSet_PartRootNode::update()
860 DocumentPtr aDoc = document();
864 myParamsFolder->update();
865 myConstrFolder->update();
866 myResultsFolder->update();
867 myFieldsFolder->update();
868 myGroupsFolder->update();
870 bool aHasFields = myFieldsFolder->childrenCount() > 0;
871 bool aHasGroups = myGroupsFolder->childrenCount() > 0;
873 if (!myChildren.contains(myFieldsFolder)) {
874 myChildren.insert(3, myFieldsFolder);
876 } else if (myChildren.contains(myFieldsFolder)) {
877 myChildren.removeAll(myFieldsFolder);
880 if (!myChildren.contains(myGroupsFolder)) {
881 myChildren.insert(aHasFields ? 4 : 3, myGroupsFolder);
883 } else if (myChildren.contains(myGroupsFolder)) {
884 myChildren.removeAll(myGroupsFolder);
887 // Update features content
888 int aRows = numberOfFolders();
890 // Remove extra sub-nodes
893 QMap<int, ModuleBase_ITreeNode*> aExistingNodes;
894 while (aId < myChildren.size()) {
895 ModuleBase_ITreeNode* aNode = myChildren.at(aId);
896 if (aNode->object().get()) {
897 aIndex = aDoc->index(aNode->object(), true);
898 if ((aIndex == -1) || (aId != (aIndex + aRows))) {
899 myChildren.removeAll(aNode);
903 aExistingNodes[aIndex + aRows] = aNode;
910 std::string aGroup = ModelAPI_Feature::group();
911 int aSize = aDoc->size(aGroup, true);
913 for (int i = 0; i < aSize; i++) {
914 ObjectPtr aObj = aDoc->object(aGroup, i, true);
915 aId = i + aRows; // Take into account existing folders
916 if (aId < myChildren.size()) {
917 if (myChildren.at(aId)->object() != aObj) {
918 if (aExistingNodes.contains(aId)) {
919 myChildren.insert(aId, aExistingNodes[aId]);
920 aExistingNodes.remove(aId);
923 myChildren.insert(aId, createNode(aObj));
927 if (aExistingNodes.contains(myChildren.size()))
928 myChildren.append(aExistingNodes[myChildren.size()]);
930 myChildren.append(createNode(aObj));
933 // Update sub-folders
934 foreach(ModuleBase_ITreeNode* aNode, myChildren) {
935 if (aNode->type() == PartSet_ObjectFolderNode::typeId())
940 DocumentPtr PartSet_PartRootNode::document() const
942 ResultPartPtr aPartRes = getPartResult(myObject);
944 return aPartRes->partDoc();
945 return DocumentPtr();
948 QVariant PartSet_PartRootNode::data(int theColumn, int theRole) const
953 case Qt::DisplayRole:
955 ResultPartPtr aPartRes = getPartResult(myObject);
956 if (aPartRes.get()) {
957 if (aPartRes->partDoc().get() == NULL)
958 return QString(myObject->data()->name().c_str()) + " (Not loaded)";
960 return QString(myObject->data()->name().c_str());
962 case Qt::DecorationRole:
963 return ModuleBase_IconFactory::get()->getIcon(myObject);
966 if (theRole == Qt::DecorationRole) {
967 if (isCurrentFeature(myObject))
968 return QIcon(":pictures/arrow.png");
973 return PartSet_TreeNode::data(theColumn, theRole);
976 Qt::ItemFlags PartSet_PartRootNode::flags(int theColumn) const
978 if (myObject->isDisabled())
979 return (theColumn == 2) ? Qt::ItemIsSelectable : aNullFlag;
981 SessionPtr aSession = ModelAPI_Session::get();
982 DocumentPtr aActiveDoc = aSession->activeDocument();
983 if ((aActiveDoc == document()) || (myObject->document() == aActiveDoc))
988 ModuleBase_ITreeNode* PartSet_PartRootNode::createNode(const ObjectPtr& theObj)
990 if (theObj->groupName() == ModelAPI_Folder::group())
991 return new PartSet_ObjectFolderNode(theObj, this);
992 PartSet_ObjectNode* aNode = new PartSet_ObjectNode(theObj, this);
997 int PartSet_PartRootNode::numberOfFolders() const
1000 if (myFieldsFolder->childrenCount() > 0)
1002 if (myGroupsFolder->childrenCount() > 0)
1007 QTreeNodesList PartSet_PartRootNode::objectCreated(const QObjectPtrList& theObjects)
1009 QTreeNodesList aResult = PartSet_FeatureFolderNode::objectCreated(theObjects);
1010 if (!myFieldsFolder->childrenCount()) {
1011 QTreeNodesList aList = myFieldsFolder->objectCreated(theObjects);
1013 myChildren.insert(3, myFieldsFolder);
1014 aResult.append(myFieldsFolder);
1015 aResult.append(aList);
1018 if (!myGroupsFolder->childrenCount()) {
1019 QTreeNodesList aList = myGroupsFolder->objectCreated(theObjects);
1021 myChildren.insert(myFieldsFolder->childrenCount()? 4 : 3, myGroupsFolder);
1022 aResult.append(myGroupsFolder);
1023 aResult.append(aList);
1029 QTreeNodesList PartSet_PartRootNode::objectsDeleted(const DocumentPtr& theDoc,
1030 const QString& theGroup)
1032 QTreeNodesList aResult;
1033 if (myFieldsFolder->childrenCount()) {
1034 QTreeNodesList aList = myFieldsFolder->objectsDeleted(theDoc, theGroup);
1036 aResult.append(aList);
1037 if (!myFieldsFolder->childrenCount())
1038 myChildren.removeAll(myFieldsFolder);
1041 if (myGroupsFolder->childrenCount()) {
1042 QTreeNodesList aList = myGroupsFolder->objectsDeleted(theDoc, theGroup);
1044 aResult.append(aList);
1045 if (!myGroupsFolder->childrenCount())
1046 myChildren.removeAll(myGroupsFolder);
1049 aResult.append(PartSet_FeatureFolderNode::objectsDeleted(theDoc, theGroup));
1053 //////////////////////////////////////////////////////////////////////////////////
1054 void PartSet_ObjectFolderNode::update()
1056 int aFirst = -1, aLast = -1;
1057 PartSet_Tools::getFirstAndLastIndexInFolder(myObject, aFirst, aLast);
1058 if ((aFirst == -1) || (aLast == -1)) {
1063 int aNbItems = aLast - aFirst + 1;
1069 DocumentPtr aDoc = myObject->document();
1070 if (aNbItems < myChildren.size()) {
1071 // Delete obsolete nodes
1073 int aNbOfFeatures = aDoc->size(ModelAPI_Feature::group(), true);
1074 while (aId < myChildren.size()) {
1075 ModuleBase_ITreeNode* aNode = myChildren.at(aId);
1076 if ((aFirst + aId) < aNbOfFeatures) {
1077 if (aNode->object() != aDoc->object(ModelAPI_Feature::group(), aFirst + aId)) {
1078 myChildren.removeAll(aNode);
1084 myChildren.removeAll(aNode);
1091 if (aNbItems > myChildren.size()) {
1093 ModuleBase_ITreeNode* aNode;
1094 for (int i = 0; i < aNbItems; i++) {
1095 ObjectPtr aObj = aDoc->object(ModelAPI_Feature::group(), aFirst + i);
1096 if (i < myChildren.size()) {
1097 if (aObj != myChildren.at(i)->object()) {
1098 aNode = new PartSet_ObjectNode(aObj, this);
1099 myChildren.insert(i, aNode);
1104 aNode = new PartSet_ObjectNode(aObj, this);
1105 myChildren.append(aNode);
1112 QTreeNodesList PartSet_ObjectFolderNode::objectCreated(const QObjectPtrList& theObjects)
1114 QTreeNodesList aResult;
1115 int aFirst = -1, aLast = -1;
1116 PartSet_Tools::getFirstAndLastIndexInFolder(myObject, aFirst, aLast);
1117 if ((aFirst == -1) || (aLast == -1)) {
1120 int aNbItems = aLast - aFirst + 1;
1124 DocumentPtr aDoc = myObject->document();
1126 ModuleBase_ITreeNode* aNode;
1127 for (int i = 0; i < aNbItems; i++) {
1128 ObjectPtr aObj = aDoc->object(ModelAPI_Feature::group(), aFirst + i);
1129 if (i < myChildren.size()) {
1130 if (aObj != myChildren.at(i)->object()) {
1131 aNode = new PartSet_ObjectNode(aObj, this);
1132 myChildren.insert(i, aNode);
1133 aResult.append(aNode);
1137 aNode = new PartSet_ObjectNode(aObj, this);
1138 myChildren.append(aNode);
1139 aResult.append(aNode);
1146 QTreeNodesList PartSet_ObjectFolderNode::objectsDeleted(const DocumentPtr& theDoc,
1147 const QString& theGroup)
1149 QTreeNodesList aResult;
1150 int aFirst = -1, aLast = -1;
1151 PartSet_Tools::getFirstAndLastIndexInFolder(myObject, aFirst, aLast);
1152 if ((aFirst == -1) || (aLast == -1)) {
1155 int aNbItems = aLast - aFirst + 1;
1159 if (aNbItems >= myChildren.size()) // Nothing was deleted here
1162 DocumentPtr aDoc = myObject->document();
1163 // Delete obsolete nodes
1164 bool aRemoved = false;
1166 int aNbOfFeatures = aDoc->size(ModelAPI_Feature::group(), true);
1167 while (aId < myChildren.size()) {
1168 ModuleBase_ITreeNode* aNode = myChildren.at(aId);
1169 if ((aFirst + aId) < aNbOfFeatures) {
1170 if (aNode->object() != aDoc->object(ModelAPI_Feature::group(), aFirst + aId)) {
1171 myChildren.removeAll(aNode);
1178 myChildren.removeAll(aNode);
1179 aResult.removeAll(aNode);
1187 aResult.append(this);
1194 //////////////////////////////////////////////////////////////////////////////////
1195 QVariant PartSet_StepNode::data(int theColumn, int theRole) const
1197 if ((theColumn == 1) && (theRole == Qt::DisplayRole)) {
1198 ModelAPI_ResultField::ModelAPI_FieldStep* aStep =
1199 dynamic_cast<ModelAPI_ResultField::ModelAPI_FieldStep*>(myEntity);
1201 return "Step " + QString::number(aStep->id() + 1) + " " +
1202 aStep->field()->textLine(aStep->id()).c_str();
1204 return PartSet_TreeNode::data(theColumn, theRole);