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 = boost::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 boost::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 boost::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 boost::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() && anObject->data()->mustBeUpdated()) {
 323             return QIcon(":pictures/constr_object_modified.png");
 324           }
 325           return QIcon(":pictures/constr_object.png");
 326         }
 327         case HistoryObject: {
 328           ObjectPtr aObject = partDocument()->object(ModelAPI_Feature::group(), theIndex.row() - 4);
 329           FeaturePtr aFeature = boost::dynamic_pointer_cast<ModelAPI_Feature>(aObject);
 330           if (aFeature)
 331             return QIcon(XGUI_Workshop::featureIcon(aFeature->getKind()));
 332         }
 333       }
 334       break;
 335     case Qt::ToolTipRole:
 336       // return Tooltip
 337       break;
 338     case Qt::ForegroundRole:
 339       return QBrush(myItemsColor);
 340       break;
 341   }
 342   return QVariant();
 343 }
 344
 345 QVariant XGUI_PartDataModel::headerData(int section, Qt::Orientation orientation, int role) const
 346 {
 347   return QVariant();
 348 }
 349
 350 int XGUI_PartDataModel::rowCount(const QModelIndex& parent) const
 351 {
 352   if (!parent.isValid()) {
 353     DocumentPtr aRootDoc = ModelAPI_Session::get()->moduleDocument();
 354     if (aRootDoc->object(ModelAPI_ResultPart::group(), myId))
 355       return 1;
 356     else
 357       return 0;
 358   }
 359   switch (parent.internalId()) {
 360     case MyRoot:
 361       {
 362         DocumentPtr aDoc = partDocument();
 363         if (aDoc)
 364           return 4 + aDoc->size(ModelAPI_Feature::group());
 365         else
 366           return 0;
 367       }
 368     case ParamsFolder:
 369       return partDocument()->size(ModelAPI_ResultParameters::group());
 370     case ConstructFolder:
 371       return partDocument()->size(ModelAPI_ResultConstruction::group());
 372     case BodiesFolder:
 373       return partDocument()->size(ModelAPI_ResultBody::group());
 374     case GroupsFolder:
 375       return partDocument()->size(ModelAPI_ResultGroup::group());
 376   }
 377   return 0;
 378 }
 379
 380 int XGUI_PartDataModel::columnCount(const QModelIndex &parent) const
 381 {
 382   return 1;
 383 }
 384
 385 QModelIndex XGUI_PartDataModel::index(int theRow, int theColumn, const QModelIndex &theParent) const
 386 {
 387   if (!theParent.isValid())
 388     return createIndex(theRow, 0, (qint32) MyRoot);
 389
 390   int aId = (int) theParent.internalId();
 391   switch (aId) {
 392     case MyRoot:
 393       switch (theRow) {
 394         case 0:
 395           return createIndex(theRow, 0, (qint32) ParamsFolder);
 396         case 1:
 397           return createIndex(theRow, 0, (qint32) ConstructFolder);
 398         case 2:
 399           return createIndex(theRow, 0, (qint32) BodiesFolder);
 400         case 3:
 401           return createIndex(theRow, 0, (qint32) GroupsFolder);
 402         default:
 403           return createIndex(theRow, theColumn, (qint32) HistoryObject);
 404       }
 405     case ParamsFolder:
 406       return createIndex(theRow, 0, (qint32) ParamObject);
 407     case ConstructFolder:
 408       return createIndex(theRow, 0, (qint32) ConstructObject);
 409     case BodiesFolder:
 410       return createIndex(theRow, 0, (qint32) BodiesObject);
 411     case GroupsFolder:
 412       return createIndex(theRow, 0, (qint32) GroupObject);
 413   }
 414   return QModelIndex();
 415 }
 416
 417 QModelIndex XGUI_PartDataModel::parent(const QModelIndex& theIndex) const
 418 {
 419   switch (theIndex.internalId()) {
 420     case MyRoot:
 421       return QModelIndex();
 422     case ParamsFolder:
 423     case ConstructFolder:
 424     case BodiesFolder:
 425     case GroupsFolder:
 426     case HistoryObject:
 427       return createIndex(0, 0, (qint32) MyRoot);
 428
 429     case ParamObject:
 430       return createIndex(0, 0, (qint32) ParamsFolder);
 431     case ConstructObject:
 432       return createIndex(1, 0, (qint32) ConstructFolder);
 433     case BodiesObject:
 434       return createIndex(2, 0, (qint32) BodiesFolder);
 435     case GroupObject:
 436       return createIndex(3, 0, (qint32) GroupsFolder);
 437   }
 438   return QModelIndex();
 439 }
 440
 441 bool XGUI_PartDataModel::hasChildren(const QModelIndex& theParent) const
 442 {
 443   return rowCount(theParent) > 0;
 444 }
 445
 446 DocumentPtr XGUI_PartDataModel::partDocument() const
 447 {
 448   DocumentPtr aRootDoc = ModelAPI_Session::get()->moduleDocument();
 449   ObjectPtr aObject = aRootDoc->object(ModelAPI_ResultPart::group(), myId);
 450   ResultPartPtr aPart = boost::dynamic_pointer_cast<ModelAPI_ResultPart>(aObject);
 451   return aPart->partDoc();
 452 }
 453
 454 ObjectPtr XGUI_PartDataModel::object(const QModelIndex& theIndex) const
 455 {
 456   switch (theIndex.internalId()) {
 457     case MyRoot: {
 458       DocumentPtr aRootDoc = ModelAPI_Session::get()->moduleDocument();
 459       return aRootDoc->object(ModelAPI_ResultPart::group(), myId);
 460     }
 461     case ParamsFolder:
 462     case ConstructFolder:
 463     case BodiesFolder:
 464     case GroupsFolder:
 465       return ObjectPtr();
 466
 467     case ParamObject:
 468       return partDocument()->object(ModelAPI_ResultParameters::group(), theIndex.row());
 469     case ConstructObject:
 470       return partDocument()->object(ModelAPI_ResultConstruction::group(), theIndex.row());
 471     case BodiesObject:
 472       return partDocument()->object(ModelAPI_ResultBody::group(), theIndex.row());
 473     case GroupObject:
 474       return partDocument()->object(ModelAPI_ResultGroup::group(), theIndex.row());
 475     case HistoryObject:
 476       return partDocument()->object(ModelAPI_Feature::group(), theIndex.row() - 4);
 477   }
 478   return ObjectPtr();
 479 }
 480
 481 bool XGUI_PartDataModel::hasDocument(const DocumentPtr& theDoc) const
 482 {
 483   return (partDocument() == theDoc);
 484 }
 485
 486 QModelIndex XGUI_PartDataModel::findParent(const ObjectPtr& theObject) const
 487 {
 488   return findGroup(theObject->groupName().c_str());
 489 }
 490
 491 QModelIndex XGUI_PartDataModel::findGroup(const std::string& theGroup) const
 492 {
 493   if (theGroup.compare(ModelAPI_ResultParameters::group()) == 0)
 494     return createIndex(0, 0, (qint32) ParamsFolder);
 495   if (theGroup.compare(ModelAPI_ResultConstruction::group()) == 0)
 496     return createIndex(1, 0, (qint32) ConstructFolder);
 497   if (theGroup.compare(ModelAPI_ResultBody::group()) == 0)
 498     return createIndex(2, 0, (qint32) BodiesFolder);
 499   if (theGroup.compare(ModelAPI_ResultGroup::group()) == 0)
 500     return createIndex(3, 0, (qint32) GroupsFolder);
 501   return QModelIndex();
 502 }
 503
 504 ResultPartPtr XGUI_PartDataModel::part() const
 505 {
 506   DocumentPtr aRootDoc = ModelAPI_Session::get()->moduleDocument();
 507   ObjectPtr aObj = aRootDoc->object(ModelAPI_ResultPart::group(), myId);
 508   return boost::dynamic_pointer_cast<ModelAPI_ResultPart>(aObj);
 509 }
 510
 511 QModelIndex XGUI_PartDataModel::objectIndex(const ObjectPtr& theObject) const
 512 {
 513   QModelIndex aIndex;
 514   if (theObject) {
 515     if (part() == theObject)
 516       return aIndex;
 517
 518     std::string aGroup = theObject->groupName();
 519     DocumentPtr aDoc = theObject->document();
 520     int aNb = aDoc->size(aGroup);
 521     int aRow = -1;
 522     for (int i = 0; i < aNb; i++) {
 523       if (aDoc->object(aGroup, i) == theObject) {
 524         aRow = i;
 525         break;
 526       }
 527     }
 528     if (aRow == -1)
 529       return aIndex;
 530     if (aGroup == ModelAPI_ResultParameters::group())
 531       return createIndex(aRow, 0, (qint32) ParamObject);
 532     else if (aGroup == ModelAPI_ResultConstruction::group())
 533       return createIndex(aRow, 0, (qint32) ConstructObject);
 534     else if (aGroup == ModelAPI_ResultBody::group())
 535       return createIndex(aRow, 0, (qint32) BodiesObject);
 536     else if (aGroup == ModelAPI_ResultGroup::group())
 537       return createIndex(aRow, 0, (qint32) GroupObject);
 538     else
 539       return createIndex(aRow + 4, 0, (qint32) HistoryObject);
 540   }
 541   return aIndex;
 542 }