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() - 4);
 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() - 4);
 330           FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aObject);
 331           if (aFeature)
 332             return QIcon(XGUI_Workshop::featureIcon(aFeature->getKind()));
 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 4 + 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           return createIndex(theRow, 0, (qint32) GroupsFolder);
 403         default:
 404           return createIndex(theRow, theColumn, (qint32) HistoryObject);
 405       }
 406     case ParamsFolder:
 407       return createIndex(theRow, 0, (qint32) ParamObject);
 408     case ConstructFolder:
 409       return createIndex(theRow, 0, (qint32) ConstructObject);
 410     case BodiesFolder:
 411       return createIndex(theRow, 0, (qint32) BodiesObject);
 412     case GroupsFolder:
 413       return createIndex(theRow, 0, (qint32) GroupObject);
 414   }
 415   return QModelIndex();
 416 }
 417
 418 QModelIndex XGUI_PartDataModel::parent(const QModelIndex& theIndex) const
 419 {
 420   switch (theIndex.internalId()) {
 421     case MyRoot:
 422       return QModelIndex();
 423     case ParamsFolder:
 424     case ConstructFolder:
 425     case BodiesFolder:
 426     case GroupsFolder:
 427     case HistoryObject:
 428       return createIndex(0, 0, (qint32) MyRoot);
 429
 430     case ParamObject:
 431       return createIndex(0, 0, (qint32) ParamsFolder);
 432     case ConstructObject:
 433       return createIndex(1, 0, (qint32) ConstructFolder);
 434     case BodiesObject:
 435       return createIndex(2, 0, (qint32) BodiesFolder);
 436     case GroupObject:
 437       return createIndex(3, 0, (qint32) GroupsFolder);
 438   }
 439   return QModelIndex();
 440 }
 441
 442 bool XGUI_PartDataModel::hasChildren(const QModelIndex& theParent) const
 443 {
 444   return rowCount(theParent) > 0;
 445 }
 446
 447 DocumentPtr XGUI_PartDataModel::partDocument() const
 448 {
 449   DocumentPtr aRootDoc = ModelAPI_Session::get()->moduleDocument();
 450   ObjectPtr aObject = aRootDoc->object(ModelAPI_ResultPart::group(), myId);
 451   ResultPartPtr aPart = std::dynamic_pointer_cast<ModelAPI_ResultPart>(aObject);
 452   if (aPart)
 453     return aPart->partDoc();
 454   return DocumentPtr(); // null if not found
 455 }
 456
 457 ObjectPtr XGUI_PartDataModel::object(const QModelIndex& theIndex) const
 458 {
 459   switch (theIndex.internalId()) {
 460     case MyRoot: {
 461       DocumentPtr aRootDoc = ModelAPI_Session::get()->moduleDocument();
 462       return aRootDoc->object(ModelAPI_ResultPart::group(), myId);
 463     }
 464     case ParamsFolder:
 465     case ConstructFolder:
 466     case BodiesFolder:
 467     case GroupsFolder:
 468       return ObjectPtr();
 469
 470     case ParamObject:
 471       return partDocument()->object(ModelAPI_ResultParameters::group(), theIndex.row());
 472     case ConstructObject:
 473       return partDocument()->object(ModelAPI_ResultConstruction::group(), theIndex.row());
 474     case BodiesObject:
 475       return partDocument()->object(ModelAPI_ResultBody::group(), theIndex.row());
 476     case GroupObject:
 477       return partDocument()->object(ModelAPI_ResultGroup::group(), theIndex.row());
 478     case HistoryObject:
 479       return partDocument()->object(ModelAPI_Feature::group(), theIndex.row() - 4);
 480   }
 481   return ObjectPtr();
 482 }
 483
 484 bool XGUI_PartDataModel::hasDocument(const DocumentPtr& theDoc) const
 485 {
 486   return (partDocument() == theDoc);
 487 }
 488
 489 QModelIndex XGUI_PartDataModel::findParent(const ObjectPtr& theObject) const
 490 {
 491   return findGroup(theObject->groupName().c_str());
 492 }
 493
 494 QModelIndex XGUI_PartDataModel::findGroup(const std::string& theGroup) const
 495 {
 496   if (theGroup.compare(ModelAPI_ResultParameters::group()) == 0)
 497     return createIndex(0, 0, (qint32) ParamsFolder);
 498   if (theGroup.compare(ModelAPI_ResultConstruction::group()) == 0)
 499     return createIndex(1, 0, (qint32) ConstructFolder);
 500   if (theGroup.compare(ModelAPI_ResultBody::group()) == 0)
 501     return createIndex(2, 0, (qint32) BodiesFolder);
 502   if (theGroup.compare(ModelAPI_ResultGroup::group()) == 0)
 503     return createIndex(3, 0, (qint32) GroupsFolder);
 504   return QModelIndex();
 505 }
 506
 507 ResultPartPtr XGUI_PartDataModel::part() const
 508 {
 509   DocumentPtr aRootDoc = ModelAPI_Session::get()->moduleDocument();
 510   ObjectPtr aObj = aRootDoc->object(ModelAPI_ResultPart::group(), myId);
 511   return std::dynamic_pointer_cast<ModelAPI_ResultPart>(aObj);
 512 }
 513
 514 QModelIndex XGUI_PartDataModel::objectIndex(const ObjectPtr& theObject) const
 515 {
 516   QModelIndex aIndex;
 517   if (theObject) {
 518     if (part() == theObject)
 519       return aIndex;
 520
 521     std::string aGroup = theObject->groupName();
 522     DocumentPtr aDoc = theObject->document();
 523     int aNb = aDoc->size(aGroup);
 524     int aRow = -1;
 525     for (int i = 0; i < aNb; i++) {
 526       if (aDoc->object(aGroup, i) == theObject) {
 527         aRow = i;
 528         break;
 529       }
 530     }
 531     if (aRow == -1)
 532       return aIndex;
 533     if (aGroup == ModelAPI_ResultParameters::group())
 534       return createIndex(aRow, 0, (qint32) ParamObject);
 535     else if (aGroup == ModelAPI_ResultConstruction::group())
 536       return createIndex(aRow, 0, (qint32) ConstructObject);
 537     else if (aGroup == ModelAPI_ResultBody::group())
 538       return createIndex(aRow, 0, (qint32) BodiesObject);
 539     else if (aGroup == ModelAPI_ResultGroup::group())
 540       return createIndex(aRow, 0, (qint32) GroupObject);
 541     else
 542       return createIndex(aRow + 4, 0, (qint32) HistoryObject);
 543   }
 544   return aIndex;
 545 }