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 HistoryObject:
 291       {
 292         ObjectPtr aObject = partDocument()->object(ModelAPI_Feature::group(), theIndex.row() - 3);
 293         if (aObject)
 294           return aObject->data()->name().c_str();
 295       }
 296     }
 297     break;
 298   case Qt::DecorationRole:
 299     // return an Icon
 300     switch (theIndex.internalId()) {
 301     case MyRoot:
 302       return QIcon(":pictures/part_ico.png");
 303     case ParamsFolder:
 304       return QIcon(":pictures/params_folder.png");
 305     case ConstructFolder:
 306     case BodiesFolder:
 307       return QIcon(":pictures/constr_folder.png");
 308     case ConstructObject:
 309       return QIcon(":pictures/constr_object.png");
 310       //{
 311       //  ObjectPtr aObject = partDocument()->object(ModelAPI_ResultConstruction::group(), theIndex.row());
 312       //  if (aObject)
 313       //    return QIcon(XGUI_Workshop::featureIcon(aObject->getKind()));
 314       //}
 315     case HistoryObject:
 316       {
 317         ObjectPtr aObject = partDocument()->object(ModelAPI_Feature::group(), theIndex.row() - 3);
 318         FeaturePtr aFeature = boost::dynamic_pointer_cast<ModelAPI_Feature>(aObject);
 319         if (aFeature)
 320           return QIcon(XGUI_Workshop::featureIcon(aFeature->getKind()));
 321       }
 322     }
 323    break;
 324   case Qt::ToolTipRole:
 325     // return Tooltip
 326     break;
 327   case Qt::ForegroundRole:
 328     return QBrush(myItemsColor);
 329     break;
 330   }
 331   return QVariant();
 332 }
 333
 334 QVariant XGUI_PartDataModel::headerData(int section, Qt::Orientation orientation, int role) const
 335 {
 336   return QVariant();
 337 }
 338
 339 int XGUI_PartDataModel::rowCount(const QModelIndex& parent) const
 340 {
 341   if (!parent.isValid()) {
 342     DocumentPtr aRootDoc = ModelAPI_PluginManager::get()->rootDocument();
 343     if (aRootDoc->object(ModelAPI_ResultPart::group(), myId))
 344       return 1;
 345     else
 346       return 0;
 347   }
 348   switch (parent.internalId()) {
 349   case MyRoot:
 350     return 3 + partDocument()->size(ModelAPI_Feature::group());
 351   case ParamsFolder:
 352     return partDocument()->size(ModelAPI_ResultParameters::group());
 353   case ConstructFolder:
 354     return partDocument()->size(ModelAPI_ResultConstruction::group());
 355   case BodiesFolder:
 356     return 0;
 357   }
 358   return 0;
 359 }
 360
 361 int XGUI_PartDataModel::columnCount(const QModelIndex &parent) const
 362 {
 363   return 1;
 364 }
 365
 366 QModelIndex XGUI_PartDataModel::index(int theRow, int theColumn, const QModelIndex &theParent) const
 367 {
 368   if (!theParent.isValid())
 369     return createIndex(theRow, 0, (qint32) MyRoot);
 370
 371   int aId = (int)theParent.internalId();
 372   switch (aId) {
 373   case MyRoot:
 374     switch (theRow) {
 375     case 0:
 376       return createIndex(0, 0, (qint32) ParamsFolder);
 377     case 1:
 378       return createIndex(1, 0, (qint32) ConstructFolder);
 379     case 2:
 380       return createIndex(2, 0, (qint32) BodiesFolder);
 381     default:
 382       return createIndex(theRow, theColumn, (qint32) HistoryObject);
 383     }
 384   case ParamsFolder:
 385     return createIndex(theRow, 0, (qint32) ParamObject);
 386   case ConstructFolder:
 387     return createIndex(theRow, 0, (qint32) ConstructObject);
 388   case BodiesFolder:
 389     return createIndex(theRow, 0, (qint32) BodiesObject);
 390   }
 391   return QModelIndex();
 392 }
 393
 394 QModelIndex XGUI_PartDataModel::parent(const QModelIndex& theIndex) const
 395 {
 396   switch (theIndex.internalId()) {
 397   case MyRoot:
 398     return QModelIndex();
 399   case ParamsFolder:
 400   case ConstructFolder:
 401   case BodiesFolder:
 402   case HistoryObject:
 403     return createIndex(0, 0, (qint32) MyRoot);
 404   case ParamObject:
 405     return createIndex(0, 0, (qint32) ParamsFolder);
 406   case ConstructObject:
 407     return createIndex(1, 0, (qint32) ConstructFolder);
 408   }
 409   return QModelIndex();
 410 }
 411
 412 bool XGUI_PartDataModel::hasChildren(const QModelIndex& theParent) const
 413 {
 414   return rowCount(theParent) > 0;
 415 }
 416
 417
 418 DocumentPtr XGUI_PartDataModel::partDocument() const
 419 {
 420   DocumentPtr aRootDoc = ModelAPI_PluginManager::get()->rootDocument();
 421   ObjectPtr aObject = aRootDoc->object(ModelAPI_ResultPart::group(), myId);
 422   ResultPartPtr aPart = boost::dynamic_pointer_cast<ModelAPI_ResultPart>(aObject);
 423   return aPart->partDoc();
 424 }
 425
 426 ObjectPtr XGUI_PartDataModel::object(const QModelIndex& theIndex) const
 427 {
 428   switch (theIndex.internalId()) {
 429   case MyRoot:
 430     {
 431       DocumentPtr aRootDoc = ModelAPI_PluginManager::get()->rootDocument();
 432       return aRootDoc->object(ModelAPI_ResultPart::group(), myId);
 433     }
 434   case ParamsFolder:
 435   case ConstructFolder:
 436   case BodiesFolder:
 437     return ObjectPtr();
 438   case ParamObject:
 439     return partDocument()->object(ModelAPI_ResultParameters::group(), theIndex.row());
 440   case ConstructObject:
 441     return partDocument()->object(ModelAPI_ResultConstruction::group(), theIndex.row());
 442   //case BodiesObject:
 443   //  return partDocument()->feature(ModelAPI_ResultConstruction::group(), theIndex.row());
 444   case HistoryObject:
 445     return partDocument()->object(ModelAPI_Feature::group(), theIndex.row() - 3);
 446   }
 447   return ObjectPtr();
 448 }
 449
 450 bool XGUI_PartDataModel::hasDocument(const DocumentPtr& theDoc) const
 451 {
 452   return (partDocument() == theDoc);
 453 }
 454
 455
 456 QModelIndex XGUI_PartDataModel::findParent(const ObjectPtr& theObject) const
 457 {
 458   return findGroup(theObject->groupName().c_str());
 459 }
 460
 461 QModelIndex XGUI_PartDataModel::findGroup(const std::string& theGroup) const
 462 {
 463   if (theGroup.compare(ModelAPI_ResultParameters::group()) == 0)
 464     return createIndex(0, 0, (qint32) ParamsFolder);
 465   if (theGroup.compare(ModelAPI_ResultConstruction::group()) == 0)
 466     return createIndex(1, 0, (qint32) ConstructFolder);
 467   return QModelIndex();
 468 }
 469
 470 ResultPartPtr XGUI_PartDataModel::part() const
 471 {
 472   DocumentPtr aRootDoc = ModelAPI_PluginManager::get()->rootDocument();
 473   ObjectPtr aObj = aRootDoc->object(ModelAPI_ResultPart::group(), myId);
 474   return boost::dynamic_pointer_cast<ModelAPI_ResultPart>(aObj);
 475 }
 476
 477 QModelIndex XGUI_PartDataModel::objectIndex(const ObjectPtr& theObject) const
 478 {
 479   QModelIndex aIndex;
 480   if (theObject) {
 481     if (part() == theObject)
 482       return aIndex;
 483
 484     //std::string aGroup = theFeature->getGroup();
 485     DocumentPtr aDoc = theObject->document();
 486     int aNb = aDoc->size(ModelAPI_Feature::group());
 487     int aRow = -1;
 488     for (int i = 0; i < aNb; i++) {
 489       if (aDoc->object(ModelAPI_Feature::group(), i) == theObject) {
 490         aRow = i;
 491         break;
 492       }
 493     }
 494     if (aRow != -1) {
 495       return createIndex(aRow + 3, 0, (qint32) HistoryObject);
 496 /*      if (aGroup.compare(ModelAPI_ResultParameters::group()) == 0)
 497         return createIndex(aRow, 0, (qint32) ParamObject);
 498       if (aGroup.compare(ModelAPI_ResultConstruction::group()) == 0)
 499         return createIndex(aRow, 0, (qint32) ConstructObject);*/
 500     }
 501   }
 502   return aIndex;
 503 }