]> SALOME platform Git repositories - modules/shaper.git/blob - src/XGUI/XGUI_PartDataModel.cpp
Salome HOME
Corrections for extrusion/revolution xml definition and random color
[modules/shaper.git] / src / XGUI / XGUI_PartDataModel.cpp
1 // Copyright (C) 2014-20xx CEA/DEN, EDF R&D -->
2
3 #include "XGUI_PartDataModel.h"
4 #include "XGUI_Workshop.h"
5
6 #include <ModelAPI_Session.h>
7 #include <ModelAPI_Document.h>
8 #include <ModelAPI_Feature.h>
9 #include <ModelAPI_Result.h>
10 #include <ModelAPI_Data.h>
11 #include <ModelAPI_AttributeDocRef.h>
12 #include <ModelAPI_Object.h>
13 #include <ModelAPI_ResultPart.h>
14 #include <ModelAPI_ResultConstruction.h>
15 #include <ModelAPI_ResultParameter.h>
16 #include <ModelAPI_ResultBody.h>
17 #include <ModelAPI_ResultGroup.h>
18 #include <ModelAPI_AttributeDouble.h>
19
20 #include <QIcon>
21 #include <QBrush>
22
23 //ObjectPtr featureObj(const ObjectPtr& theFeature)
24 //{
25 //  ObjectPtr aObject = std::dynamic_pointer_cast<ModelAPI_Object>(theFeature);
26 //  if (aObject)
27 //    return aObject->featureRef();
28 //  return theFeature;
29 //}
30
31 XGUI_TopDataModel::XGUI_TopDataModel(QObject* theParent)
32     : XGUI_FeaturesModel(theParent)
33 {
34 }
35
36 XGUI_TopDataModel::~XGUI_TopDataModel()
37 {
38 }
39
40 QVariant XGUI_TopDataModel::data(const QModelIndex& theIndex, int theRole) const
41 {
42   switch (theRole) {
43     case Qt::DisplayRole:
44       // return a name
45       switch (theIndex.internalId()) {
46         case ParamsFolder:
47           return tr("Parameters") + QString(" (%1)").arg(rowCount(theIndex));
48         case ParamObject: {
49           DocumentPtr aRootDoc = ModelAPI_Session::get()->moduleDocument();
50           ObjectPtr aObject = aRootDoc->object(ModelAPI_ResultParameter::group(), theIndex.row());
51           if (aObject) {
52             ResultParameterPtr aParam = std::dynamic_pointer_cast<ModelAPI_ResultParameter>(aObject);
53             AttributeDoublePtr aValueAttribute = aParam->data()->real(ModelAPI_ResultParameter::VALUE());
54             QString aVal = QString::number(aValueAttribute->value());
55             QString aTitle = QString(aObject->data()->name().c_str());
56             return aTitle + " = " + aVal;
57           }
58         }
59           break;
60         case ConstructFolder:
61           return tr("Constructions") + QString(" (%1)").arg(rowCount(theIndex));
62         case ConstructObject: {
63           DocumentPtr aRootDoc = ModelAPI_Session::get()->moduleDocument();
64           ObjectPtr aObject = aRootDoc->object(ModelAPI_ResultConstruction::group(),
65                                                theIndex.row());
66           if (aObject)
67             return aObject->data()->name().c_str();
68         }
69           break;
70         //case GroupsFolder:
71         //  return tr("Groups") + QString(" (%1)").arg(rowCount(theIndex));
72         //case GroupObject: {
73         //  DocumentPtr aRootDoc = ModelAPI_Session::get()->moduleDocument();
74         //  ObjectPtr aObject = aRootDoc->object(ModelAPI_ResultGroup::group(),
75         //                                       theIndex.row());
76         //  if (aObject)
77         //    return aObject->data()->name().c_str();
78         //}
79         //  break;
80       }
81       break;
82
83     case Qt::DecorationRole:
84       {
85       // return an Icon
86       switch (theIndex.internalId()) {
87         case ParamsFolder:
88           return QIcon(":pictures/params_folder.png");
89         case ConstructFolder:
90           return QIcon(":pictures/constr_folder.png");
91         case ConstructObject:
92           return QIcon(":pictures/constr_object.png");
93         //case GroupsFolder:
94         //  return QIcon(":pictures/constr_folder.png");
95         }
96       }
97       break;
98
99     case Qt::ToolTipRole:
100       // return Tooltip
101       break;
102     case Qt::ForegroundRole:
103       return QBrush(myItemsColor);
104       break;
105   }
106   return QVariant();
107 }
108
109 QVariant XGUI_TopDataModel::headerData(int section, Qt::Orientation orientation, int role) const
110 {
111   return QVariant();
112 }
113
114 int XGUI_TopDataModel::rowCount(const QModelIndex& theParent) const
115 {
116   if (!theParent.isValid())
117     return 2;  // In case of groups using it has to be +1
118
119   DocumentPtr aRootDoc = ModelAPI_Session::get()->moduleDocument();
120   if (theParent.internalId() == ParamsFolder)
121     return aRootDoc->size(ModelAPI_ResultParameter::group());
122
123   if (theParent.internalId() == ConstructFolder)
124     return aRootDoc->size(ModelAPI_ResultConstruction::group());
125
126   //if (theParent.internalId() == GroupsFolder)
127   //  return aRootDoc->size(ModelAPI_ResultGroup::group());
128
129   return 0;
130 }
131
132 int XGUI_TopDataModel::columnCount(const QModelIndex &parent) const
133 {
134   return 1;
135 }
136
137 QModelIndex XGUI_TopDataModel::index(int theRow, int theColumn, const QModelIndex& theParent) const
138 {
139   if (!theParent.isValid()) {
140     switch (theRow) {
141       case 0:
142         return createIndex(theRow, theColumn, (qint32) ParamsFolder);
143       case 1:
144         return createIndex(theRow, theColumn, (qint32) ConstructFolder);
145       //case 2:
146       //  return createIndex(theRow, theColumn, (qint32) GroupsFolder);
147     }
148   } else {
149     if (theParent.internalId() == ParamsFolder)
150       return createIndex(theRow, theColumn, (qint32) ParamObject);
151
152     if (theParent.internalId() == ConstructFolder)
153       return createIndex(theRow, theColumn, (qint32) ConstructObject);
154
155     //if (theParent.internalId() == GroupsFolder)
156     //  return createIndex(theRow, theColumn, (qint32) GroupObject);
157   }
158   return QModelIndex();
159 }
160
161 QModelIndex XGUI_TopDataModel::parent(const QModelIndex& theIndex) const
162 {
163   int aId = (int) theIndex.internalId();
164   switch (aId) {
165     case ParamsFolder:
166     case ConstructFolder:
167     //case GroupsFolder:
168       return QModelIndex();
169     case ParamObject:
170       return createIndex(0, 0, (qint32) ParamsFolder);
171     case ConstructObject:
172       return createIndex(1, 0, (qint32) ConstructFolder);
173     //case GroupObject:
174     //  return createIndex(2, 0, (qint32) GroupsFolder);
175   }
176   return QModelIndex();
177 }
178
179 bool XGUI_TopDataModel::hasChildren(const QModelIndex& theParent) const
180 {
181   return rowCount(theParent) > 0;
182 }
183
184 ObjectPtr XGUI_TopDataModel::object(const QModelIndex& theIndex) const
185 {
186   switch (theIndex.internalId()) {
187     case ParamsFolder:
188     case ConstructFolder:
189       return ObjectPtr();
190     case ParamObject: {
191       DocumentPtr aRootDoc = ModelAPI_Session::get()->moduleDocument();
192       return aRootDoc->object(ModelAPI_ResultParameter::group(), theIndex.row());
193     }
194     case ConstructObject: {
195       DocumentPtr aRootDoc = ModelAPI_Session::get()->moduleDocument();
196       return aRootDoc->object(ModelAPI_ResultConstruction::group(), theIndex.row());
197     }
198     //case GroupObject: {
199     //  DocumentPtr aRootDoc = ModelAPI_Session::get()->moduleDocument();
200     //  return aRootDoc->object(ModelAPI_ResultGroup::group(), theIndex.row());
201     //}
202   }
203   return ObjectPtr();
204 }
205
206 QModelIndex XGUI_TopDataModel::findParent(const ObjectPtr& theObject) const
207 {
208   return findGroup(theObject->groupName().c_str());
209 }
210
211 QModelIndex XGUI_TopDataModel::findGroup(const std::string& theGroup) const
212 {
213   if (theGroup == ModelAPI_ResultParameter::group())
214     return createIndex(0, 0, (qint32) ParamsFolder);
215   if (theGroup == ModelAPI_ResultConstruction::group())
216     return createIndex(1, 0, (qint32) ConstructFolder);
217   //if (theGroup == ModelAPI_ResultGroup::group())
218   //  return createIndex(2, 0, (qint32) ConstructFolder);
219   return QModelIndex();
220 }
221
222 QModelIndex XGUI_TopDataModel::objectIndex(const ObjectPtr& theObject) const
223 {
224   QModelIndex aIndex;
225   if (theObject) {
226     DocumentPtr aRootDoc = ModelAPI_Session::get()->moduleDocument();
227     std::string aGroup = theObject->groupName();
228     int aNb = aRootDoc->size(aGroup);
229     int aRow = -1;
230     for (int i = 0; i < aNb; i++) {
231       if (aRootDoc->object(aGroup, i) == theObject) {
232         aRow = i;
233         break;
234       }
235     }
236     if (aRow != -1) {
237       if (aGroup == ModelAPI_ResultParameter::group())
238         return createIndex(aRow, 0, (qint32) ParamObject);
239       if (aGroup == ModelAPI_ResultConstruction::group())
240         return createIndex(aRow, 0, (qint32) ConstructObject);
241       //if (aGroup == ModelAPI_ResultGroup::group())
242       //  return createIndex(aRow, 0, (qint32) GroupObject);
243     }
244   }
245   return aIndex;
246 }
247
248 //******************************************************************
249 //******************************************************************
250 //******************************************************************
251 XGUI_PartDataModel::XGUI_PartDataModel(QObject* theParent)
252     : XGUI_PartModel(theParent)
253 {
254 }
255
256 XGUI_PartDataModel::~XGUI_PartDataModel()
257 {
258 }
259
260 QVariant XGUI_PartDataModel::data(const QModelIndex& theIndex, int theRole) const
261 {
262   switch (theRole) {
263     case Qt::DisplayRole:
264       // return a name
265       switch (theIndex.internalId()) {
266         case MyRoot: {
267           DocumentPtr aRootDoc = ModelAPI_Session::get()->moduleDocument();
268           ObjectPtr aObject = aRootDoc->object(ModelAPI_ResultPart::group(), myId);
269           if (aObject)
270             return std::dynamic_pointer_cast<ModelAPI_Object>(aObject)->data()->name().c_str();
271         }
272         case ParamsFolder:
273           return tr("Parameters") + QString(" (%1)").arg(rowCount(theIndex));
274         case ConstructFolder:
275           return tr("Constructions") + QString(" (%1)").arg(rowCount(theIndex));
276         case BodiesFolder:
277           return tr("Bodies") + QString(" (%1)").arg(rowCount(theIndex));
278         case GroupsFolder:
279           return tr("Groups") + QString(" (%1)").arg(rowCount(theIndex));
280         case ParamObject: {
281           ObjectPtr aObject = partDocument()->object(ModelAPI_ResultParameter::group(),
282                                                      theIndex.row());
283           if (aObject) {
284             ResultParameterPtr aParam = std::dynamic_pointer_cast<ModelAPI_ResultParameter>(aObject);
285             AttributeDoublePtr aValueAttribute = aParam->data()->real(ModelAPI_ResultParameter::VALUE());
286             QString aVal = QString::number(aValueAttribute->value());
287             QString aTitle = QString(aObject->data()->name().c_str());
288             return aTitle + " = " + aVal;
289           }
290         }
291           break;
292         case ConstructObject: {
293           ObjectPtr aObject = partDocument()->object(ModelAPI_ResultConstruction::group(),
294                                                      theIndex.row());
295           if (aObject)
296             return std::dynamic_pointer_cast<ModelAPI_Object>(aObject)->data()->name().c_str();
297         }
298           break;
299         case BodiesObject: {
300           ObjectPtr aObject = partDocument()->object(ModelAPI_ResultBody::group(), theIndex.row());
301           if (aObject)
302             return aObject->data()->name().c_str();
303         }
304           break;
305         case GroupObject: {
306           ObjectPtr aObject = partDocument()->object(ModelAPI_ResultGroup::group(), theIndex.row());
307           if (aObject)
308             return aObject->data()->name().c_str();
309         }
310         case HistoryObject: {
311           ObjectPtr aObject = partDocument()->object(ModelAPI_Feature::group(), theIndex.row() - getRowsNumber());
312           if (aObject)
313             return aObject->data()->name().c_str();
314         }
315       }
316       break;
317     case Qt::DecorationRole:
318       // return an Icon
319       switch (theIndex.internalId()) {
320         case MyRoot:
321           return QIcon(":pictures/part_ico.png");
322         case ParamsFolder:
323           return QIcon(":pictures/params_folder.png");
324         case ConstructFolder:
325         case BodiesFolder:
326           return QIcon(":pictures/constr_folder.png");
327         case GroupsFolder:
328           return QIcon(":pictures/constr_folder.png");
329         case ConstructObject:
330         case GroupObject:
331         case BodiesObject: {
332           std::string aGroup = theIndex.internalId() == ConstructObject ?
333             ModelAPI_ResultConstruction::group() : ModelAPI_ResultBody::group();
334           ObjectPtr anObject = partDocument()->object(aGroup, theIndex.row());
335           if (anObject && anObject->data() && 
336               anObject->data()->execState() == ModelAPI_StateMustBeUpdated) {
337             return QIcon(":pictures/constr_object_modified.png");
338           }
339           return QIcon(":pictures/constr_object.png");
340         }
341         case HistoryObject: {
342           ObjectPtr aObject = partDocument()->object(ModelAPI_Feature::group(), theIndex.row() - getRowsNumber());
343           FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aObject);
344           if (aFeature)
345             return XGUI_Workshop::featureIcon(aFeature);
346         }
347       }
348       break;
349     case Qt::ToolTipRole:
350       // return Tooltip
351       break;
352     case Qt::ForegroundRole:
353       return QBrush(myItemsColor);
354       break;
355   }
356   return QVariant();
357 }
358
359 QVariant XGUI_PartDataModel::headerData(int section, Qt::Orientation orientation, int role) const
360 {
361   return QVariant();
362 }
363
364 int XGUI_PartDataModel::rowCount(const QModelIndex& parent) const
365 {
366   if (!parent.isValid()) {
367     DocumentPtr aRootDoc = ModelAPI_Session::get()->moduleDocument();
368     if (aRootDoc->object(ModelAPI_ResultPart::group(), myId))
369       return 1;
370     else
371       return 0;
372   }
373   switch (parent.internalId()) {
374     case MyRoot:
375       {
376         DocumentPtr aDoc = partDocument();
377         if (aDoc) {
378           return getRowsNumber() + aDoc->size(ModelAPI_Feature::group());
379         } else 
380           return 0;
381       }
382     case ParamsFolder:
383       return partDocument()->size(ModelAPI_ResultParameter::group());
384     case ConstructFolder:
385       return partDocument()->size(ModelAPI_ResultConstruction::group());
386     case BodiesFolder:
387       return partDocument()->size(ModelAPI_ResultBody::group());
388     case GroupsFolder:
389       return partDocument()->size(ModelAPI_ResultGroup::group());
390   }
391   return 0;
392 }
393
394 int XGUI_PartDataModel::columnCount(const QModelIndex &parent) const
395 {
396   return 1;
397 }
398
399 QModelIndex XGUI_PartDataModel::index(int theRow, int theColumn, const QModelIndex &theParent) const
400 {
401   if (!theParent.isValid())
402     return createIndex(theRow, 0, (qint32) MyRoot);
403
404   int aId = (int) theParent.internalId();
405   switch (aId) {
406     case MyRoot:
407       switch (theRow) {
408         case 0:
409           return createIndex(theRow, 0, (qint32) ParamsFolder);
410         case 1:
411           return createIndex(theRow, 0, (qint32) ConstructFolder);
412         case 2:
413           return createIndex(theRow, 0, (qint32) BodiesFolder);
414         case 3:
415           {
416           int aSize = partDocument()->size(ModelAPI_ResultGroup::group());
417           if (aSize > 0)
418             return createIndex(theRow, 0, (qint32) GroupsFolder);
419           else
420             return createIndex(theRow, theColumn, (qint32) HistoryObject);
421           }
422         default:
423           return createIndex(theRow, theColumn, (qint32) HistoryObject);
424       }
425     case ParamsFolder:
426       return createIndex(theRow, 0, (qint32) ParamObject);
427     case ConstructFolder:
428       return createIndex(theRow, 0, (qint32) ConstructObject);
429     case BodiesFolder:
430       return createIndex(theRow, 0, (qint32) BodiesObject);
431     case GroupsFolder:
432       return createIndex(theRow, 0, (qint32) GroupObject);
433   }
434   return QModelIndex();
435 }
436
437 QModelIndex XGUI_PartDataModel::parent(const QModelIndex& theIndex) const
438 {
439   switch (theIndex.internalId()) {
440     case MyRoot:
441       return QModelIndex();
442     case ParamsFolder:
443     case ConstructFolder:
444     case BodiesFolder:
445     case GroupsFolder:
446     case HistoryObject:
447       return createIndex(0, 0, (qint32) MyRoot);
448
449     case ParamObject:
450       return createIndex(0, 0, (qint32) ParamsFolder);
451     case ConstructObject:
452       return createIndex(1, 0, (qint32) ConstructFolder);
453     case BodiesObject:
454       return createIndex(2, 0, (qint32) BodiesFolder);
455     case GroupObject:
456       return createIndex(3, 0, (qint32) GroupsFolder);
457   }
458   return QModelIndex();
459 }
460
461 bool XGUI_PartDataModel::hasChildren(const QModelIndex& theParent) const
462 {
463   return rowCount(theParent) > 0;
464 }
465
466 DocumentPtr XGUI_PartDataModel::partDocument() const
467 {
468   DocumentPtr aRootDoc = ModelAPI_Session::get()->moduleDocument();
469   ObjectPtr aObject = aRootDoc->object(ModelAPI_ResultPart::group(), myId);
470   ResultPartPtr aPart = std::dynamic_pointer_cast<ModelAPI_ResultPart>(aObject);
471   if (aPart)
472     return aPart->partDoc();
473   return DocumentPtr(); // null if not found
474 }
475
476 ObjectPtr XGUI_PartDataModel::object(const QModelIndex& theIndex) const
477 {
478   switch (theIndex.internalId()) {
479     case MyRoot: {
480       DocumentPtr aRootDoc = ModelAPI_Session::get()->moduleDocument();
481       return aRootDoc->object(ModelAPI_ResultPart::group(), myId);
482     }
483     case ParamsFolder:
484     case ConstructFolder:
485     case BodiesFolder:
486     case GroupsFolder:
487       return ObjectPtr();
488
489     case ParamObject:
490       return partDocument()->object(ModelAPI_ResultParameter::group(), theIndex.row());
491     case ConstructObject:
492       return partDocument()->object(ModelAPI_ResultConstruction::group(), theIndex.row());
493     case BodiesObject:
494       return partDocument()->object(ModelAPI_ResultBody::group(), theIndex.row());
495     case GroupObject:
496       return partDocument()->object(ModelAPI_ResultGroup::group(), theIndex.row());
497     case HistoryObject:
498       return partDocument()->object(ModelAPI_Feature::group(), theIndex.row() - getRowsNumber());
499   }
500   return ObjectPtr();
501 }
502
503 bool XGUI_PartDataModel::hasDocument(const DocumentPtr& theDoc) const
504 {
505   return (partDocument() == theDoc);
506 }
507
508 QModelIndex XGUI_PartDataModel::findParent(const ObjectPtr& theObject) const
509 {
510   return findGroup(theObject->groupName().c_str());
511 }
512
513 QModelIndex XGUI_PartDataModel::findGroup(const std::string& theGroup) const
514 {
515   if (theGroup == ModelAPI_ResultParameter::group())
516     return createIndex(0, 0, (qint32) ParamsFolder);
517   if (theGroup == ModelAPI_ResultConstruction::group())
518     return createIndex(1, 0, (qint32) ConstructFolder);
519   if (theGroup == ModelAPI_ResultBody::group())
520     return createIndex(2, 0, (qint32) BodiesFolder);
521   if (theGroup == ModelAPI_ResultGroup::group())
522     return createIndex(3, 0, (qint32) GroupsFolder);
523   return QModelIndex();
524 }
525
526 ResultPartPtr XGUI_PartDataModel::part() const
527 {
528   DocumentPtr aRootDoc = ModelAPI_Session::get()->moduleDocument();
529   ObjectPtr aObj = aRootDoc->object(ModelAPI_ResultPart::group(), myId);
530   return std::dynamic_pointer_cast<ModelAPI_ResultPart>(aObj);
531 }
532
533 QModelIndex XGUI_PartDataModel::objectIndex(const ObjectPtr& theObject) const
534 {
535   QModelIndex aIndex;
536   if (theObject) {
537     if (part() == theObject)
538       return aIndex;
539
540     std::string aGroup = theObject->groupName();
541     DocumentPtr aDoc = theObject->document();
542     int aNb = aDoc->size(aGroup);
543     int aRow = -1;
544     for (int i = 0; i < aNb; i++) {
545       if (aDoc->object(aGroup, i) == theObject) {
546         aRow = i;
547         break;
548       }
549     }
550     if (aRow == -1)
551       return aIndex;
552     if (aGroup == ModelAPI_ResultParameter::group())
553       return createIndex(aRow, 0, (qint32) ParamObject);
554     else if (aGroup == ModelAPI_ResultConstruction::group())
555       return createIndex(aRow, 0, (qint32) ConstructObject);
556     else if (aGroup == ModelAPI_ResultBody::group())
557       return createIndex(aRow, 0, (qint32) BodiesObject);
558     else if (aGroup == ModelAPI_ResultGroup::group())
559       return createIndex(aRow, 0, (qint32) GroupObject);
560     else
561       return createIndex(aRow + getRowsNumber(), 0, (qint32) HistoryObject);
562   }
563   return aIndex;
564 }
565
566
567 int XGUI_PartDataModel::getRowsNumber() const
568 {
569   int aSize = partDocument()->size(ModelAPI_ResultGroup::group());
570   if (aSize == 0) // If there are no groups then do not show group folder
571     return 3;
572   return 4;
573 }