src/ModelAPI/ModelAPI_Events.cpp

   1 // Copyright (C) 2014-2017  CEA/DEN, EDF R&D
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License, or (at your option) any later version.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com<mailto:webmaster.salome@opencascade.com>
  18 //
  19
  20 /*
  21  * ModelAPI_Events.cpp
  22  *
  23  *  Created on: Dec 8, 2014
  24  *      Author: sbh
  25  */
  26
  27 #include <ModelAPI.h>
  28 #include <ModelAPI_Events.h>
  29
  30 ModelAPI_ObjectUpdatedMessage::ModelAPI_ObjectUpdatedMessage(const Events_ID theID,
  31                                                              const void* theSender)
  32     : Events_MessageGroup(theID, theSender)
  33 {
  34
  35 }
  36
  37 ModelAPI_ObjectUpdatedMessage::~ModelAPI_ObjectUpdatedMessage()
  38 {
  39
  40 }
  41
  42 ModelAPI_ObjectDeletedMessage::ModelAPI_ObjectDeletedMessage(const Events_ID theID,
  43                                                              const void* theSender)
  44     : Events_MessageGroup(theID, theSender)
  45 {
  46
  47 }
  48
  49 ModelAPI_ObjectDeletedMessage::~ModelAPI_ObjectDeletedMessage()
  50 {
  51
  52 }
  53
  54 ModelAPI_OrderUpdatedMessage::ModelAPI_OrderUpdatedMessage(const Events_ID theID,
  55                                                            const void* theSender)
  56     : Events_Message(theID, theSender)
  57 {
  58
  59 }
  60
  61 ModelAPI_OrderUpdatedMessage::~ModelAPI_OrderUpdatedMessage()
  62 {
  63
  64 }
  65
  66 ModelAPI_FeatureStateMessage::ModelAPI_FeatureStateMessage(const Events_ID theID,
  67                                                            const void* theSender)
  68  : Events_Message(theID, theSender)
  69 {
  70   myCurrentFeature = std::shared_ptr<ModelAPI_Feature>();
  71 }
  72
  73 ModelAPI_FeatureStateMessage::~ModelAPI_FeatureStateMessage()
  74 {
  75
  76 }
  77
  78 std::shared_ptr<ModelAPI_Feature> ModelAPI_FeatureStateMessage::feature() const
  79 {
  80   return myCurrentFeature;
  81 }
  82
  83 void ModelAPI_FeatureStateMessage::setFeature(std::shared_ptr<ModelAPI_Feature>& theFeature)
  84 {
  85   myCurrentFeature = theFeature;
  86 }
  87
  88 bool ModelAPI_FeatureStateMessage::hasState(const std::string& theKey) const
  89 {
  90   return myFeatureState.find(theKey) != myFeatureState.end();
  91 }
  92
  93 bool ModelAPI_FeatureStateMessage::state(const  std::string& theFeatureId, bool theDefault) const
  94 {
  95   if(hasState(theFeatureId)) {
  96     return myFeatureState.at(theFeatureId);
  97   }
  98   return theDefault;
  99 }
 100
 101 void ModelAPI_FeatureStateMessage::setState(const std::string& theFeatureId, bool theValue)
 102 {
 103   myFeatureState[theFeatureId] = theValue;
 104 }
 105
 106 std::list<std::string> ModelAPI_FeatureStateMessage::features() const
 107 {
 108   std::list<std::string> result;
 109   std::map<std::string, bool>::const_iterator it = myFeatureState.begin();
 110   for( ; it != myFeatureState.end(); ++it) {
 111     result.push_back(it->first);
 112   }
 113   return result;
 114 }
 115
 116
 117 ModelAPI_DocumentCreatedMessage::ModelAPI_DocumentCreatedMessage(
 118   const Events_ID theID, const void* theSender)
 119 : Events_Message(theID, theSender)
 120 {}
 121
 122 ModelAPI_DocumentCreatedMessage::~ModelAPI_DocumentCreatedMessage()
 123 {}
 124
 125 DocumentPtr ModelAPI_DocumentCreatedMessage::document() const
 126 {
 127   return myDocument;
 128 }
 129
 130 void ModelAPI_DocumentCreatedMessage::setDocument(DocumentPtr theDocument)
 131 {
 132   myDocument = theDocument;
 133 }
 134
 135 ModelAPI_AttributeEvalMessage::ModelAPI_AttributeEvalMessage(
 136   const Events_ID theID, const void* theSender)
 137 : Events_Message(theID, theSender)
 138 {}
 139
 140 ModelAPI_AttributeEvalMessage::~ModelAPI_AttributeEvalMessage()
 141 {}
 142
 143 AttributePtr ModelAPI_AttributeEvalMessage::attribute() const
 144 {
 145   return myAttribute;
 146 }
 147
 148 void ModelAPI_AttributeEvalMessage::setAttribute(AttributePtr theAttribute)
 149 {
 150   myAttribute = theAttribute;
 151 }
 152
 153 ModelAPI_ParameterEvalMessage::ModelAPI_ParameterEvalMessage(
 154   const Events_ID theID, const void* theSender)
 155   : Events_Message(theID, theSender), myIsProcessed(false)
 156 {}
 157
 158 ModelAPI_ParameterEvalMessage::~ModelAPI_ParameterEvalMessage()
 159 {}
 160
 161 FeaturePtr ModelAPI_ParameterEvalMessage::parameter() const
 162 {
 163   return myParam;
 164 }
 165
 166 void ModelAPI_ParameterEvalMessage::setParameter(FeaturePtr theParam)
 167 {
 168   myParam = theParam;
 169 }
 170
 171 void ModelAPI_ParameterEvalMessage::setResults(
 172     const std::list<std::shared_ptr<ModelAPI_ResultParameter> >& theParamsList,
 173     const double theResult, const std::string& theError)
 174 {
 175   myParamsList = theParamsList;
 176   myResult = theResult;
 177   myError = theError;
 178   myIsProcessed = true;
 179 }
 180
 181 bool ModelAPI_ParameterEvalMessage::isProcessed()
 182 {
 183   return myIsProcessed;
 184 }
 185
 186 const std::list<std::shared_ptr<ModelAPI_ResultParameter> >&
 187   ModelAPI_ParameterEvalMessage::params() const
 188 {
 189   return myParamsList;
 190 }
 191
 192 const double& ModelAPI_ParameterEvalMessage::result() const
 193 {
 194   return myResult;
 195 }
 196
 197 const std::string& ModelAPI_ParameterEvalMessage::error() const
 198 {
 199   return myError;
 200 }
 201
 202 ModelAPI_ComputePositionsMessage::ModelAPI_ComputePositionsMessage(
 203   const Events_ID theID, const void* theSender)
 204   : Events_Message(theID, theSender)
 205 {}
 206
 207 ModelAPI_ComputePositionsMessage::~ModelAPI_ComputePositionsMessage()
 208 {}
 209
 210 const std::string& ModelAPI_ComputePositionsMessage::expression() const
 211 {
 212   return myExpression;
 213 }
 214
 215 const std::string& ModelAPI_ComputePositionsMessage::parameter() const
 216 {
 217   return myParamName;
 218 }
 219
 220 void ModelAPI_ComputePositionsMessage::set(
 221   const std::string& theExpression, const std::string& theParameter)
 222 {
 223   myExpression = theExpression;
 224   myParamName = theParameter;
 225 }
 226
 227 void ModelAPI_ComputePositionsMessage::setPositions(
 228   const std::list<std::pair<int, int> >& thePositions)
 229 {
 230   myPositions = thePositions;
 231 }
 232
 233 const std::list<std::pair<int, int> >& ModelAPI_ComputePositionsMessage::positions() const
 234 {
 235   return myPositions;
 236 }
 237
 238
 239 ModelAPI_ObjectRenamedMessage::ModelAPI_ObjectRenamedMessage(const Events_ID theID,
 240                                                              const void* theSender)
 241 : Events_Message(theID, theSender)
 242 {
 243
 244 }
 245
 246 ModelAPI_ObjectRenamedMessage::~ModelAPI_ObjectRenamedMessage()
 247 {
 248
 249 }
 250
 251 void ModelAPI_ObjectRenamedMessage::send(ObjectPtr theObject,
 252                                          const std::string& theOldName,
 253                                          const std::string& theNewName,
 254                                          const void* theSender)
 255 {
 256   std::shared_ptr<ModelAPI_ObjectRenamedMessage> aMessage(
 257     new ModelAPI_ObjectRenamedMessage(eventId(), theSender));
 258   aMessage->setObject(theObject);
 259   aMessage->setOldName(theOldName);
 260   aMessage->setNewName(theNewName);
 261   Events_Loop::loop()->send(aMessage);
 262 }
 263
 264 ObjectPtr ModelAPI_ObjectRenamedMessage::object() const
 265 {
 266   return myObject;
 267 }
 268
 269 void ModelAPI_ObjectRenamedMessage::setObject(ObjectPtr theObject)
 270 {
 271   myObject = theObject;
 272 }
 273
 274 std::string ModelAPI_ObjectRenamedMessage::oldName() const
 275 {
 276   return myOldName;
 277 }
 278
 279 void ModelAPI_ObjectRenamedMessage::setOldName(const std::string& theOldName)
 280 {
 281   myOldName = theOldName;
 282 }
 283
 284 std::string ModelAPI_ObjectRenamedMessage::newName() const
 285 {
 286   return myNewName;
 287 }
 288
 289 void ModelAPI_ObjectRenamedMessage::setNewName(const std::string& theNewName)
 290 {
 291   myNewName = theNewName;
 292 }
 293
 294 ModelAPI_ReplaceParameterMessage::ModelAPI_ReplaceParameterMessage(const Events_ID theID,
 295                                                                    const void* theSender)
 296 : Events_Message(theID, theSender)
 297 {
 298
 299 }
 300
 301 ModelAPI_ReplaceParameterMessage::~ModelAPI_ReplaceParameterMessage()
 302 {
 303
 304 }
 305
 306 void ModelAPI_ReplaceParameterMessage::send(ObjectPtr theObject,
 307                                             const void* theSender)
 308 {
 309   std::shared_ptr<ModelAPI_ReplaceParameterMessage> aMessage(
 310       new ModelAPI_ReplaceParameterMessage(eventId(), theSender));
 311   aMessage->setObject(theObject);
 312   Events_Loop::loop()->send(aMessage);
 313 }
 314
 315 ObjectPtr ModelAPI_ReplaceParameterMessage::object() const
 316 {
 317   return myObject;
 318 }
 319
 320 void ModelAPI_ReplaceParameterMessage::setObject(ObjectPtr theObject)
 321 {
 322   myObject = theObject;
 323 }
 324
 325
 326 // =====   ModelAPI_SolverFailedMessage   =====
 327 ModelAPI_SolverFailedMessage::ModelAPI_SolverFailedMessage(const Events_ID theID,
 328                                                            const void* theSender)
 329   : Events_Message(theID, theSender),
 330     myDOF(-1)
 331 {
 332 }
 333
 334 ModelAPI_SolverFailedMessage::~ModelAPI_SolverFailedMessage()
 335 {
 336 }
 337
 338 void ModelAPI_SolverFailedMessage::setObjects(const std::set<ObjectPtr>& theObjects)
 339 {
 340   myObjects = theObjects;
 341 }
 342
 343 const std::set<ObjectPtr>& ModelAPI_SolverFailedMessage::objects() const
 344 {
 345   return myObjects;
 346 }
 347