src/PartSet/PartSet_DocumentDataModel.cpp

   1 // Copyright (C) 2014-20xx CEA/DEN, EDF R&D -->
   2
   3 #include "PartSet_DocumentDataModel.h"
   4 #include "PartSet_PartDataModel.h"
   5 #include "PartSet_Module.h"
   6 //#include "XGUI_Tools.h"
   7
   8 #include <ModelAPI_Session.h>
   9 #include <ModelAPI_Document.h>
  10 #include <ModelAPI_Feature.h>
  11 #include <ModelAPI_Data.h>
  12 #include <ModelAPI_ResultPart.h>
  13 #include <ModelAPI_Events.h>
  14 #include <ModelAPI_Object.h>
  15
  16 #include <Events_Loop.h>
  17
  18 #include <Config_FeatureMessage.h>
  19 #include <ModuleBase_Tools.h>
  20 #include <ModuleBase_ActionInfo.h>
  21
  22 #include <PartSetPlugin_Part.h>
  23
  24 #include <QIcon>
  25 #include <QString>
  26 #include <QBrush>
  27 #include <QTreeView>
  28
  29 #include <set>
  30
  31 #define ACTIVE_COLOR QColor(0,72,140)
  32 #define PASSIVE_COLOR Qt::black
  33
  34 QMap<QString, QString> PartSet_DocumentDataModel::myIcons;
  35
  36
  37 PartSet_DocumentDataModel::PartSet_DocumentDataModel(QObject* theParent)
  38     : ModuleBase_IDocumentDataModel(theParent),
  39       myActivePartModel(0)
  40 {
  41   // Create a top part of data tree model
  42   myModel = new PartSet_TopDataModel(this);
  43   myModel->setItemsColor(ACTIVE_COLOR);
  44
  45   Events_Loop* aLoop = Events_Loop::loop();
  46   aLoop->registerListener(this, Events_Loop::eventByName(EVENT_OBJECT_UPDATED));
  47   aLoop->registerListener(this, Events_Loop::eventByName(EVENT_OBJECT_CREATED));
  48   aLoop->registerListener(this, Events_Loop::eventByName(EVENT_OBJECT_DELETED));
  49   aLoop->registerListener(this, Events_Loop::eventByName(Config_FeatureMessage::GUI_EVENT()));
  50 }
  51
  52 PartSet_DocumentDataModel::~PartSet_DocumentDataModel()
  53 {
  54   clearModelIndexes();
  55   clearSubModels();
  56 }
  57
  58 void PartSet_DocumentDataModel::processEvent(const std::shared_ptr<Events_Message>& theMessage)
  59 {
  60   DocumentPtr aRootDoc = ModelAPI_Session::get()->moduleDocument();
  61
  62
  63   // Created object event *******************
  64   if (theMessage->eventID() == Events_Loop::loop()->eventByName(EVENT_OBJECT_CREATED)) {
  65     std::shared_ptr<ModelAPI_ObjectUpdatedMessage> aUpdMsg =
  66         std::dynamic_pointer_cast<ModelAPI_ObjectUpdatedMessage>(theMessage);
  67     std::set<ObjectPtr> aObjects = aUpdMsg->objects();
  68
  69     std::set<ObjectPtr>::const_iterator aIt;
  70     for (aIt = aObjects.begin(); aIt != aObjects.end(); ++aIt) {
  71       ObjectPtr aObject = (*aIt);
  72       FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aObject);
  73       if (aFeature && (!aFeature->isInHistory()))
  74         continue;
  75
  76       DocumentPtr aDoc = aObject->document();
  77       if (aDoc == aRootDoc) {  // If root objects
  78         if (aObject->groupName() == ModelAPI_ResultPart::group()) {  // Update only Parts group
  79             // Add a new part
  80           int aStart = aRootDoc->size(ModelAPI_ResultPart::group());
  81           if (aStart > 0) {
  82             FeaturePtr aPartFeature = ModelAPI_Feature::feature(aObject);
  83             PartSet_PartDataModel* aModel = new PartSet_PartDataModel(this);
  84             int anId = aRootDoc->index(aPartFeature);
  85             aModel->setPart(aPartFeature);
  86             myPartModels.append(aModel);
  87             insertRow(aStart, partFolderNode(0));
  88           }
  89         } else {  // Update top groups (other except parts
  90           QModelIndex aIndex = myModel->findParent(aObject);
  91           int aStart = myModel->rowCount(aIndex) - 1;
  92           if (aStart < 0)
  93             aStart = 0;
  94           aIndex = createIndex(aIndex.row(), aIndex.column(), (void*) getModelIndex(aIndex));
  95           insertRow(aStart, aIndex);
  96         }
  97       } else {  // if sub-objects of first level nodes
  98         PartSet_PartModel* aPartModel = 0;
  99         foreach (PartSet_PartModel* aPart, myPartModels) {
 100           if (aPart->hasDocument(aDoc)) {
 101             aPartModel = aPart;
 102             break;
 103           }
 104         }
 105         if (aPartModel) {
 106           QModelIndex aIndex = aPartModel->findParent(aObject);
 107           int aStart = aPartModel->rowCount(aIndex);  // check this index
 108           aIndex = createIndex(aIndex.row(), aIndex.column(), (void*) getModelIndex(aIndex));
 109           insertRow(aStart, aIndex);
 110         } else
 111           reset();
 112       }
 113     }
 114     // Deleted object event ***********************
 115   } else if (theMessage->eventID() == Events_Loop::loop()->eventByName(EVENT_OBJECT_DELETED)) {
 116     std::shared_ptr<ModelAPI_ObjectDeletedMessage> aUpdMsg =
 117         std::dynamic_pointer_cast<ModelAPI_ObjectDeletedMessage>(theMessage);
 118     DocumentPtr aDoc = aUpdMsg->document();
 119     std::set<std::string> aGroups = aUpdMsg->groups();
 120
 121     std::set<std::string>::const_iterator aIt;
 122     for (aIt = aGroups.begin(); aIt != aGroups.end(); ++aIt) {
 123       std::string aGroup = (*aIt);
 124       if (aDoc == aRootDoc) {  // If root objects
 125         if (aGroup == ModelAPI_ResultPart::group()) {  // Update only Parts group
 126           PartSet_PartModel* aDelPartModel = 0;
 127           foreach (PartSet_PartModel* aPartModel, myPartModels) {
 128             if (aPartModel->position() == -1) {
 129               aDelPartModel = aPartModel;
 130               break;
 131             }
 132           }
 133           if (aDelPartModel) {
 134             deactivatePart();
 135             int aStart = myPartModels.size() - 1;
 136             removeSubModel(aDelPartModel);
 137             removeRow(aStart, partFolderNode(0));
 138           }
 139         } else {  // Update top groups (other except parts
 140           QModelIndex aIndex = myModel->findGroup(aGroup);
 141           int aStart = myModel->rowCount(aIndex);
 142           aIndex = createIndex(aIndex.row(), aIndex.column(), (void*) getModelIndex(aIndex));
 143           removeRow(aStart, aIndex);
 144         }
 145       } else {
 146         PartSet_PartModel* aPartModel = 0;
 147         foreach (PartSet_PartModel* aPart, myPartModels) {
 148           if (aPart->hasDocument(aDoc)) {
 149             aPartModel = aPart;
 150             break;
 151           }
 152         }
 153         if (aPartModel) {
 154           QModelIndex aIndex = aPartModel->findGroup(aGroup);
 155           int aStart = aPartModel->rowCount(aIndex);
 156           aIndex = createIndex(aIndex.row(), aIndex.column(), (void*) getModelIndex(aIndex));
 157           removeRow(aStart, aIndex);
 158         }
 159       }
 160     }
 161     // Deleted object event ***********************
 162   } else if (theMessage->eventID() == Events_Loop::loop()->eventByName(EVENT_OBJECT_UPDATED)) {
 163     //std::shared_ptr<ModelAPI_ObjectUpdatedMessage> aUpdMsg = std::dynamic_pointer_cast<ModelAPI_ObjectUpdatedMessage>(theMessage);
 164     //ObjectPtr aFeature = aUpdMsg->feature();
 165     //DocumentPtr aDoc = aFeature->document();
 166
 167     // TODO: Identify the necessary index by the modified feature
 168     QModelIndex aIndex;
 169     emit dataChanged(aIndex, aIndex);
 170
 171     // Reset whole tree **************************
 172   } else if (theMessage->eventID() == Events_Loop::loop()->eventByName(Config_FeatureMessage::GUI_EVENT())) {
 173     std::shared_ptr<Config_FeatureMessage> aFeatureMsg =
 174        std::dynamic_pointer_cast<Config_FeatureMessage>(theMessage);
 175     if (!aFeatureMsg->isInternal()) {
 176       ActionInfo aFeatureInfo;
 177       aFeatureInfo.initFrom(aFeatureMsg);
 178       // Remember features icons
 179       myIcons[QString::fromStdString(aFeatureMsg->id())] = aFeatureInfo.iconFile;
 180     }
 181   } else {
 182     rebuildDataTree();
 183   }
 184 }
 185
 186 void PartSet_DocumentDataModel::rebuildDataTree()
 187 {
 188   DocumentPtr aRootDoc = ModelAPI_Session::get()->moduleDocument();
 189
 190   beginResetModel();
 191   clearModelIndexes();
 192
 193   // Delete extra models
 194   ObjectPtr aObj;
 195   FeaturePtr aFeature;
 196   QList<PartSet_PartModel*> aDelList;
 197   foreach (PartSet_PartModel* aPartModel, myPartModels) {
 198     if (aPartModel->position() == -1)
 199       aDelList.append(aPartModel);
 200   }
 201   foreach (PartSet_PartModel* aPartModel, aDelList) {
 202     removeSubModel(aPartModel);
 203   }
 204   // Add non existing models
 205   int aHistNb = aRootDoc->size(ModelAPI_Feature::group());
 206   for (int i = 0; i < aHistNb; i++) {
 207     aObj = aRootDoc->object(ModelAPI_Feature::group(), i);
 208     aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aObj);
 209     if (aFeature->getKind() == PartSetPlugin_Part::ID()) {
 210       if (!findPartModel(aFeature)) {
 211         PartSet_PartDataModel* aModel = new PartSet_PartDataModel(this);
 212         aModel->setPart(aFeature);
 213         myPartModels.append(aModel);
 214       }
 215     }
 216   }
 217   endResetModel();
 218 }
 219
 220 QVariant PartSet_DocumentDataModel::data(const QModelIndex& theIndex, int theRole) const
 221 {
 222   if (!theIndex.isValid())
 223     return QVariant();
 224
 225   DocumentPtr aRootDoc = ModelAPI_Session::get()->moduleDocument();
 226   QModelIndex aParent = theIndex.parent();
 227   if ((theIndex.column() == 1) ) {
 228     if ((theIndex.internalId() >= PartsFolder) && (theIndex.internalId() <= PartResult)) {
 229       if (ModelAPI_Session::get()->activeDocument() == aRootDoc) {
 230         if (!aParent.isValid()) {
 231           switch (theRole) {
 232           case Qt::DecorationRole:
 233             if (theIndex.row() == lastHistoryRow())
 234               return QIcon(":pictures/arrow.png");
 235           }
 236         }
 237       }
 238     } else {
 239       QModelIndex* aIndex = toSourceModelIndex(theIndex);
 240       const QAbstractItemModel* aModel = aIndex->model();
 241       if (isPartSubModel(aModel)) {
 242         return aModel->data(*aIndex, theRole);
 243       }
 244     }
 245     return QVariant();
 246   }
 247
 248   switch (theIndex.internalId()) {
 249     case PartsFolder:
 250       switch (theRole) {
 251         case Qt::DisplayRole:
 252           return tr("Parts") + QString(" (%1)").arg(rowCount(theIndex));
 253         case Qt::DecorationRole:
 254           return QIcon(":pictures/constr_folder.png");
 255         case Qt::ToolTipRole:
 256           return tr("Parts folder");
 257         case Qt::ForegroundRole:
 258           if (myActivePartIndex.isValid())
 259               return QBrush(PASSIVE_COLOR);
 260             else
 261               return QBrush(ACTIVE_COLOR);
 262         default:
 263           return QVariant();
 264       }
 265       break;
 266     case HistoryNode:
 267       {
 268         int aOffset = historyOffset();
 269         ObjectPtr aObj = aRootDoc->object(ModelAPI_Feature::group(), theIndex.row() - aOffset);
 270         FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aObj);
 271         if (!aFeature)
 272           return QVariant();
 273         switch (theRole) {
 274           case Qt::DisplayRole:
 275             if (aFeature)
 276               return aFeature->data()->name().c_str();
 277             else
 278               return QVariant();
 279           case Qt::DecorationRole:
 280             return featureIcon(aFeature);
 281           case Qt::ToolTipRole:
 282             return tr("Feature object");
 283           case Qt::ForegroundRole:
 284             if (theIndex.row() > lastHistoryRow())
 285               return QBrush(Qt::lightGray);
 286             else {
 287               if (myActivePartIndex.isValid())
 288                 return QBrush(PASSIVE_COLOR);
 289               else
 290                 return QBrush(ACTIVE_COLOR);
 291             }
 292           default:
 293             return QVariant();
 294         }
 295       }
 296       break;
 297     case PartResult:
 298       {
 299         ObjectPtr aObject = aRootDoc->object(ModelAPI_ResultPart::group(), theIndex.row());
 300         if (aObject) {
 301           switch (theRole) {
 302             case Qt::DisplayRole:
 303               return std::dynamic_pointer_cast<ModelAPI_Object>(aObject)->data()->name().c_str();
 304             case Qt::DecorationRole:
 305               return QIcon(":pictures/part_ico.png");
 306             case Qt::ForegroundRole:
 307               {
 308                 if (theIndex == myActivePartIndex)
 309                   return QBrush(ACTIVE_COLOR);
 310                 else
 311                   return QBrush(PASSIVE_COLOR);
 312               }
 313             default:
 314               return QVariant();
 315           }
 316         }
 317       }
 318       break;
 319   }
 320   if (aParent.internalId() == HistoryNode) {
 321     int aId = aParent.row() - historyOffset();
 322     QModelIndex* aIndex = toSourceModelIndex(theIndex);
 323     return findPartModel(aId)->data(*aIndex, theRole);
 324   }
 325   return toSourceModelIndex(theIndex)->data(theRole);
 326 }
 327
 328 QVariant PartSet_DocumentDataModel::headerData(int theSection, Qt::Orientation theOrient,
 329                                             int theRole) const
 330 {
 331   return QVariant();
 332 }
 333
 334 int PartSet_DocumentDataModel::rowCount(const QModelIndex& theParent) const
 335 {
 336   DocumentPtr aRootDoc = ModelAPI_Session::get()->moduleDocument();
 337   if (!theParent.isValid()) {
 338     // Size of external models
 339     int aVal = historyOffset();
 340     // Plus history size
 341     aVal += aRootDoc->size(ModelAPI_Feature::group());
 342     return aVal;
 343   }
 344   if (theParent.internalId() == PartsFolder) {
 345     return aRootDoc->size(ModelAPI_ResultPart::group());
 346     //int aSize = myPartModels.size();
 347     //return myPartModels.size();
 348   }
 349   if (theParent.internalId() == HistoryNode) {
 350     int aId = theParent.row() - historyOffset();
 351     PartSet_PartModel* aModel = findPartModel(aId);
 352     if (aModel)
 353       return aModel->rowCount(QModelIndex());
 354     return 0;
 355   }
 356   if (theParent.internalId() == PartResult)
 357     return 0;
 358
 359   QModelIndex* aParent = toSourceModelIndex(theParent);
 360   const QAbstractItemModel* aModel = aParent->model();
 361   if (!isSubModel(aModel))
 362     return 0;
 363
 364   /*if (isPartSubModel(aModel)) {
 365    if (aModel != myActivePart)
 366    return 0;
 367    }*/
 368   return aModel->rowCount(*aParent);
 369 }
 370
 371 int PartSet_DocumentDataModel::columnCount(const QModelIndex& theParent) const
 372 {
 373   return 2;
 374 }
 375
 376 QModelIndex PartSet_DocumentDataModel::index(int theRow, int theColumn,
 377                                           const QModelIndex& theParent) const
 378 {
 379   QModelIndex aIndex;
 380   if (!theParent.isValid()) {
 381     int aOffs = myModel->rowCount();
 382     if (theRow < aOffs) {
 383       aIndex = myModel->index(theRow, theColumn, theParent);
 384       aIndex = createIndex(theRow, theColumn, (void*) getModelIndex(aIndex));
 385     } else {
 386       if (theRow == aOffs)  // Create Parts node
 387         aIndex = partFolderNode(theColumn);
 388       else {
 389         // create history node
 390         aIndex = createIndex(theRow, theColumn, HistoryNode);
 391       }
 392     }
 393   } else {
 394     if (theParent.internalId() == PartsFolder) {
 395        aIndex = createIndex(theRow, theColumn, PartResult);
 396     } else {
 397       if (theParent.internalId() == HistoryNode) {
 398         int aId = theParent.row() - historyOffset();
 399         aIndex = findPartModel(aId)->index(theRow, theColumn, QModelIndex());
 400       } else {
 401         QModelIndex* aParent = (QModelIndex*) theParent.internalPointer();
 402         aIndex = aParent->model()->index(theRow, theColumn, (*aParent));
 403       }
 404       aIndex = createIndex(theRow, theColumn, (void*) getModelIndex(aIndex));
 405     }
 406   }
 407   return aIndex;
 408 }
 409
 410 QModelIndex PartSet_DocumentDataModel::parent(const QModelIndex& theIndex) const
 411 {
 412   if ((theIndex.internalId() == PartsFolder) || (theIndex.internalId() == HistoryNode))
 413     return QModelIndex();
 414
 415   if (theIndex.internalId() == PartResult)
 416     return partFolderNode(0);
 417
 418   QModelIndex* aIndex = toSourceModelIndex(theIndex);
 419   const QAbstractItemModel* aModel = aIndex->model();
 420   if (!isSubModel(aModel))
 421     return QModelIndex();
 422
 423   QModelIndex aIndex1 = aModel->parent(*aIndex);
 424   const PartSet_PartModel* aPartModel = dynamic_cast<const PartSet_PartModel*>(aModel);
 425   if (aPartModel && (!aIndex1.isValid())) {
 426     int aId = aPartModel->position();
 427     int aRow = aId + historyOffset();
 428     return createIndex(aRow, 0, (qint32) HistoryNode);
 429   }
 430
 431   if (aIndex1.isValid())
 432     return createIndex(aIndex1.row(), 0, (void*) getModelIndex(aIndex1));
 433   return aIndex1;
 434 }
 435
 436 bool PartSet_DocumentDataModel::hasChildren(const QModelIndex& theParent) const
 437 {
 438   if (!theParent.isValid())
 439     return true;
 440   return rowCount(theParent) > 0;
 441 }
 442
 443 QModelIndex* PartSet_DocumentDataModel::toSourceModelIndex(const QModelIndex& theProxy) const
 444 {
 445   QModelIndex* aIndexPtr = static_cast<QModelIndex*>(theProxy.internalPointer());
 446   return aIndexPtr;
 447 }
 448
 449 QModelIndex* PartSet_DocumentDataModel::findModelIndex(const QModelIndex& theIndex) const
 450 {
 451   QList<QModelIndex*>::const_iterator aIt;
 452   for (aIt = myIndexes.constBegin(); aIt != myIndexes.constEnd(); ++aIt) {
 453     QModelIndex* aIndex = (*aIt);
 454     if ((*aIndex) == theIndex)
 455       return aIndex;
 456   }
 457   return 0;
 458 }
 459
 460 QModelIndex* PartSet_DocumentDataModel::getModelIndex(const QModelIndex& theIndex) const
 461 {
 462   QModelIndex* aIndexPtr = findModelIndex(theIndex);
 463   if (!aIndexPtr) {
 464     aIndexPtr = new QModelIndex(theIndex);
 465     PartSet_DocumentDataModel* that = (PartSet_DocumentDataModel*) this;
 466     that->myIndexes.append(aIndexPtr);
 467   }
 468   return aIndexPtr;
 469 }
 470
 471 void PartSet_DocumentDataModel::clearModelIndexes()
 472 {
 473   foreach (QModelIndex* aIndex, myIndexes)
 474     delete aIndex;
 475   myIndexes.clear();
 476 }
 477
 478 void PartSet_DocumentDataModel::clearSubModels()
 479 {
 480   foreach (PartSet_PartModel* aPart, myPartModels)
 481     delete aPart;
 482   myPartModels.clear();
 483 }
 484
 485 ObjectPtr PartSet_DocumentDataModel::object(const QModelIndex& theIndex) const
 486 {
 487   if (theIndex.internalId() == PartsFolder)
 488     return ObjectPtr();
 489   DocumentPtr aRootDoc = ModelAPI_Session::get()->moduleDocument();
 490   if (theIndex.internalId() == HistoryNode) {
 491     int aOffset = historyOffset();
 492     return aRootDoc->object(ModelAPI_Feature::group(), theIndex.row() - aOffset);
 493   }
 494   if (theIndex.internalId() == PartResult) {
 495     return aRootDoc->object(ModelAPI_ResultPart::group(), theIndex.row());
 496   }
 497   QModelIndex* aIndex = toSourceModelIndex(theIndex);
 498   if (!isSubModel(aIndex->model()))
 499     return ObjectPtr();
 500
 501   const PartSet_FeaturesModel* aModel = dynamic_cast<const PartSet_FeaturesModel*>(aIndex->model());
 502   return aModel->object(*aIndex);
 503 }
 504
 505 bool PartSet_DocumentDataModel::insertRows(int theRow, int theCount, const QModelIndex& theParent)
 506 {
 507   beginInsertRows(theParent, theRow, theRow + theCount - 1);
 508   //endInsertRows();
 509
 510   // Update history
 511   QModelIndex aRoot;
 512   int aRow = rowCount(aRoot);
 513   beginInsertRows(aRoot, aRow, aRow);
 514   endInsertRows();
 515
 516   return true;
 517 }
 518
 519 bool PartSet_DocumentDataModel::removeRows(int theRow, int theCount, const QModelIndex& theParent)
 520 {
 521   beginRemoveRows(theParent, theRow, theRow + theCount - 1);
 522   endRemoveRows();
 523   return true;
 524 }
 525
 526 void PartSet_DocumentDataModel::removeSubModel(int theModelId)
 527 {
 528   PartSet_PartModel* aModel = myPartModels.at(theModelId);
 529   removeSubModel(aModel);
 530 }
 531
 532 void PartSet_DocumentDataModel::removeSubModel(PartSet_PartModel* theModel)
 533 {
 534   QIntList aToRemove;
 535   for (int i = 0; i < myIndexes.size(); i++) {
 536     if (myIndexes.at(i)->model() == theModel)
 537       aToRemove.append(i);
 538   }
 539   int aId;
 540   while (aToRemove.size() > 0) {
 541     aId = aToRemove.last();
 542     delete myIndexes.at(aId);
 543     myIndexes.removeAt(aId);
 544     aToRemove.removeLast();
 545   }
 546   delete theModel;
 547   myPartModels.removeAll(theModel);
 548 }
 549
 550
 551 bool PartSet_DocumentDataModel::isSubModel(const QAbstractItemModel* theModel) const
 552 {
 553   if (theModel == myModel)
 554     return true;
 555   return isPartSubModel(theModel);
 556 }
 557
 558 bool PartSet_DocumentDataModel::isPartSubModel(const QAbstractItemModel* theModel) const
 559 {
 560   return myPartModels.contains((PartSet_PartModel*) theModel);
 561 }
 562
 563 QModelIndex PartSet_DocumentDataModel::partFolderNode(int theColumn) const
 564 {
 565   int aPos = myModel->rowCount(QModelIndex());
 566   return createIndex(aPos, theColumn, PartsFolder);
 567 }
 568
 569 int PartSet_DocumentDataModel::historyOffset() const
 570 {
 571   // Nb of rows of top model + Parts folder
 572   return myModel->rowCount(QModelIndex()) + 1;
 573 }
 574
 575 bool PartSet_DocumentDataModel::activatePart(const QModelIndex& theIndex)
 576 {
 577   if ((theIndex.internalId() == PartsFolder) || (theIndex.internalId() == HistoryNode))
 578     return false;
 579
 580   if (theIndex.isValid() && (theIndex.internalId() == PartResult)) {
 581     myActivePartIndex = theIndex;
 582     myModel->setItemsColor(PASSIVE_COLOR);
 583     if (myActivePartModel)
 584       myActivePartModel->setItemsColor(PASSIVE_COLOR);
 585
 586     // Find activated part feature by its ID
 587     ResultPartPtr aPartRes = activePart();
 588     FeaturePtr aFeature = ModelAPI_Feature::feature(aPartRes);
 589     if (aFeature.get()) {
 590       myActivePartModel = findPartModel(aFeature);
 591       myActivePartModel->setItemsColor(ACTIVE_COLOR);
 592     }
 593   }
 594   return true;
 595 }
 596
 597 ResultPartPtr PartSet_DocumentDataModel::activePart() const
 598 {
 599   if (myActivePartIndex.isValid()) {
 600     DocumentPtr aRootDoc = ModelAPI_Session::get()->moduleDocument();
 601     ObjectPtr aObj = aRootDoc->object(ModelAPI_ResultPart::group(), myActivePartIndex.row());
 602     return std::dynamic_pointer_cast<ModelAPI_ResultPart>(aObj);
 603   }
 604   return ResultPartPtr();
 605 }
 606
 607 QModelIndex PartSet_DocumentDataModel::activePartTree() const
 608 {
 609   if (myActivePartModel) {
 610     return createIndex(myActivePartModel->position() + historyOffset(), 0, HistoryNode);
 611   }
 612   return QModelIndex();
 613 }
 614
 615 void PartSet_DocumentDataModel::deactivatePart()
 616 {
 617   if (myActivePartIndex.isValid()) {
 618     if (myActivePartModel)
 619       myActivePartModel->setItemsColor(PASSIVE_COLOR);
 620     myActivePartModel = 0;
 621     myActivePartIndex = QModelIndex();
 622     myModel->setItemsColor(ACTIVE_COLOR);
 623   }
 624 }
 625
 626 Qt::ItemFlags PartSet_DocumentDataModel::flags(const QModelIndex& theIndex) const
 627 {
 628   if ((theIndex.internalId() >= PartsFolder) && (theIndex.internalId() <= PartResult)) {
 629     Qt::ItemFlags aFlags = Qt::ItemIsSelectable;
 630     if (object(theIndex)) {
 631       aFlags |= Qt::ItemIsEditable;
 632     }
 633     // Disable items which are below of last history row
 634     // Do not disable second column
 635     if (theIndex.internalId() == HistoryNode) {
 636       if (theIndex.row() <= lastHistoryRow() || (theIndex.column() == 1))
 637         aFlags |= Qt::ItemIsEnabled;
 638     } else
 639       aFlags |= Qt::ItemIsEnabled;
 640     return aFlags;
 641   } else {
 642     QModelIndex* aIndex = toSourceModelIndex(theIndex);
 643     const QAbstractItemModel* aModel = aIndex->model();
 644     return aModel->flags(*aIndex);
 645   }
 646 }
 647
 648 QModelIndex PartSet_DocumentDataModel::partIndex(const ResultPartPtr& theObject) const
 649 {
 650   DocumentPtr aRootDoc = ModelAPI_Session::get()->moduleDocument();
 651   int aNb = aRootDoc->size(ModelAPI_ResultPart::group());
 652   for (int aId = 0; aId < aNb; aId++) {
 653     if (theObject == aRootDoc->object(ModelAPI_ResultPart::group(), aId))
 654       return createIndex(aId, 0, PartResult);
 655   }
 656   return QModelIndex();
 657 }
 658
 659 QModelIndex PartSet_DocumentDataModel::objectIndex(const ObjectPtr theObject) const
 660 {
 661   // Check that this feature belongs to root document
 662   DocumentPtr aRootDoc = ModelAPI_Session::get()->moduleDocument();
 663   DocumentPtr aDoc = theObject->document();
 664   if (aDoc == aRootDoc) {
 665     // This feature belongs to histrory or top model
 666     FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(theObject);
 667     if (aFeature) {
 668       int aId;
 669       int aNb = aRootDoc->size(ModelAPI_Feature::group());
 670       for (aId = 0; aId < aNb; aId++) {
 671         if (theObject == aRootDoc->object(ModelAPI_Feature::group(), aId))
 672           break;
 673       }
 674       if (aId < aNb)
 675         return index(aId + historyOffset(), 0, QModelIndex());
 676     } else {
 677       QModelIndex aIndex = myModel->objectIndex(theObject);
 678       return
 679           aIndex.isValid() ?
 680               createIndex(aIndex.row(), 0, (void*) getModelIndex(aIndex)) :
 681               QModelIndex();
 682     }
 683   } else {
 684     PartSet_PartModel* aPartModel = 0;
 685     foreach(PartSet_PartModel* aModel, myPartModels) {
 686       if (aModel->hasDocument(aDoc)) {
 687         aPartModel = aModel;
 688         break;
 689       }
 690     }
 691     if (aPartModel) {
 692       QModelIndex aIndex = aPartModel->objectIndex(theObject);
 693       return aIndex.isValid() ?
 694               createIndex(aIndex.row(), 0, (void*) getModelIndex(aIndex)) :
 695               QModelIndex();
 696     }
 697   }
 698   return QModelIndex();
 699 }
 700
 701
 702 void PartSet_DocumentDataModel::clear()
 703 {
 704   clearModelIndexes();
 705   clearSubModels();
 706   //myActivePart = 0;
 707   myActivePartIndex = QModelIndex();
 708   myModel->setItemsColor(ACTIVE_COLOR);
 709 }
 710
 711 int PartSet_DocumentDataModel::lastHistoryRow() const
 712 {
 713   DocumentPtr aRootDoc = ModelAPI_Session::get()->moduleDocument();
 714   FeaturePtr aFeature = aRootDoc->currentFeature(true);
 715   if (aFeature.get())
 716     return historyOffset() + aRootDoc->index(aFeature);
 717   else
 718     return historyOffset() - 1;
 719 }
 720
 721 void PartSet_DocumentDataModel::setLastHistoryItem(const QModelIndex& theIndex)
 722 {
 723   SessionPtr aMgr = ModelAPI_Session::get();
 724   DocumentPtr aRootDoc = aMgr->moduleDocument();
 725   std::string aOpName = tr("History change").toStdString();
 726   if (theIndex.internalId() == HistoryNode) {
 727     ObjectPtr aObject = object(theIndex);
 728     aMgr->startOperation(aOpName);
 729     aRootDoc->setCurrentFeature(std::dynamic_pointer_cast<ModelAPI_Feature>(aObject), true);
 730     aMgr->finishOperation();
 731   } else {
 732     aMgr->startOperation(aOpName);
 733     aRootDoc->setCurrentFeature(FeaturePtr(), true);
 734     aMgr->finishOperation();
 735   }
 736 }
 737
 738 QModelIndex PartSet_DocumentDataModel::lastHistoryItem() const
 739 {
 740   return index(lastHistoryRow(), 1);
 741 }
 742
 743
 744 QIcon PartSet_DocumentDataModel::featureIcon(const FeaturePtr& theFeature)
 745 {
 746   QIcon anIcon;
 747
 748   std::string aKind = theFeature->getKind();
 749   QString aId(aKind.c_str());
 750   if (!myIcons.contains(aId))
 751     return anIcon;
 752
 753   QString anIconString = myIcons[aId];
 754
 755   ModelAPI_ExecState aState = theFeature->data()->execState();
 756   switch(aState) {
 757     case ModelAPI_StateDone:
 758     case ModelAPI_StateNothing: {
 759       anIcon = QIcon(anIconString);
 760     }
 761     break;
 762     case ModelAPI_StateMustBeUpdated: {
 763       anIcon = ModuleBase_Tools::lighter(anIconString);
 764     }
 765     break;
 766     case ModelAPI_StateExecFailed: {
 767       anIcon = ModuleBase_Tools::composite(":icons/exec_state_failed.png", anIconString);
 768     }
 769     break;
 770     case ModelAPI_StateInvalidArgument: {
 771       anIcon = ModuleBase_Tools::composite(":icons/exec_state_invalid_parameters.png",
 772                                            anIconString);
 773     }
 774     break;
 775     default: break;
 776   }
 777   return anIcon;
 778 }
 779
 780 void PartSet_DocumentDataModel::onMouseDoubleClick(const QModelIndex& theIndex)
 781 {
 782   if (theIndex.column() != 1)
 783     return;
 784   QTreeView* aTreeView = dynamic_cast<QTreeView*>(sender());
 785   if ((theIndex.internalId() >= PartsFolder) && (theIndex.internalId() <= PartResult)) {
 786     if (myActivePartModel)
 787       // It means that the root document is not active
 788       return;
 789     QModelIndex aNewIndex;
 790     if (theIndex.internalId() == HistoryNode)
 791       aNewIndex = theIndex;
 792     int aOldId = lastHistoryRow();
 793     setLastHistoryItem(theIndex);
 794     int aStartRow = std::min(aOldId, theIndex.row());
 795     int aEndRow = std::max(aOldId, theIndex.row());
 796     for (int i = aStartRow; i <= aEndRow; i++) {
 797       aTreeView->update(createIndex(i, 0, HistoryNode));
 798       aTreeView->update(createIndex(i, 1, HistoryNode));
 799     }
 800
 801   } else {
 802     QModelIndex* aIndex = toSourceModelIndex(theIndex);
 803     const QAbstractItemModel* aModel = aIndex->model();
 804     if (isPartSubModel(aModel)) {
 805       PartSet_PartDataModel* aPartModel = (PartSet_PartDataModel*)aModel;
 806       QModelIndex aOldItem = aPartModel->lastHistoryItem();
 807       aPartModel->setLastHistoryItem(*aIndex);
 808       QModelIndex aOldIndex = createIndex(aOldItem.row(), aOldItem.column(), (void*) getModelIndex(aOldItem));
 809       int aStartRow = std::min(aOldItem.row(), aIndex->row());
 810       int aEndRow = std::max(aOldItem.row(), aIndex->row());
 811       for (int i = aStartRow; i <= aEndRow; i++) {
 812         QModelIndex aInd1 = aPartModel->index(i, 0);
 813         QModelIndex aInd2 = createIndex(i, 0, (void*) getModelIndex(aInd1));
 814         aTreeView->update(aInd2);
 815         aInd1 = aPartModel->index(i, 1);
 816         aInd2 = createIndex(i, 1, (void*) getModelIndex(aInd1));
 817         aTreeView->update(aInd2);
 818       }
 819     }
 820   }
 821 }
 822
 823
 824 PartSet_PartModel* PartSet_DocumentDataModel::findPartModel(FeaturePtr thePart) const
 825 {
 826   foreach (PartSet_PartModel* aModel, myPartModels) {
 827     if (aModel->part() == thePart)
 828       return aModel;
 829   }
 830   return 0;
 831 }
 832
 833 PartSet_PartModel* PartSet_DocumentDataModel::findPartModel(int thePosition) const
 834 {
 835   foreach (PartSet_PartModel* aModel, myPartModels) {
 836     if (aModel->position() == thePosition)
 837       return aModel;
 838   }
 839   return 0;
 840 }