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()
  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_Loop* aLoop = Events_Loop::loop();
  33   static Events_ID EVENT_UPD = Events_Loop::eventByName(EVENT_OBJECT_UPDATED);
  34   static const ModelAPI_EventCreator* aECreator = ModelAPI_EventCreator::get();
  35
  36   if (firstResult() == theResult) {
  37     // nothing to change
  38   } else if (!myResults.empty()) {  // all except first become disabled
  39     std::list<std::shared_ptr<ModelAPI_Result> >::iterator aResIter = myResults.begin();
  40     *aResIter = theResult;
  41     aECreator->sendUpdated(theResult, EVENT_UPD);
  42     for(aResIter++; aResIter != myResults.end(); aResIter++) {
  43       (*aResIter)->setDisabled((*aResIter), true);
  44     }
  45   } else {
  46     myResults.push_back(theResult);
  47   }
  48   // in any case result becomes enabled
  49   theResult->setDisabled(theResult, false);
  50   // flush vidualisation changes
  51   static Events_ID aRedispEvent = aLoop->eventByName(EVENT_OBJECT_TO_REDISPLAY);
  52   aLoop->flush(aRedispEvent);
  53 }
  54
  55 void ModelAPI_Feature::setResult(const std::shared_ptr<ModelAPI_Result>& theResult,
  56                                  const int theIndex)
  57 {
  58   std::list<std::shared_ptr<ModelAPI_Result> >::iterator aResIter = myResults.begin();
  59   for (int anIndex = 0; anIndex < theIndex; anIndex++) {
  60     aResIter++;
  61   }
  62   if (aResIter == myResults.end()) {  // append
  63     myResults.push_back(theResult);
  64   } else {  // update
  65     *aResIter = theResult;
  66   }
  67   theResult->setDisabled(theResult, false);
  68   // flush visualisation changes
  69   static Events_Loop* aLoop = Events_Loop::loop();
  70   static Events_ID aRedispEvent = aLoop->eventByName(EVENT_OBJECT_TO_REDISPLAY);
  71   aLoop->flush(aRedispEvent);
  72 }
  73
  74 void ModelAPI_Feature::removeResult(const std::shared_ptr<ModelAPI_Result>& theResult)
  75 {
  76   theResult->setDisabled(theResult, true);
  77   // flush visualisation changes
  78   static Events_Loop* aLoop = Events_Loop::loop();
  79   static Events_ID aRedispEvent = aLoop->eventByName(EVENT_OBJECT_TO_REDISPLAY);
  80   aLoop->flush(aRedispEvent);
  81 }
  82
  83 void ModelAPI_Feature::removeResults(const int theSinceIndex, const bool theFlush)
  84 {
  85   std::list<std::shared_ptr<ModelAPI_Result> >::iterator aResIter = myResults.begin();
  86   for(int anIndex = 0; anIndex < theSinceIndex && aResIter != myResults.end(); anIndex++)
  87     aResIter++;
  88   std::list<std::shared_ptr<ModelAPI_Result> >::iterator aNextIter = aResIter;
  89   while( aNextIter != myResults.end()) {
  90     // remove previously erased results: to enable later if needed only actual (of history change)
  91     if (theSinceIndex == 0 && (*aNextIter)->isDisabled()) {
  92       aNextIter = myResults.erase(aNextIter);
  93     } else {
  94       (*aNextIter)->setDisabled(*aNextIter, true); // just disable results
  95       aNextIter++;
  96     }
  97   }
  98   if (theFlush) {
  99     // flush visualisation changes
 100     static Events_Loop* aLoop = Events_Loop::loop();
 101     static Events_ID aRedispEvent = aLoop->eventByName(EVENT_OBJECT_TO_REDISPLAY);
 102     aLoop->flush(aRedispEvent);
 103   }
 104 }
 105
 106 void ModelAPI_Feature::eraseResults()
 107 {
 108   removeResults(0);
 109 }
 110
 111 const std::string& ModelAPI_Feature::documentToAdd()
 112 {
 113   // empty to use the current document
 114   static const std::string anEmpty;
 115   return anEmpty;
 116 }
 117
 118 void ModelAPI_Feature::erase()
 119 {
 120   static Events_Loop* aLoop = Events_Loop::loop();
 121   static Events_ID EVENT_DISP = aLoop->eventByName(EVENT_OBJECT_TO_REDISPLAY);
 122   static const ModelAPI_EventCreator* aECreator = ModelAPI_EventCreator::get();
 123
 124   while (!myResults.empty()) {  // remove one by one with messages
 125     std::shared_ptr<ModelAPI_Result> aRes = *(myResults.begin());
 126     myResults.erase(myResults.begin());
 127     aECreator->sendDeleted(aRes->document(), aRes->groupName());
 128     aECreator->sendUpdated(aRes, EVENT_DISP);
 129   }
 130   ModelAPI_Object::erase();
 131 }
 132
 133 ModelAPI_Feature::~ModelAPI_Feature()
 134 {
 135   erase();
 136 }
 137
 138 FeaturePtr ModelAPI_Feature::feature(ObjectPtr theObject)
 139 {
 140   FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(theObject);
 141   if (!aFeature) {
 142     ResultPtr aResult = std::dynamic_pointer_cast<ModelAPI_Result>(theObject);
 143     if (aResult) {
 144       DocumentPtr aDoc = aResult->document();
 145       return aDoc->feature(aResult);
 146     }
 147   }
 148   return aFeature;
 149 }
 150
 151 bool ModelAPI_Feature::isMacro() const
 152 {
 153   return false;
 154 }
 155
 156 bool ModelAPI_Feature::setDisabled(const bool theFlag)
 157 {
 158   if (myIsDisabled != theFlag) {
 159     myIsDisabled = theFlag;
 160     if (myIsDisabled) {
 161       removeResults(0, false); // flush will be in setCurrentFeature
 162     } else {
 163       // enable all disabled previously results
 164       std::list<std::shared_ptr<ModelAPI_Result> >::iterator aResIter = myResults.begin();
 165       for(; aResIter != myResults.end(); aResIter++) {
 166         (*aResIter)->setDisabled(*aResIter, false);
 167       }
 168     }
 169     return true;
 170   }
 171   return false;
 172 }
 173
 174 bool ModelAPI_Feature::isDisabled() const
 175 {
 176   return myIsDisabled;
 177 }
 178
 179 bool ModelAPI_Feature::isPreviewNeeded() const
 180 {
 181   return true;
 182 }