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