src/ModuleBase/ModuleBase_Operation.cpp

   1 /*
   2  * ModuleBase_Operation.cpp
   3  *
   4  *  Created on: Apr 2, 2014
   5  *      Author: sbh
   6  */
   7
   8 #include "ModuleBase_Operation.h"
   9
  10 #include <ModelAPI_AttributeDouble.h>
  11 #include <ModelAPI_Document.h>
  12 #include <ModelAPI_Feature.h>
  13 #include <ModelAPI_Data.h>
  14 #include <ModelAPI_PluginManager.h>
  15 #include <ModelAPI_Document.h>
  16
  17 #ifdef _DEBUG
  18 #include <QDebug>
  19 #endif
  20
  21 /*!
  22  \brief Constructor
  23  \param XGUI_Workshop - workshop for this operation
  24
  25  Constructs an empty operation. Constructor should work very fast because many
  26  operators may be created after starting workshop but only several from them
  27  may be used. As result this constructor stores given workshop in myApp field
  28  and set Waiting status.
  29  */
  30 ModuleBase_Operation::ModuleBase_Operation(const QString& theId, QObject* parent)
  31     : QObject(parent),
  32       myFlags(Transaction),
  33       myState(Waiting),
  34       myExecStatus(Rejected),
  35       myOperationId(theId)
  36 {
  37 }
  38
  39 /*!
  40  * \brief Destructor
  41  */
  42 ModuleBase_Operation::~ModuleBase_Operation()
  43 {
  44
  45 }
  46
  47 /*!
  48  * \brief Unique name of the operation
  49  *
  50  *  Returns string name of the operation.
  51  */
  52 QString ModuleBase_Operation::operationId() const
  53 {
  54   return myOperationId;
  55 }
  56
  57 /*!
  58  * \brief Replied whether the operation should be commited after the start, or the operation itself
  59  *  do that. The default realization provides the check by the operation having the xml prepresentation
  60  *  @return the boolean value
  61  */
  62 bool ModuleBase_Operation::isPerformedImmediately() const
  63 {
  64   return xmlRepresentation().isEmpty();
  65 }
  66
  67 std::shared_ptr<ModelAPI_Feature> ModuleBase_Operation::feature() const
  68 {
  69   return myFeature;
  70 }
  71
  72 /*!
  73  * \brief Gets state of operation
  74  * \return Value from OperationState enumeration
  75  *
  76  * Gets state of operation (see OperationState enumeration)
  77  */
  78 ModuleBase_Operation::OperationState ModuleBase_Operation::state() const
  79 {
  80   return myState;
  81 }
  82
  83 /*!
  84  * \brief Verifies whether operation is an ran one (state()==Running)
  85  * \return TRUE if operation is active, FALSE otherwise
  86  *
  87  * Verifies whether operation is an running. Returns TRUE if state of operator
  88  * is Running
  89  */
  90 bool ModuleBase_Operation::isRunning() const
  91 {
  92   return state() == Running;
  93 }
  94
  95 /*!
  96  * \brief Verifies whether given operator is valid for this one
  97  * \param theOtherOp - other operation
  98  * \return Returns TRUE if the given operator is valid for this one
  99  *
 100  * Verifies whether given operator is valid for this one (i.e. can be started "above"
 101  * this operator)
 102  */
 103 bool ModuleBase_Operation::isValid(ModuleBase_Operation*) const
 104 {
 105   return false;
 106 }
 107
 108 /*!
 109  * \brief Verifies whether this operator can be always started above any already running one
 110  * \return Returns TRUE if current operation must not be checked for ActiveOperation->IsValid( this )
 111  *
 112  * This method must be redefined in derived operation if operation of derived class
 113  * must be always can start above any launched one. Default implementation returns FALSE,
 114  * so it is being checked for IsValid, but some operations may overload IsGranted()
 115  * In this case they will always start, no matter what operation is running.
 116  */
 117 bool ModuleBase_Operation::isGranted() const
 118 {
 119   return false;
 120 }
 121
 122 /*
 123  * Returns pointer to the root document.
 124  */
 125 std::shared_ptr<ModelAPI_Document> ModuleBase_Operation::document() const
 126 {
 127   return ModelAPI_PluginManager::get()->rootDocument();
 128 }
 129
 130 /*!
 131  * \brief Sets slot which is called when operation is started
 132  * \param theReceiver - object containing slot
 133  * \param theSlot - slot of theReceiver object
 134  * \return TR if slot was connected successfully, FALSE otherwise
 135  *
 136  * Sets slot which is called when operation is started. There is no point in
 137  * using this method. It would be better to inherit own operator from base
 138  * one and redefine startOperation method
 139  */
 140 bool ModuleBase_Operation::setSlot(const QObject* theReceiver, const char* theSlot)
 141 {
 142   return connect(this, SIGNAL(callSlot()), theReceiver, theSlot);
 143 }
 144
 145 /*!
 146  * \brief Sets the flags of operation
 147  * \param f - flags of operation to be set
 148  *
 149  *  Sets flags of operation (see Flags enumeration)
 150  */
 151 void ModuleBase_Operation::setFlags(const int f)
 152 {
 153   myFlags = myFlags | f;
 154 }
 155
 156 /*!
 157  * \brief Clears the flags of operation
 158  * \param f - flags of operation to be cleared
 159  *
 160  *  Clears flags of operation (see Flags enumeration)
 161  */
 162 void ModuleBase_Operation::clearFlags(const int f)
 163 {
 164   myFlags = myFlags & ~f;
 165 }
 166
 167 /*!
 168  * \brief Test the flags of operation
 169  * \param f - flags of operation to be tested
 170  *
 171  *  Returns TRUE if the specified flags set in the operation (see Flags enumeration)
 172  */
 173 bool ModuleBase_Operation::testFlags(const int f) const
 174 {
 175   return (myFlags & f) == f;
 176 }
 177
 178 /*!
 179  * \brief Gets execution status
 180  * \return Execution status
 181  *
 182  * Gets execution status
 183  */
 184 int ModuleBase_Operation::execStatus() const
 185 {
 186   return myExecStatus;
 187 }
 188
 189 /*!
 190  *  \brief Returns XML representation of the operation's widget.
 191  *  \return XML QString
 192  *
 193  *  Returns XML representation of the operation's widget.
 194  */
 195 const QString& ModuleBase_Operation::xmlRepresentation() const
 196 {
 197   return myXmlRepr;
 198 }
 199
 200 /*!
 201  *  \brief Sets XML representation of the operation's widget.
 202  *  \param xmlRepr - XML QString
 203  *
 204  *  Sets XML representation of the operation's widget.
 205  */
 206 void ModuleBase_Operation::setXmlRepresentation(const QString& xmlRepr)
 207 {
 208   myXmlRepr = xmlRepr;
 209 }
 210
 211 /*!
 212  * \brief Starts operation
 213  *
 214  * Public slot. Verifies whether operation can be started and starts operation.
 215  * This slot is not virtual and cannot be redefined. Redefine startOperation method
 216  * to change behavior of operation. There is no point in using this method. It would
 217  * be better to inherit own operator from base one and redefine startOperation method
 218  * instead.
 219  */
 220 void ModuleBase_Operation::start()
 221 {
 222   //document()->start(this);
 223   document()->startOperation();
 224
 225   startOperation();
 226   emit started();
 227 }
 228
 229 /*!
 230  * \brief Aborts operation
 231  *
 232  * Public slot. Aborts operation. This slot is not virtual and cannot be redefined.
 233  * Redefine abortOperation method to change behavior of operation instead
 234  */
 235 void ModuleBase_Operation::abort()
 236 {
 237   abortOperation();
 238   myState = Waiting;
 239   emit aborted();
 240
 241   stopOperation();
 242
 243   document()->abortOperation();
 244   emit stopped();
 245 }
 246
 247 /*!
 248  * \brief Commits operation
 249  *
 250  * Public slot. Commits operation. This slot is not virtual and cannot be redefined.
 251  * Redefine commitOperation method to change behavior of operation instead
 252  */
 253 void ModuleBase_Operation::commit()
 254 {
 255   commitOperation();
 256   myState = Waiting;
 257   emit committed();
 258
 259   stopOperation();
 260
 261   document()->finishOperation();
 262   emit stopped();
 263 }
 264
 265 /*!
 266  * \brief Stores a real value in model.
 267  * \param theValue - to store
 268  *
 269  * Public slot. Passes theValue into the model.
 270  */
 271 void ModuleBase_Operation::storeReal(double theValue)
 272 {
 273   if(!myFeature){
 274     #ifdef _DEBUG
 275     qDebug() << "ModuleBase_Operation::storeReal: " <<
 276         "trying to store value without opening a transaction.";
 277     #endif
 278     return;
 279   }
 280   QString anId = sender()->objectName();
 281   std::shared_ptr<ModelAPI_Data> aData = myFeature->data();
 282   std::shared_ptr<ModelAPI_AttributeDouble> aReal = aData->real(anId.toStdString());
 283   aReal->setValue(theValue);
 284 }
 285
 286 /*!
 287  * \brief Verifies whether operator is ready to start.
 288  * \return TRUE if operation is ready to start
 289  *
 290  * Default implementation returns TRUE. Redefine this method to add own verifications
 291  */
 292 bool ModuleBase_Operation::isReadyToStart() const
 293 {
 294   return true;
 295 }
 296
 297 /*!
 298  * \brief Virtual method called when operation is started
 299  *
 300  * Virtual method called when operation started (see start() method for more description)
 301  * Default implementation calls corresponding slot and commits immediately.
 302  */
 303 void ModuleBase_Operation::startOperation()
 304 {
 305   std::shared_ptr<ModelAPI_Document> aDoc = ModelAPI_PluginManager::get()->rootDocument();
 306   myFeature = aDoc->addFeature(myOperationId.toStdString());
 307   if (myFeature) // TODO: generate an error if feature was not created
 308     myFeature->execute();
 309   //emit callSlot();
 310   //commit();
 311 }
 312
 313 /*!
 314  * \brief Virtual method called when operation is started
 315  *
 316  * Virtual method called when operation stopped - committed or aborted.
 317  */
 318 void ModuleBase_Operation::stopOperation()
 319 {
 320 }
 321
 322 /*!
 323  * \brief Virtual method called when operation aborted
 324  *
 325  * Virtual method called when operation aborted (see abort() method for more description)
 326  */
 327 void ModuleBase_Operation::abortOperation()
 328 {
 329 }
 330
 331 /*!
 332  * \brief Virtual method called when operation committed
 333  *
 334  * Virtual method called when operation committed (see commit() method for more description)
 335  */
 336 void ModuleBase_Operation::commitOperation()
 337 {
 338   if (myFeature) myFeature->execute();
 339 }
 340
 341 /*!
 342  * \brief Sets execution status
 343  * \param theStatus - execution status
 344  *
 345  * Sets myExecStatus to the given value
 346  */
 347 void ModuleBase_Operation::setExecStatus(const int theVal)
 348 {
 349   myExecStatus = (ExecStatus) theVal;
 350 }
 351
 352 /*!
 353  * \brief Sets state of operation
 354  * \param theState - state of operation to be set
 355  *
 356  *  Sets state of operation (see OperationState enumeration)
 357  */
 358 void ModuleBase_Operation::setState(const ModuleBase_Operation::OperationState theState)
 359 {
 360   myState = theState;
 361 }