src/ModelAPI/ModelAPI_Feature.cpp

   1 // Copyright (C) 2014-20xx CEA/DEN, EDF R&D
   2
   3 // File:        ModelAPI_Feature.cpp
   4 // Created:     17 Jul 2014
   5 // Author:      Mikhail PONIKAROV
   6
   7 #include "ModelAPI_Feature.h"
   8 #include <ModelAPI_Events.h>
   9 #include <ModelAPI_Result.h>
  10 #include <ModelAPI_Data.h>
  11 #include <ModelAPI_Document.h>
  12 #include <ModelAPI_Session.h>
  13 #include <Events_Loop.h>
  14
  15 const std::list<std::shared_ptr<ModelAPI_Result> >& ModelAPI_Feature::results()
  16 {
  17   return myResults;
  18 }
  19
  20 std::shared_ptr<ModelAPI_Result> ModelAPI_Feature::firstResult() const
  21 {
  22   return myResults.empty() ? std::shared_ptr<ModelAPI_Result>() : *(myResults.begin());
  23 }
  24
  25 std::shared_ptr<ModelAPI_Result> ModelAPI_Feature::lastResult()
  26 {
  27   return myResults.empty() ? std::shared_ptr<ModelAPI_Result>() : *(myResults.rbegin());
  28 }
  29
  30 void ModelAPI_Feature::setResult(const std::shared_ptr<ModelAPI_Result>& theResult)
  31 {
  32   static Events_ID EVENT_UPD = Events_Loop::eventByName(EVENT_OBJECT_UPDATED);
  33   static const ModelAPI_EventCreator* aECreator = ModelAPI_EventCreator::get();
  34
  35   if (firstResult() == theResult) {
  36     // nothing to change
  37   } else if (!myResults.empty()) {  // all except first become disabled
  38     std::list<std::shared_ptr<ModelAPI_Result> >::iterator aResIter = myResults.begin();
  39     *aResIter = theResult;
  40     aECreator->sendUpdated(theResult, EVENT_UPD);
  41     for(aResIter++; aResIter != myResults.end(); aResIter++) {
  42       (*aResIter)->setDisabled((*aResIter), true);
  43     }
  44   } else {
  45     myResults.push_back(theResult);
  46   }
  47   // in any case result becomes enabled
  48   theResult->setDisabled(theResult, false);
  49 }
  50
  51 void ModelAPI_Feature::setResult(const std::shared_ptr<ModelAPI_Result>& theResult,
  52                                  const int theIndex)
  53 {
  54   std::list<std::shared_ptr<ModelAPI_Result> >::iterator aResIter = myResults.begin();
  55   for (int anIndex = 0; anIndex < theIndex; anIndex++) {
  56     aResIter++;
  57   }
  58   if (aResIter == myResults.end()) {  // append
  59     myResults.push_back(theResult);
  60   } else {  // update
  61     *aResIter = theResult;
  62   }
  63   theResult->setDisabled(theResult, false);
  64 }
  65
  66 void ModelAPI_Feature::removeResult(const std::shared_ptr<ModelAPI_Result>& theResult)
  67 {
  68   theResult->setDisabled(theResult, true);
  69   // flush visualisation changes
  70   static Events_Loop* aLoop = Events_Loop::loop();
  71   static Events_ID aRedispEvent = aLoop->eventByName(EVENT_OBJECT_TO_REDISPLAY);
  72   aLoop->flush(aRedispEvent);
  73 }
  74
  75 void ModelAPI_Feature::eraseResultFromList(const std::shared_ptr<ModelAPI_Result>& theResult)
  76 {
  77   std::list<std::shared_ptr<ModelAPI_Result> >::iterator aResIter = myResults.begin();
  78   for(; aResIter != myResults.end(); aResIter++) {
  79     ResultPtr aRes = *aResIter;
  80     if (aRes == theResult) {
  81       std::string aGroup = aRes->groupName();
  82       aRes->setDisabled(aRes, true); // for complex results to disable all subs
  83       aRes->data()->erase();
  84       myResults.erase(aResIter);
  85
  86       static Events_Loop* aLoop = Events_Loop::loop();
  87       static Events_ID EVENT_DISP = aLoop->eventByName(EVENT_OBJECT_TO_REDISPLAY);
  88       static const ModelAPI_EventCreator* aECreator = ModelAPI_EventCreator::get();
  89       aECreator->sendDeleted(document(), aGroup);
  90       aECreator->sendUpdated(aRes, EVENT_DISP);
  91       break;
  92     }
  93   }
  94 }
  95
  96 void ModelAPI_Feature::removeResults(const int theSinceIndex, const bool theFlush)
  97 {
  98   std::list<std::shared_ptr<ModelAPI_Result> >::iterator aResIter = myResults.begin();
  99   for(int anIndex = 0; anIndex < theSinceIndex && aResIter != myResults.end(); anIndex++)
 100     aResIter++;
 101
 102   std::string aGroup;
 103   std::list<std::shared_ptr<ModelAPI_Result> >::iterator aNextIter = aResIter;
 104   while( aNextIter != myResults.end()) {
 105     aGroup = (*aNextIter)->groupName();
 106     // remove previously erased results: to enable later if needed only actual (of history change)
 107     if (theSinceIndex == 0 && (*aNextIter)->isDisabled()) {
 108       aNextIter = myResults.erase(aNextIter);
 109     } else {
 110       (*aNextIter)->setDisabled(*aNextIter, true); // just disable results
 111       aNextIter++;
 112     }
 113   }
 114   if (!aGroup.empty() && theFlush) {
 115     // flush visualisation changes
 116     static Events_Loop* aLoop = Events_Loop::loop();
 117     static Events_ID aRedispEvent = aLoop->eventByName(EVENT_OBJECT_TO_REDISPLAY);
 118     aLoop->flush(aRedispEvent);
 119     static Events_ID aDelEvent = aLoop->eventByName(EVENT_OBJECT_DELETED);
 120     aLoop->flush(aDelEvent);
 121   }
 122 }
 123
 124 void ModelAPI_Feature::eraseResults()
 125 {
 126   removeResults(0);
 127 }
 128
 129 const std::string& ModelAPI_Feature::documentToAdd()
 130 {
 131   // empty to use the current document
 132   static const std::string anEmpty;
 133   return anEmpty;
 134 }
 135
 136 void ModelAPI_Feature::erase()
 137 {
 138   // if this is the current feature, make the upper feature as current before removing
 139   if (document().get() && document()->currentFeature(false).get() == this) {
 140     document()->setCurrentFeatureUp();
 141   }
 142
 143   static Events_Loop* aLoop = Events_Loop::loop();
 144   static Events_ID EVENT_DISP = aLoop->eventByName(EVENT_OBJECT_TO_REDISPLAY);
 145   static const ModelAPI_EventCreator* aECreator = ModelAPI_EventCreator::get();
 146
 147   while (!myResults.empty()) {  // remove one by one with messages
 148     std::shared_ptr<ModelAPI_Result> aRes = *(myResults.begin());
 149     aRes->setDisabled(aRes, true); // to avoid activation of the Part result
 150     if (!myResults.empty()) // disabling result may erase the list (on undo of Part, issue 665)
 151       myResults.erase(myResults.begin());
 152   }
 153   ModelAPI_Object::erase();
 154 }
 155
 156 ModelAPI_Feature::~ModelAPI_Feature()
 157 {
 158   erase();
 159 }
 160
 161 FeaturePtr ModelAPI_Feature::feature(ObjectPtr theObject)
 162 {
 163   FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(theObject);
 164   if (!aFeature) {
 165     ResultPtr aResult = std::dynamic_pointer_cast<ModelAPI_Result>(theObject);
 166     if (aResult) {
 167       DocumentPtr aDoc = aResult->document();
 168       return aDoc->feature(aResult);
 169     }
 170   }
 171   return aFeature;
 172 }
 173
 174 bool ModelAPI_Feature::isMacro() const
 175 {
 176   return false;
 177 }
 178
 179 bool ModelAPI_Feature::setDisabled(const bool theFlag)
 180 {
 181   if (myIsDisabled != theFlag) {
 182     myIsDisabled = theFlag;
 183     if (myIsDisabled) {
 184       removeResults(0, false); // flush will be in setCurrentFeature
 185     } else {
 186       // enable all disabled previously results
 187       std::list<std::shared_ptr<ModelAPI_Result> >::iterator aResIter = myResults.begin();
 188       for(; aResIter != myResults.end(); aResIter++) {
 189         (*aResIter)->setDisabled(*aResIter, false);
 190       }
 191     }
 192     return true;
 193   }
 194   return false;
 195 }
 196
 197 bool ModelAPI_Feature::isDisabled()
 198 {
 199   return myIsDisabled;
 200 }
 201
 202 bool ModelAPI_Feature::isPreviewNeeded() const
 203 {
 204   return true;
 205 }