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