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