src/XGUI/XGUI_PartDataModel.cpp

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