src/XGUI/XGUI_PartDataModel.cpp

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