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