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       {
  74         DocumentPtr aRootDoc = ModelAPI_PluginManager::get()->rootDocument();
  75         ObjectPtr aObject = aRootDoc->object(ModelAPI_ResultConstruction::group(), theIndex.row());
  76         if (aObject)
  77           return QIcon(XGUI_Workshop::featureIcon(aObject->getKind()));
  78       }
  79     }
  80     break;
  81
  82   case Qt::ToolTipRole:
  83     // return Tooltip
  84     break;
  85   case Qt::ForegroundRole:
  86     return QBrush(myItemsColor);
  87     break;
  88   }
  89   return QVariant();
  90 }
  91
  92 QVariant XGUI_TopDataModel::headerData(int section, Qt::Orientation orientation, int role) const
  93 {
  94   return QVariant();
  95 }
  96
  97 int XGUI_TopDataModel::rowCount(const QModelIndex& theParent) const
  98 {
  99   if (!theParent.isValid())
 100     return 2;
 101
 102   DocumentPtr aRootDoc = ModelAPI_PluginManager::get()->rootDocument();
 103   if (theParent.internalId() == ParamsFolder)
 104     return aRootDoc->size(ModelAPI_ResultParameters::group());
 105
 106   if (theParent.internalId() == ConstructFolder)
 107     return aRootDoc->size(ModelAPI_ResultConstruction::group());
 108
 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)->getName().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       {
 281         ObjectPtr aObject = partDocument()->object(ModelAPI_ResultConstruction::group(), theIndex.row());
 282         if (aObject)
 283           return QIcon(XGUI_Workshop::featureIcon(aObject->getKind()));
 284       }
 285     case HistoryObject:
 286       {
 287         ObjectPtr aObject = partDocument()->object(ModelAPI_Feature::group(), theIndex.row() - 3);
 288         if (aObject)
 289           return QIcon(XGUI_Workshop::featureIcon(aObject->getKind()));
 290       }
 291     }
 292    break;
 293   case Qt::ToolTipRole:
 294     // return Tooltip
 295     break;
 296   case Qt::ForegroundRole:
 297     return QBrush(myItemsColor);
 298     break;
 299   }
 300   return QVariant();
 301 }
 302
 303 QVariant XGUI_PartDataModel::headerData(int section, Qt::Orientation orientation, int role) const
 304 {
 305   return QVariant();
 306 }
 307
 308 int XGUI_PartDataModel::rowCount(const QModelIndex& parent) const
 309 {
 310   if (!parent.isValid()) {
 311     DocumentPtr aRootDoc = ModelAPI_PluginManager::get()->rootDocument();
 312     if (aRootDoc->object(ModelAPI_ResultPart::group(), myId))
 313       return 1;
 314     else
 315       return 0;
 316   }
 317   switch (parent.internalId()) {
 318   case MyRoot:
 319     return 3 + partDocument()->size(ModelAPI_Feature::group());
 320   case ParamsFolder:
 321     return partDocument()->size(ModelAPI_ResultParameters::group());
 322   case ConstructFolder:
 323     return partDocument()->size(ModelAPI_ResultConstruction::group());
 324   case BodiesFolder:
 325     return 0;
 326   }
 327   return 0;
 328 }
 329
 330 int XGUI_PartDataModel::columnCount(const QModelIndex &parent) const
 331 {
 332   return 1;
 333 }
 334
 335 QModelIndex XGUI_PartDataModel::index(int theRow, int theColumn, const QModelIndex &theParent) const
 336 {
 337   if (!theParent.isValid())
 338     return createIndex(theRow, 0, (qint32) MyRoot);
 339
 340   int aId = (int)theParent.internalId();
 341   switch (aId) {
 342   case MyRoot:
 343     switch (theRow) {
 344     case 0:
 345       return createIndex(0, 0, (qint32) ParamsFolder);
 346     case 1:
 347       return createIndex(1, 0, (qint32) ConstructFolder);
 348     case 2:
 349       return createIndex(2, 0, (qint32) BodiesFolder);
 350     default:
 351       return createIndex(theRow, theColumn, (qint32) HistoryObject);
 352     }
 353   case ParamsFolder:
 354     return createIndex(theRow, 0, (qint32) ParamObject);
 355   case ConstructFolder:
 356     return createIndex(theRow, 0, (qint32) ConstructObject);
 357   case BodiesFolder:
 358     return createIndex(theRow, 0, (qint32) BodiesObject);
 359   }
 360   return QModelIndex();
 361 }
 362
 363 QModelIndex XGUI_PartDataModel::parent(const QModelIndex& theIndex) const
 364 {
 365   switch (theIndex.internalId()) {
 366   case MyRoot:
 367     return QModelIndex();
 368   case ParamsFolder:
 369   case ConstructFolder:
 370   case BodiesFolder:
 371   case HistoryObject:
 372     return createIndex(0, 0, (qint32) MyRoot);
 373   case ParamObject:
 374     return createIndex(0, 0, (qint32) ParamsFolder);
 375   case ConstructObject:
 376     return createIndex(1, 0, (qint32) ConstructFolder);
 377   }
 378   return QModelIndex();
 379 }
 380
 381 bool XGUI_PartDataModel::hasChildren(const QModelIndex& theParent) const
 382 {
 383   return rowCount(theParent) > 0;
 384 }
 385
 386
 387 DocumentPtr XGUI_PartDataModel::partDocument() const
 388 {
 389   DocumentPtr aRootDoc = ModelAPI_PluginManager::get()->rootDocument();
 390   ObjectPtr aObject = aRootDoc->object(ModelAPI_ResultPart::group(), myId);
 391   return aObject->data()->docRef("PartDocument")->value();
 392 }
 393
 394 ObjectPtr XGUI_PartDataModel::object(const QModelIndex& theIndex) const
 395 {
 396   switch (theIndex.internalId()) {
 397   case MyRoot:
 398     {
 399       DocumentPtr aRootDoc = ModelAPI_PluginManager::get()->rootDocument();
 400       return aRootDoc->object(ModelAPI_ResultPart::group(), myId);
 401     }
 402   case ParamsFolder:
 403   case ConstructFolder:
 404   case BodiesFolder:
 405     return ObjectPtr();
 406   case ParamObject:
 407     return partDocument()->object(ModelAPI_ResultParameters::group(), theIndex.row());
 408   case ConstructObject:
 409     return partDocument()->object(ModelAPI_ResultConstruction::group(), theIndex.row());
 410   //case BodiesObject:
 411   //  return partDocument()->feature(ModelAPI_ResultConstruction::group(), theIndex.row());
 412   case HistoryObject:
 413     return partDocument()->object(ModelAPI_Feature::group(), theIndex.row() - 3);
 414   }
 415   return ObjectPtr();
 416 }
 417
 418 bool XGUI_PartDataModel::hasDocument(const DocumentPtr& theDoc) const
 419 {
 420   return (partDocument() == theDoc);
 421 }
 422
 423
 424 QModelIndex XGUI_PartDataModel::findParent(const ObjectPtr& theObject) const
 425 {
 426   return findGroup(theObject->groupName().c_str());
 427 }
 428
 429 QModelIndex XGUI_PartDataModel::findGroup(const std::string& theGroup) const
 430 {
 431   if (theGroup.compare(ModelAPI_ResultParameters::group()) == 0)
 432     return createIndex(0, 0, (qint32) ParamsFolder);
 433   if (theGroup.compare(ModelAPI_ResultConstruction::group()) == 0)
 434     return createIndex(1, 0, (qint32) ConstructFolder);
 435   return QModelIndex();
 436 }
 437
 438 ObjectPtr XGUI_PartDataModel::part() const
 439 {
 440   DocumentPtr aRootDoc = ModelAPI_PluginManager::get()->rootDocument();
 441   return aRootDoc->object(ModelAPI_ResultPart::group(), myId);
 442 }
 443
 444 QModelIndex XGUI_PartDataModel::objectIndex(const ObjectPtr& theObject) const
 445 {
 446   QModelIndex aIndex;
 447   if (theObject) {
 448     if (part() == theObject)
 449       return aIndex;
 450
 451     //std::string aGroup = theFeature->getGroup();
 452     DocumentPtr aDoc = theObject->document();
 453     int aNb = aDoc->size(ModelAPI_Feature::group());
 454     int aRow = -1;
 455     for (int i = 0; i < aNb; i++) {
 456       if (aDoc->object(ModelAPI_Feature::group(), i) == theObject) {
 457         aRow = i;
 458         break;
 459       }
 460     }
 461     if (aRow != -1) {
 462       return createIndex(aRow + 3, 0, (qint32) HistoryObject);
 463 /*      if (aGroup.compare(ModelAPI_ResultParameters::group()) == 0)
 464         return createIndex(aRow, 0, (qint32) ParamObject);
 465       if (aGroup.compare(ModelAPI_ResultConstruction::group()) == 0)
 466         return createIndex(aRow, 0, (qint32) ConstructObject);*/
 467     }
 468   }
 469   return aIndex;
 470 }