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   return 0;
 110 }
 111
 112 int XGUI_TopDataModel::columnCount(const QModelIndex &parent) const
 113 {
 114   return 1;
 115 }
 116
 117 QModelIndex XGUI_TopDataModel::index(int theRow, int theColumn, const QModelIndex& theParent) const
 118 {
 119   if (!theParent.isValid()) {
 120     switch (theRow) {
 121     case 0:
 122       return createIndex(theRow, theColumn, (qint32) ParamsFolder);
 123     case 1:
 124       return createIndex(theRow, theColumn, (qint32) ConstructFolder);
 125     }
 126   } else {
 127     if (theParent.internalId() == ParamsFolder)
 128       return createIndex(theRow, theColumn, (qint32) ParamObject);
 129
 130     if (theParent.internalId() == ConstructFolder)
 131       return createIndex(theRow, theColumn, (qint32) ConstructObject);
 132   }
 133   return QModelIndex();
 134 }
 135
 136 QModelIndex XGUI_TopDataModel::parent(const QModelIndex& theIndex) const
 137 {
 138   int aId = (int)theIndex.internalId();
 139   switch (aId) {
 140   case ParamsFolder:
 141   case ConstructFolder:
 142     return QModelIndex();
 143   case ParamObject:
 144     return createIndex(0, 0, (qint32) ParamsFolder);
 145   case ConstructObject:
 146     return createIndex(1, 0, (qint32) ConstructFolder);
 147   }
 148   return QModelIndex();
 149 }
 150
 151 bool XGUI_TopDataModel::hasChildren(const QModelIndex& theParent) const
 152 {
 153   return rowCount(theParent) > 0;
 154 }
 155
 156 ObjectPtr XGUI_TopDataModel::object(const QModelIndex& theIndex) const
 157 {
 158   switch (theIndex.internalId()) {
 159   case ParamsFolder:
 160   case ConstructFolder:
 161     return ObjectPtr();
 162   case ParamObject:
 163     {
 164       DocumentPtr aRootDoc = ModelAPI_PluginManager::get()->rootDocument();
 165       return aRootDoc->object(ModelAPI_ResultParameters::group(), theIndex.row());
 166     }
 167   case ConstructObject:
 168     {
 169       DocumentPtr aRootDoc = ModelAPI_PluginManager::get()->rootDocument();
 170       return aRootDoc->object(ModelAPI_ResultConstruction::group(), theIndex.row());
 171     }
 172   }
 173   return ObjectPtr();
 174 }
 175
 176
 177 QModelIndex XGUI_TopDataModel::findParent(const ObjectPtr& theObject) const
 178 {
 179   return findGroup(theObject->groupName().c_str());
 180 }
 181
 182 QModelIndex XGUI_TopDataModel::findGroup(const std::string& theGroup) const
 183 {
 184   if (theGroup.compare(ModelAPI_ResultParameters::group()) == 0)
 185     return createIndex(0, 0, (qint32) ParamsFolder);
 186   if (theGroup.compare(ModelAPI_ResultConstruction::group()) == 0)
 187     return createIndex(1, 0, (qint32) ConstructFolder);
 188   return QModelIndex();
 189 }
 190
 191 QModelIndex XGUI_TopDataModel::objectIndex(const ObjectPtr& theObject) const
 192 {
 193   QModelIndex aIndex;
 194   if (theObject) {
 195     DocumentPtr aRootDoc = ModelAPI_PluginManager::get()->rootDocument();
 196     std::string aGroup = theObject->groupName();
 197     int aNb = aRootDoc->size(aGroup);
 198     int aRow = -1;
 199     for (int i = 0; i < aNb; i++) {
 200       if (aRootDoc->object(aGroup, i) == theObject) {
 201         aRow = i;
 202         break;
 203       }
 204     }
 205     if (aRow != -1) {
 206       if (aGroup.compare(ModelAPI_ResultParameters::group()) == 0)
 207         return createIndex(aRow, 0, (qint32) ParamObject);
 208       if (aGroup.compare(ModelAPI_ResultConstruction::group()) == 0)
 209         return createIndex(aRow, 0, (qint32) ConstructObject);
 210     }
 211   }
 212   return aIndex;
 213 }
 214
 215
 216
 217 //******************************************************************
 218 //******************************************************************
 219 //******************************************************************
 220 XGUI_PartDataModel::XGUI_PartDataModel(QObject* theParent)
 221   : XGUI_PartModel(theParent)
 222 {
 223 }
 224
 225
 226 XGUI_PartDataModel::~XGUI_PartDataModel()
 227 {
 228 }
 229
 230 QVariant XGUI_PartDataModel::data(const QModelIndex& theIndex, int theRole) const
 231 {
 232   switch (theRole) {
 233   case Qt::DisplayRole:
 234     // return a name
 235     switch (theIndex.internalId()) {
 236     case MyRoot:
 237       {
 238         DocumentPtr aRootDoc = ModelAPI_PluginManager::get()->rootDocument();
 239         ObjectPtr aObject = aRootDoc->object(ModelAPI_ResultPart::group(), myId);
 240         if (aObject)
 241           return boost::dynamic_pointer_cast<ModelAPI_Object>(aObject)->data()->name().c_str();
 242       }
 243     case ParamsFolder:
 244       return tr("Parameters") + QString(" (%1)").arg(rowCount(theIndex));
 245     case ConstructFolder:
 246       return tr("Constructions") + QString(" (%1)").arg(rowCount(theIndex));
 247     case BodiesFolder:
 248       return tr("Bodies") + QString(" (%1)").arg(rowCount(theIndex));
 249     case ParamObject:
 250       {
 251         ObjectPtr aObject = partDocument()->object(ModelAPI_ResultParameters::group(), theIndex.row());
 252         if (aObject)
 253           return boost::dynamic_pointer_cast<ModelAPI_Object>(aObject)->data()->name().c_str();
 254       }
 255     case ConstructObject:
 256       {
 257         ObjectPtr aObject = partDocument()->object(ModelAPI_ResultConstruction::group(), theIndex.row());
 258         if (aObject)
 259           return boost::dynamic_pointer_cast<ModelAPI_Object>(aObject)->data()->name().c_str();
 260       }
 261     case HistoryObject:
 262       {
 263         ObjectPtr aObject = partDocument()->object(ModelAPI_Feature::group(), theIndex.row() - 3);
 264         if (aObject)
 265           return aObject->data()->name().c_str();
 266       }
 267     }
 268     break;
 269   case Qt::DecorationRole:
 270     // return an Icon
 271     switch (theIndex.internalId()) {
 272     case MyRoot:
 273       return QIcon(":pictures/part_ico.png");
 274     case ParamsFolder:
 275       return QIcon(":pictures/params_folder.png");
 276     case ConstructFolder:
 277     case BodiesFolder:
 278       return QIcon(":pictures/constr_folder.png");
 279     case ConstructObject:
 280       return QIcon(":pictures/constr_object.png");
 281       //{
 282       //  ObjectPtr aObject = partDocument()->object(ModelAPI_ResultConstruction::group(), theIndex.row());
 283       //  if (aObject)
 284       //    return QIcon(XGUI_Workshop::featureIcon(aObject->getKind()));
 285       //}
 286     case HistoryObject:
 287       {
 288         ObjectPtr aObject = partDocument()->object(ModelAPI_Feature::group(), theIndex.row() - 3);
 289         FeaturePtr aFeature = boost::dynamic_pointer_cast<ModelAPI_Feature>(aObject);
 290         if (aFeature)
 291           return QIcon(XGUI_Workshop::featureIcon(aFeature->getKind()));
 292       }
 293     }
 294    break;
 295   case Qt::ToolTipRole:
 296     // return Tooltip
 297     break;
 298   case Qt::ForegroundRole:
 299     return QBrush(myItemsColor);
 300     break;
 301   }
 302   return QVariant();
 303 }
 304
 305 QVariant XGUI_PartDataModel::headerData(int section, Qt::Orientation orientation, int role) const
 306 {
 307   return QVariant();
 308 }
 309
 310 int XGUI_PartDataModel::rowCount(const QModelIndex& parent) const
 311 {
 312   if (!parent.isValid()) {
 313     DocumentPtr aRootDoc = ModelAPI_PluginManager::get()->rootDocument();
 314     if (aRootDoc->object(ModelAPI_ResultPart::group(), myId))
 315       return 1;
 316     else
 317       return 0;
 318   }
 319   switch (parent.internalId()) {
 320   case MyRoot:
 321     return 3 + partDocument()->size(ModelAPI_Feature::group());
 322   case ParamsFolder:
 323     return partDocument()->size(ModelAPI_ResultParameters::group());
 324   case ConstructFolder:
 325     return partDocument()->size(ModelAPI_ResultConstruction::group());
 326   case BodiesFolder:
 327     return 0;
 328   }
 329   return 0;
 330 }
 331
 332 int XGUI_PartDataModel::columnCount(const QModelIndex &parent) const
 333 {
 334   return 1;
 335 }
 336
 337 QModelIndex XGUI_PartDataModel::index(int theRow, int theColumn, const QModelIndex &theParent) const
 338 {
 339   if (!theParent.isValid())
 340     return createIndex(theRow, 0, (qint32) MyRoot);
 341
 342   int aId = (int)theParent.internalId();
 343   switch (aId) {
 344   case MyRoot:
 345     switch (theRow) {
 346     case 0:
 347       return createIndex(0, 0, (qint32) ParamsFolder);
 348     case 1:
 349       return createIndex(1, 0, (qint32) ConstructFolder);
 350     case 2:
 351       return createIndex(2, 0, (qint32) BodiesFolder);
 352     default:
 353       return createIndex(theRow, theColumn, (qint32) HistoryObject);
 354     }
 355   case ParamsFolder:
 356     return createIndex(theRow, 0, (qint32) ParamObject);
 357   case ConstructFolder:
 358     return createIndex(theRow, 0, (qint32) ConstructObject);
 359   case BodiesFolder:
 360     return createIndex(theRow, 0, (qint32) BodiesObject);
 361   }
 362   return QModelIndex();
 363 }
 364
 365 QModelIndex XGUI_PartDataModel::parent(const QModelIndex& theIndex) const
 366 {
 367   switch (theIndex.internalId()) {
 368   case MyRoot:
 369     return QModelIndex();
 370   case ParamsFolder:
 371   case ConstructFolder:
 372   case BodiesFolder:
 373   case HistoryObject:
 374     return createIndex(0, 0, (qint32) MyRoot);
 375   case ParamObject:
 376     return createIndex(0, 0, (qint32) ParamsFolder);
 377   case ConstructObject:
 378     return createIndex(1, 0, (qint32) ConstructFolder);
 379   }
 380   return QModelIndex();
 381 }
 382
 383 bool XGUI_PartDataModel::hasChildren(const QModelIndex& theParent) const
 384 {
 385   return rowCount(theParent) > 0;
 386 }
 387
 388
 389 DocumentPtr XGUI_PartDataModel::partDocument() const
 390 {
 391   DocumentPtr aRootDoc = ModelAPI_PluginManager::get()->rootDocument();
 392   ObjectPtr aObject = aRootDoc->object(ModelAPI_ResultPart::group(), myId);
 393   ResultPartPtr aPart = boost::dynamic_pointer_cast<ModelAPI_ResultPart>(aObject);
 394   return aPart->partDoc();
 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 }