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