src/ModelAPI/ModelAPI_Events.cpp

   1 // Copyright (C) 2014-20xx CEA/DEN, EDF R&D
   2
   3 /*
   4  * ModelAPI_Events.cpp
   5  *
   6  *  Created on: Dec 8, 2014
   7  *      Author: sbh
   8  */
   9
  10 #include <ModelAPI.h>
  11 #include <ModelAPI_Events.h>
  12
  13 #include <GeomAPI_Pnt2d.h>
  14
  15 ModelAPI_ObjectUpdatedMessage::ModelAPI_ObjectUpdatedMessage(const Events_ID theID,
  16                                                              const void* theSender)
  17     : Events_MessageGroup(theID, theSender)
  18 {
  19
  20 }
  21
  22 ModelAPI_ObjectUpdatedMessage::~ModelAPI_ObjectUpdatedMessage()
  23 {
  24
  25 }
  26
  27 ModelAPI_ObjectDeletedMessage::ModelAPI_ObjectDeletedMessage(const Events_ID theID,
  28                                                              const void* theSender)
  29     : Events_MessageGroup(theID, theSender)
  30 {
  31
  32 }
  33
  34 ModelAPI_ObjectDeletedMessage::~ModelAPI_ObjectDeletedMessage()
  35 {
  36
  37 }
  38
  39 ModelAPI_OrderUpdatedMessage::ModelAPI_OrderUpdatedMessage(const Events_ID theID,
  40                                                            const void* theSender)
  41     : Events_Message(theID, theSender)
  42 {
  43
  44 }
  45
  46 ModelAPI_OrderUpdatedMessage::~ModelAPI_OrderUpdatedMessage()
  47 {
  48
  49 }
  50
  51 ModelAPI_FeatureStateMessage::ModelAPI_FeatureStateMessage(const Events_ID theID,
  52                                                            const void* theSender)
  53  : Events_Message(theID, theSender)
  54 {
  55   myCurrentFeature = std::shared_ptr<ModelAPI_Feature>();
  56 }
  57
  58 ModelAPI_FeatureStateMessage::~ModelAPI_FeatureStateMessage()
  59 {
  60
  61 }
  62
  63 std::shared_ptr<ModelAPI_Feature> ModelAPI_FeatureStateMessage::feature() const
  64 {
  65   return myCurrentFeature;
  66 }
  67
  68 void ModelAPI_FeatureStateMessage::setFeature(std::shared_ptr<ModelAPI_Feature>& theFeature)
  69 {
  70   myCurrentFeature = theFeature;
  71 }
  72
  73 bool ModelAPI_FeatureStateMessage::hasState(const std::string& theKey) const
  74 {
  75   return myFeatureState.find(theKey) != myFeatureState.end();
  76 }
  77
  78 bool ModelAPI_FeatureStateMessage::state(const  std::string& theFeatureId, bool theDefault) const
  79 {
  80   if(hasState(theFeatureId)) {
  81     return myFeatureState.at(theFeatureId);
  82   }
  83   return theDefault;
  84 }
  85
  86 void ModelAPI_FeatureStateMessage::setState(const std::string& theFeatureId, bool theValue)
  87 {
  88   myFeatureState[theFeatureId] = theValue;
  89 }
  90
  91 std::list<std::string> ModelAPI_FeatureStateMessage::features() const
  92 {
  93   std::list<std::string> result;
  94   std::map<std::string, bool>::const_iterator it = myFeatureState.begin();
  95   for( ; it != myFeatureState.end(); ++it) {
  96     result.push_back(it->first);
  97   }
  98   return result;
  99 }
 100
 101
 102 ModelAPI_DocumentCreatedMessage::ModelAPI_DocumentCreatedMessage(
 103   const Events_ID theID, const void* theSender)
 104 : Events_Message(theID, theSender)
 105 {}
 106
 107 ModelAPI_DocumentCreatedMessage::~ModelAPI_DocumentCreatedMessage()
 108 {}
 109
 110 DocumentPtr ModelAPI_DocumentCreatedMessage::document() const
 111 {
 112   return myDocument;
 113 }
 114
 115 void ModelAPI_DocumentCreatedMessage::setDocument(DocumentPtr theDocument)
 116 {
 117   myDocument = theDocument;
 118 }
 119
 120 ModelAPI_AttributeEvalMessage::ModelAPI_AttributeEvalMessage(
 121   const Events_ID theID, const void* theSender)
 122 : Events_Message(theID, theSender)
 123 {}
 124
 125 ModelAPI_AttributeEvalMessage::~ModelAPI_AttributeEvalMessage()
 126 {}
 127
 128 AttributePtr ModelAPI_AttributeEvalMessage::attribute() const
 129 {
 130   return myAttribute;
 131 }
 132
 133 void ModelAPI_AttributeEvalMessage::setAttribute(AttributePtr theAttribute)
 134 {
 135   myAttribute = theAttribute;
 136 }
 137
 138 ModelAPI_ParameterEvalMessage::ModelAPI_ParameterEvalMessage(
 139   const Events_ID theID, const void* theSender)
 140   : Events_Message(theID, theSender), myIsProcessed(false)
 141 {}
 142
 143 ModelAPI_ParameterEvalMessage::~ModelAPI_ParameterEvalMessage()
 144 {}
 145
 146 FeaturePtr ModelAPI_ParameterEvalMessage::parameter() const
 147 {
 148   return myParam;
 149 }
 150
 151 void ModelAPI_ParameterEvalMessage::setParameter(FeaturePtr theParam)
 152 {
 153   myParam = theParam;
 154 }
 155
 156 void ModelAPI_ParameterEvalMessage::setResults(
 157     const std::list<std::shared_ptr<ModelAPI_ResultParameter> >& theParamsList,
 158     const double theResult, const std::string& theError)
 159 {
 160   myParamsList = theParamsList;
 161   myResult = theResult;
 162   myError = theError;
 163   myIsProcessed = true;
 164 }
 165
 166 bool ModelAPI_ParameterEvalMessage::isProcessed()
 167 {
 168   return myIsProcessed;
 169 }
 170
 171 const std::list<std::shared_ptr<ModelAPI_ResultParameter> >&
 172   ModelAPI_ParameterEvalMessage::params() const
 173 {
 174   return myParamsList;
 175 }
 176
 177 const double& ModelAPI_ParameterEvalMessage::result() const
 178 {
 179   return myResult;
 180 }
 181
 182 const std::string& ModelAPI_ParameterEvalMessage::error() const
 183 {
 184   return myError;
 185 }
 186
 187 ModelAPI_ComputePositionsMessage::ModelAPI_ComputePositionsMessage(
 188   const Events_ID theID, const void* theSender)
 189   : Events_Message(theID, theSender)
 190 {}
 191
 192 ModelAPI_ComputePositionsMessage::~ModelAPI_ComputePositionsMessage()
 193 {}
 194
 195 const std::string& ModelAPI_ComputePositionsMessage::expression() const
 196 {
 197   return myExpression;
 198 }
 199
 200 const std::string& ModelAPI_ComputePositionsMessage::parameter() const
 201 {
 202   return myParamName;
 203 }
 204
 205 void ModelAPI_ComputePositionsMessage::set(
 206   const std::string& theExpression, const std::string& theParameter)
 207 {
 208   myExpression = theExpression;
 209   myParamName = theParameter;
 210 }
 211
 212 void ModelAPI_ComputePositionsMessage::setPositions(
 213   const std::list<std::pair<int, int> >& thePositions)
 214 {
 215   myPositions = thePositions;
 216 }
 217
 218 const std::list<std::pair<int, int> >& ModelAPI_ComputePositionsMessage::positions() const
 219 {
 220   return myPositions;
 221 }
 222
 223
 224 ModelAPI_ObjectRenamedMessage::ModelAPI_ObjectRenamedMessage(const Events_ID theID,
 225                                                              const void* theSender)
 226 : Events_Message(theID, theSender)
 227 {
 228
 229 }
 230
 231 ModelAPI_ObjectRenamedMessage::~ModelAPI_ObjectRenamedMessage()
 232 {
 233
 234 }
 235
 236 void ModelAPI_ObjectRenamedMessage::send(ObjectPtr theObject,
 237                                          const std::string& theOldName,
 238                                          const std::string& theNewName,
 239                                          const void* theSender)
 240 {
 241   std::shared_ptr<ModelAPI_ObjectRenamedMessage> aMessage(
 242     new ModelAPI_ObjectRenamedMessage(eventId(), theSender));
 243   aMessage->setObject(theObject);
 244   aMessage->setOldName(theOldName);
 245   aMessage->setNewName(theNewName);
 246   Events_Loop::loop()->send(aMessage);
 247 }
 248
 249 ObjectPtr ModelAPI_ObjectRenamedMessage::object() const
 250 {
 251   return myObject;
 252 }
 253
 254 void ModelAPI_ObjectRenamedMessage::setObject(ObjectPtr theObject)
 255 {
 256   myObject = theObject;
 257 }
 258
 259 std::string ModelAPI_ObjectRenamedMessage::oldName() const
 260 {
 261   return myOldName;
 262 }
 263
 264 void ModelAPI_ObjectRenamedMessage::setOldName(const std::string& theOldName)
 265 {
 266   myOldName = theOldName;
 267 }
 268
 269 std::string ModelAPI_ObjectRenamedMessage::newName() const
 270 {
 271   return myNewName;
 272 }
 273
 274 void ModelAPI_ObjectRenamedMessage::setNewName(const std::string& theNewName)
 275 {
 276   myNewName = theNewName;
 277 }
 278
 279 ModelAPI_ReplaceParameterMessage::ModelAPI_ReplaceParameterMessage(const Events_ID theID,
 280                                                                    const void* theSender)
 281 : Events_Message(theID, theSender)
 282 {
 283
 284 }
 285
 286 ModelAPI_ReplaceParameterMessage::~ModelAPI_ReplaceParameterMessage()
 287 {
 288
 289 }
 290
 291 void ModelAPI_ReplaceParameterMessage::send(ObjectPtr theObject,
 292                                             const void* theSender)
 293 {
 294   std::shared_ptr<ModelAPI_ReplaceParameterMessage> aMessage(
 295       new ModelAPI_ReplaceParameterMessage(eventId(), theSender));
 296   aMessage->setObject(theObject);
 297   Events_Loop::loop()->send(aMessage);
 298 }
 299
 300 ObjectPtr ModelAPI_ReplaceParameterMessage::object() const
 301 {
 302   return myObject;
 303 }
 304
 305 void ModelAPI_ReplaceParameterMessage::setObject(ObjectPtr theObject)
 306 {
 307   myObject = theObject;
 308 }
 309
 310
 311 // =====   ModelAPI_SolverFailedMessage   =====
 312 ModelAPI_SolverFailedMessage::ModelAPI_SolverFailedMessage(const Events_ID theID,
 313                                                            const void* theSender)
 314   : Events_Message(theID, theSender),
 315     myDOF(-1)
 316 {
 317 }
 318
 319 ModelAPI_SolverFailedMessage::~ModelAPI_SolverFailedMessage()
 320 {
 321 }
 322
 323 void ModelAPI_SolverFailedMessage::setObjects(const std::set<ObjectPtr>& theObjects)
 324 {
 325   myObjects = theObjects;
 326 }
 327
 328 const std::set<ObjectPtr>& ModelAPI_SolverFailedMessage::objects() const
 329 {
 330   return myObjects;
 331 }
 332
 333
 334 // =====   ModelAPI_ObjectMovedMessage   =====
 335 ModelAPI_ObjectMovedMessage::ModelAPI_ObjectMovedMessage(const void* theSender)
 336   : Events_Message(Events_Loop::eventByName(EVENT_OBJECT_MOVED), theSender)
 337 {
 338 }
 339
 340 void ModelAPI_ObjectMovedMessage::setMovedObject(const ObjectPtr& theMovedObject)
 341 {
 342   myMovedObject = theMovedObject;
 343   myMovedAttribute = AttributePtr();
 344 }
 345
 346 void ModelAPI_ObjectMovedMessage::setMovedAttribute(const AttributePtr& theMovedAttribute)
 347 {
 348   myMovedAttribute = theMovedAttribute;
 349   myMovedObject = ObjectPtr();
 350 }
 351
 352 void ModelAPI_ObjectMovedMessage::setOriginalPosition(double theX, double theY)
 353 {
 354   myOriginalPosition = std::shared_ptr<GeomAPI_Pnt2d>(new GeomAPI_Pnt2d(theX, theY));
 355 }
 356
 357 void ModelAPI_ObjectMovedMessage::setOriginalPosition(const std::shared_ptr<GeomAPI_Pnt2d>& thePoint)
 358 {
 359   myOriginalPosition = thePoint;
 360 }
 361
 362 void ModelAPI_ObjectMovedMessage::setCurrentPosition(double theX, double theY)
 363 {
 364   myCurrentPosition = std::shared_ptr<GeomAPI_Pnt2d>(new GeomAPI_Pnt2d(theX, theY));
 365 }
 366
 367 void ModelAPI_ObjectMovedMessage::setCurrentPosition(const std::shared_ptr<GeomAPI_Pnt2d>& thePoint)
 368 {
 369   myCurrentPosition = thePoint;
 370 }