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()->moduleDocument();
  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()->moduleDocument();
  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       }
  62       break;
  63
  64     case Qt::DecorationRole:
  65       {
  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       }
  76       break;
  77
  78     case Qt::ToolTipRole:
  79       // return Tooltip
  80       break;
  81     case Qt::ForegroundRole:
  82       return QBrush(myItemsColor);
  83       break;
  84   }
  85   return QVariant();
  86 }
  87
  88 QVariant XGUI_TopDataModel::headerData(int section, Qt::Orientation orientation, int role) const
  89 {
  90   return QVariant();
  91 }
  92
  93 int XGUI_TopDataModel::rowCount(const QModelIndex& theParent) const
  94 {
  95   if (!theParent.isValid())
  96     return 2;
  97
  98   DocumentPtr aRootDoc = ModelAPI_Session::get()->moduleDocument();
  99   if (theParent.internalId() == ParamsFolder)
 100     return aRootDoc->size(ModelAPI_ResultParameters::group());
 101
 102   if (theParent.internalId() == ConstructFolder)
 103     return aRootDoc->size(ModelAPI_ResultConstruction::group());
 104
 105   return 0;
 106 }
 107
 108 int XGUI_TopDataModel::columnCount(const QModelIndex &parent) const
 109 {
 110   return 1;
 111 }
 112
 113 QModelIndex XGUI_TopDataModel::index(int theRow, int theColumn, const QModelIndex& theParent) const
 114 {
 115   if (!theParent.isValid()) {
 116     switch (theRow) {
 117       case 0:
 118         return createIndex(theRow, theColumn, (qint32) ParamsFolder);
 119       case 1:
 120         return createIndex(theRow, theColumn, (qint32) ConstructFolder);
 121     }
 122   } else {
 123     if (theParent.internalId() == ParamsFolder)
 124       return createIndex(theRow, theColumn, (qint32) ParamObject);
 125
 126     if (theParent.internalId() == ConstructFolder)
 127       return createIndex(theRow, theColumn, (qint32) ConstructObject);
 128   }
 129   return QModelIndex();
 130 }
 131
 132 QModelIndex XGUI_TopDataModel::parent(const QModelIndex& theIndex) const
 133 {
 134   int aId = (int) theIndex.internalId();
 135   switch (aId) {
 136     case ParamsFolder:
 137     case ConstructFolder:
 138       return QModelIndex();
 139     case ParamObject:
 140       return createIndex(0, 0, (qint32) ParamsFolder);
 141     case ConstructObject:
 142       return createIndex(1, 0, (qint32) ConstructFolder);
 143   }
 144   return QModelIndex();
 145 }
 146
 147 bool XGUI_TopDataModel::hasChildren(const QModelIndex& theParent) const
 148 {
 149   return rowCount(theParent) > 0;
 150 }
 151
 152 ObjectPtr XGUI_TopDataModel::object(const QModelIndex& theIndex) const
 153 {
 154   switch (theIndex.internalId()) {
 155     case ParamsFolder:
 156     case ConstructFolder:
 157       return ObjectPtr();
 158     case ParamObject: {
 159       DocumentPtr aRootDoc = ModelAPI_Session::get()->moduleDocument();
 160       return aRootDoc->object(ModelAPI_ResultParameters::group(), theIndex.row());
 161     }
 162     case ConstructObject: {
 163       DocumentPtr aRootDoc = ModelAPI_Session::get()->moduleDocument();
 164       return aRootDoc->object(ModelAPI_ResultConstruction::group(), theIndex.row());
 165     }
 166   }
 167   return ObjectPtr();
 168 }
 169
 170 QModelIndex XGUI_TopDataModel::findParent(const ObjectPtr& theObject) const
 171 {
 172   return findGroup(theObject->groupName().c_str());
 173 }
 174
 175 QModelIndex XGUI_TopDataModel::findGroup(const std::string& theGroup) const
 176 {
 177   if (theGroup == ModelAPI_ResultParameters::group())
 178     return createIndex(0, 0, (qint32) ParamsFolder);
 179   if (theGroup == ModelAPI_ResultConstruction::group())
 180     return createIndex(1, 0, (qint32) ConstructFolder);
 181   return QModelIndex();
 182 }
 183
 184 QModelIndex XGUI_TopDataModel::objectIndex(const ObjectPtr& theObject) const
 185 {
 186   QModelIndex aIndex;
 187   if (theObject) {
 188     DocumentPtr aRootDoc = ModelAPI_Session::get()->moduleDocument();
 189     std::string aGroup = theObject->groupName();
 190     int aNb = aRootDoc->size(aGroup);
 191     int aRow = -1;
 192     for (int i = 0; i < aNb; i++) {
 193       if (aRootDoc->object(aGroup, i) == theObject) {
 194         aRow = i;
 195         break;
 196       }
 197     }
 198     if (aRow != -1) {
 199       if (aGroup == ModelAPI_ResultParameters::group())
 200         return createIndex(aRow, 0, (qint32) ParamObject);
 201       if (aGroup == ModelAPI_ResultConstruction::group())
 202         return createIndex(aRow, 0, (qint32) ConstructObject);
 203     }
 204   }
 205   return aIndex;
 206 }
 207
 208 //******************************************************************
 209 //******************************************************************
 210 //******************************************************************
 211 XGUI_PartDataModel::XGUI_PartDataModel(QObject* theParent)
 212     : XGUI_PartModel(theParent)
 213 {
 214 }
 215
 216 XGUI_PartDataModel::~XGUI_PartDataModel()
 217 {
 218 }
 219
 220 QVariant XGUI_PartDataModel::data(const QModelIndex& theIndex, int theRole) const
 221 {
 222   switch (theRole) {
 223     case Qt::DisplayRole:
 224       // return a name
 225       switch (theIndex.internalId()) {
 226         case MyRoot: {
 227           DocumentPtr aRootDoc = ModelAPI_Session::get()->moduleDocument();
 228           ObjectPtr aObject = aRootDoc->object(ModelAPI_ResultPart::group(), myId);
 229           if (aObject)
 230             return boost::dynamic_pointer_cast<ModelAPI_Object>(aObject)->data()->name().c_str();
 231         }
 232         case ParamsFolder:
 233           return tr("Parameters") + QString(" (%1)").arg(rowCount(theIndex));
 234         case ConstructFolder:
 235           return tr("Constructions") + QString(" (%1)").arg(rowCount(theIndex));
 236         case BodiesFolder:
 237           return tr("Bodies") + QString(" (%1)").arg(rowCount(theIndex));
 238         case ParamObject: {
 239           ObjectPtr aObject = partDocument()->object(ModelAPI_ResultParameters::group(),
 240                                                      theIndex.row());
 241           if (aObject)
 242             return boost::dynamic_pointer_cast<ModelAPI_Object>(aObject)->data()->name().c_str();
 243         }
 244         case ConstructObject: {
 245           ObjectPtr aObject = partDocument()->object(ModelAPI_ResultConstruction::group(),
 246                                                      theIndex.row());
 247           if (aObject)
 248             return boost::dynamic_pointer_cast<ModelAPI_Object>(aObject)->data()->name().c_str();
 249         }
 250         case BodiesObject: {
 251           ObjectPtr aObject = partDocument()->object(ModelAPI_ResultBody::group(), theIndex.row());
 252           if (aObject)
 253             return aObject->data()->name().c_str();
 254         }
 255         case HistoryObject: {
 256           ObjectPtr aObject = partDocument()->object(ModelAPI_Feature::group(), theIndex.row() - 3);
 257           if (aObject)
 258             return aObject->data()->name().c_str();
 259         }
 260       }
 261       break;
 262     case Qt::DecorationRole:
 263       // return an Icon
 264       switch (theIndex.internalId()) {
 265         case MyRoot:
 266           return QIcon(":pictures/part_ico.png");
 267         case ParamsFolder:
 268           return QIcon(":pictures/params_folder.png");
 269         case ConstructFolder:
 270         case BodiesFolder:
 271           return QIcon(":pictures/constr_folder.png");
 272         case ConstructObject:
 273         case BodiesObject: {
 274           std::string aGroup = theIndex.internalId() == ConstructObject ?
 275             ModelAPI_ResultConstruction::group() : ModelAPI_ResultBody::group();
 276           ObjectPtr anObject = partDocument()->object(aGroup, theIndex.row());
 277           if (anObject && anObject->data() && anObject->data()->mustBeUpdated()) {
 278             return QIcon(":pictures/constr_object_modified.png");
 279           }
 280           return QIcon(":pictures/constr_object.png");
 281         }
 282         case HistoryObject: {
 283           ObjectPtr aObject = partDocument()->object(ModelAPI_Feature::group(), theIndex.row() - 3);
 284           FeaturePtr aFeature = boost::dynamic_pointer_cast<ModelAPI_Feature>(aObject);
 285           if (aFeature)
 286             return QIcon(XGUI_Workshop::featureIcon(aFeature->getKind()));
 287         }
 288       }
 289       break;
 290     case Qt::ToolTipRole:
 291       // return Tooltip
 292       break;
 293     case Qt::ForegroundRole:
 294       return QBrush(myItemsColor);
 295       break;
 296   }
 297   return QVariant();
 298 }
 299
 300 QVariant XGUI_PartDataModel::headerData(int section, Qt::Orientation orientation, int role) const
 301 {
 302   return QVariant();
 303 }
 304
 305 int XGUI_PartDataModel::rowCount(const QModelIndex& parent) const
 306 {
 307   if (!parent.isValid()) {
 308     DocumentPtr aRootDoc = ModelAPI_Session::get()->moduleDocument();
 309     if (aRootDoc->object(ModelAPI_ResultPart::group(), myId))
 310       return 1;
 311     else
 312       return 0;
 313   }
 314   switch (parent.internalId()) {
 315     case MyRoot:
 316       {
 317         DocumentPtr aDoc = partDocument();
 318         if (aDoc)
 319           return 3 + aDoc->size(ModelAPI_Feature::group());
 320         else
 321           return 0;
 322       }
 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 partDocument()->size(ModelAPI_ResultBody::group());
 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     case BodiesObject:
 381       return createIndex(2, 0, (qint32) BodiesFolder);
 382   }
 383   return QModelIndex();
 384 }
 385
 386 bool XGUI_PartDataModel::hasChildren(const QModelIndex& theParent) const
 387 {
 388   return rowCount(theParent) > 0;
 389 }
 390
 391 DocumentPtr XGUI_PartDataModel::partDocument() const
 392 {
 393   DocumentPtr aRootDoc = ModelAPI_Session::get()->moduleDocument();
 394   ObjectPtr aObject = aRootDoc->object(ModelAPI_ResultPart::group(), myId);
 395   ResultPartPtr aPart = boost::dynamic_pointer_cast<ModelAPI_ResultPart>(aObject);
 396   return aPart->partDoc();
 397 }
 398
 399 ObjectPtr XGUI_PartDataModel::object(const QModelIndex& theIndex) const
 400 {
 401   switch (theIndex.internalId()) {
 402     case MyRoot: {
 403       DocumentPtr aRootDoc = ModelAPI_Session::get()->moduleDocument();
 404       return aRootDoc->object(ModelAPI_ResultPart::group(), myId);
 405     }
 406     case ParamsFolder:
 407     case ConstructFolder:
 408     case BodiesFolder:
 409       return ObjectPtr();
 410     case ParamObject:
 411       return partDocument()->object(ModelAPI_ResultParameters::group(), theIndex.row());
 412     case ConstructObject:
 413       return partDocument()->object(ModelAPI_ResultConstruction::group(), theIndex.row());
 414     case BodiesObject:
 415       return partDocument()->object(ModelAPI_ResultBody::group(), theIndex.row());
 416     case HistoryObject:
 417       return partDocument()->object(ModelAPI_Feature::group(), theIndex.row() - 3);
 418   }
 419   return ObjectPtr();
 420 }
 421
 422 bool XGUI_PartDataModel::hasDocument(const DocumentPtr& theDoc) const
 423 {
 424   return (partDocument() == theDoc);
 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   if (theGroup.compare(ModelAPI_ResultBody::group()) == 0)
 439     return createIndex(2, 0, (qint32) BodiesFolder);
 440   return QModelIndex();
 441 }
 442
 443 ResultPartPtr XGUI_PartDataModel::part() const
 444 {
 445   DocumentPtr aRootDoc = ModelAPI_Session::get()->moduleDocument();
 446   ObjectPtr aObj = aRootDoc->object(ModelAPI_ResultPart::group(), myId);
 447   return boost::dynamic_pointer_cast<ModelAPI_ResultPart>(aObj);
 448 }
 449
 450 QModelIndex XGUI_PartDataModel::objectIndex(const ObjectPtr& theObject) const
 451 {
 452   QModelIndex aIndex;
 453   if (theObject) {
 454     if (part() == theObject)
 455       return aIndex;
 456
 457     std::string aGroup = theObject->groupName();
 458     DocumentPtr aDoc = theObject->document();
 459     int aNb = aDoc->size(aGroup);
 460     int aRow = -1;
 461     for (int i = 0; i < aNb; i++) {
 462       if (aDoc->object(aGroup, i) == theObject) {
 463         aRow = i;
 464         break;
 465       }
 466     }
 467     if (aRow == -1)
 468       return aIndex;
 469     if (aGroup == ModelAPI_ResultParameters::group())
 470       return createIndex(aRow, 0, (qint32) ParamObject);
 471     else if (aGroup == ModelAPI_ResultConstruction::group())
 472       return createIndex(aRow, 0, (qint32) ConstructObject);
 473     else if (aGroup == ModelAPI_ResultBody::group())
 474       return createIndex(aRow, 0, (qint32) BodiesObject);
 475     else
 476       return createIndex(aRow + 3, 0, (qint32) HistoryObject);
 477   }
 478   return aIndex;
 479 }