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       // update selection for the case something was updated higher in the history
 192       // while this feature was disabled
 193       static Events_Loop* aLoop = Events_Loop::loop();
 194       static Events_ID kUpdatedSel = aLoop->eventByName(EVENT_UPDATE_SELECTION);
 195       static const ModelAPI_EventCreator* aECreator = ModelAPI_EventCreator::get();
 196       aECreator->sendUpdated(data()->owner(), kUpdatedSel, false);
 197     }
 198     return true;
 199   }
 200   return false;
 201 }
 202
 203 bool ModelAPI_Feature::isDisabled()
 204 {
 205   return myIsDisabled;
 206 }
 207
 208 bool ModelAPI_Feature::setStable(const bool theFlag)
 209 {
 210   if (myIsStable != theFlag) {
 211     myIsStable = theFlag;
 212     // send an event about the stability change (editing is started/finished)
 213     static Events_Loop* aLoop = Events_Loop::loop();
 214     static Events_ID EVENT_STAB = aLoop->eventByName(EVENT_STABILITY_CHANGED);
 215     std::shared_ptr<Events_Message> aMessage(new Events_Message(EVENT_STAB, this));
 216     aLoop->send(aMessage, false);
 217     return true;
 218   }
 219   return false;
 220 }
 221
 222 bool ModelAPI_Feature::isStable()
 223 {
 224   return myIsStable;
 225 }
 226
 227 bool ModelAPI_Feature::customAction(const std::string& theActionId)
 228 {
 229   return false;
 230 }
 231
 232 bool ModelAPI_Feature::isPreviewNeeded() const
 233 {
 234   return true;
 235 }
 236
 237 void ModelAPI_Feature::init()
 238 {
 239   myIsDisabled = false;
 240   myIsStable = true;
 241 }