X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FModuleBase%2FModuleBase_Operation.cpp;h=8c2f4a274f6372e3d2c3739f8e137737b51de1cb;hb=6f7ce111d1694790c7b2ec920d49e926a7a50106;hp=c3a0bd6fec3cef5b19649dc6fc7ba1f7b22689a9;hpb=8f7629543f0653bd6e4ed7b2a8669c20162b6167;p=modules%2Fshaper.git

diff --git a/src/ModuleBase/ModuleBase_Operation.cpp b/src/ModuleBase/ModuleBase_Operation.cpp
index c3a0bd6fe..896da097e 100644
--- a/src/ModuleBase/ModuleBase_Operation.cpp
+++ b/src/ModuleBase/ModuleBase_Operation.cpp
@@ -7,339 +7,328 @@
 
 #include "ModuleBase_Operation.h"
 
+#include "ModuleBase_OperationDescription.h"
+#include "ModuleBase_ModelWidget.h"
+#include "ModuleBase_WidgetValueFeature.h"
+#include "ModuleBase_ViewerPrs.h"
+#include "ModuleBase_IPropertyPanel.h"
+#include "ModuleBase_ISelection.h"
+
 #include <ModelAPI_AttributeDouble.h>
 #include <ModelAPI_Document.h>
 #include <ModelAPI_Feature.h>
-#include <ModelAPI_Object.h>
-#include <ModelAPI_PluginManager.h>
+#include <ModelAPI_Data.h>
 #include <ModelAPI_Document.h>
+#include <ModelAPI_Events.h>
+#include <ModelAPI_Result.h>
+#include <ModelAPI_Object.h>
+#include <ModelAPI_Validator.h>
+#include <ModelAPI_Session.h>
+
+#include <GeomAPI_Pnt2d.h>
+
+#include <Events_Loop.h>
 
 #ifdef _DEBUG
 #include <QDebug>
 #endif
 
-/*!
- \brief Constructor
- \param XGUI_Workshop - workshop for this operation
-
- Constructs an empty operation. Constructor should work very fast because many
- operators may be created after starting workshop but only several from them
- may be used. As result this constructor stores given workshop in myApp field
- and set Waiting status.
- */
-ModuleBase_Operation::ModuleBase_Operation(const QString& theId, QObject* parent)
-    : QObject(parent),
-      myFlags(Transaction),
-      myState(Waiting),
-      myExecStatus(Rejected),
-      myOperationId(theId)
+ModuleBase_Operation::ModuleBase_Operation(const QString& theId, QObject* theParent)
+    : QObject(theParent),
+      myIsEditing(false),
+      myIsModified(false),
+      myPropertyPanel(NULL)
 {
+  myDescription = new ModuleBase_OperationDescription(theId);
 }
 
-/*!
- * \brief Destructor
- */
 ModuleBase_Operation::~ModuleBase_Operation()
 {
+  delete myDescription;
+}
 
+QString ModuleBase_Operation::id() const
+{
+  return getDescription()->operationId();
 }
 
-/*!
- * \brief Unique name of the operation
- *
- *  Returns string name of the operation.
- */
-QString ModuleBase_Operation::operationId() const
+FeaturePtr ModuleBase_Operation::feature() const
 {
-  return myOperationId;
+  return myFeature;
 }
 
-/*!
- * \brief Gets state of operation
- * \return Value from OperationState enumeration
- *
- * Gets state of operation (see OperationState enumeration)
- */
-ModuleBase_Operation::OperationState ModuleBase_Operation::state() const
+bool ModuleBase_Operation::isValid() const
 {
-  return myState;
+  if (!myFeature)
+    return true; // rename operation
+  //Get validators for the Id
+  SessionPtr aMgr = ModelAPI_Session::get();
+  ModelAPI_ValidatorsFactory* aFactory = aMgr->validators();
+  return aFactory->validate(myFeature);
 }
 
-/*!
- * \brief Verifies whether operation is an ran one (state()==Running)
- * \return TRUE if operation is active, FALSE otherwise
- *
- * Verifies whether operation is an running. Returns TRUE if state of operator
- * is Running
- */
-bool ModuleBase_Operation::isRunning() const
+bool ModuleBase_Operation::isNestedOperationsEnabled() const
 {
-  return state() == Running;
+  return true;
 }
 
-/*!
- * \brief Verifies whether given operator is valid for this one
- * \param theOtherOp - other operation
- * \return Returns TRUE if the given operator is valid for this one
- *
- * Verifies whether given operator is valid for this one (i.e. can be started "above"
- * this operator)
- */
-bool ModuleBase_Operation::isValid(ModuleBase_Operation*) const
+void ModuleBase_Operation::storeCustomValue()
 {
-  return false;
+  if (!myFeature) {
+#ifdef _DEBUG
+    qDebug() << "ModuleBase_Operation::storeCustom: " <<
+    "trying to store value without opening a transaction.";
+#endif
+    return;
+  }
+
+  ModuleBase_ModelWidget* aCustom = dynamic_cast<ModuleBase_ModelWidget*>(sender());
+  if (aCustom)
+    aCustom->storeValue();
 }
 
-/*!
- * \brief Verifies whether this operator can be always started above any already running one
- * \return Returns TRUE if current operation must not be checked for ActiveOperation->IsValid( this )
- *
- * This method must be redefined in derived operation if operation of derived class
- * must be always can start above any launched one. Default implementation returns FALSE,
- * so it is being checked for IsValid, but some operations may overload IsGranted()
- * In this case they will always start, no matter what operation is running.
- */
-bool ModuleBase_Operation::isGranted() const
+void ModuleBase_Operation::startOperation()
 {
-  return false;
+  if (!myIsEditing)
+    createFeature();
 }
 
-/*
- * Returns pointer to the root document.
- */
-std::shared_ptr<ModelAPI_Document> ModuleBase_Operation::document() const
+void ModuleBase_Operation::stopOperation()
 {
-  return ModelAPI_PluginManager::get()->rootDocument();
 }
 
-/*!
- * \brief Sets slot which is called when operation is started
- * \param theReceiver - object containing slot
- * \param theSlot - slot of theReceiver object
- * \return TR if slot was connected successfully, FALSE otherwise
- *
- * Sets slot which is called when operation is started. There is no point in
- * using this method. It would be better to inherit own operator from base
- * one and redefine startOperation method
- */
-bool ModuleBase_Operation::setSlot(const QObject* theReceiver, const char* theSlot)
+void ModuleBase_Operation::abortOperation()
 {
-  return connect(this, SIGNAL(callSlot()), theReceiver, theSlot);
 }
 
-/*!
- * \brief Sets the flags of operation
- * \param f - flags of operation to be set
- *
- *  Sets flags of operation (see Flags enumeration)
- */
-void ModuleBase_Operation::setFlags(const int f)
+void ModuleBase_Operation::commitOperation()
 {
-  myFlags = myFlags | f;
 }
 
-/*!
- * \brief Clears the flags of operation
- * \param f - flags of operation to be cleared
- *
- *  Clears flags of operation (see Flags enumeration)
- */
-void ModuleBase_Operation::clearFlags(const int f)
+void ModuleBase_Operation::afterCommitOperation()
 {
-  myFlags = myFlags & ~f;
 }
 
-/*!
- * \brief Test the flags of operation
- * \param f - flags of operation to be tested
- *
- *  Returns TRUE if the specified flags set in the operation (see Flags enumeration)
- */
-bool ModuleBase_Operation::testFlags(const int f) const
+bool ModuleBase_Operation::canBeCommitted() const
 {
-  return (myFlags & f) == f;
+  return true;
 }
 
-/*!
- * \brief Gets execution status
- * \return Execution status
- *
- * Gets execution status
- */
-int ModuleBase_Operation::execStatus() const
+void ModuleBase_Operation::flushUpdated()
 {
-  return myExecStatus;
+  Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_UPDATED));
 }
 
-/*!
- *  \brief Returns XML representation of the operation's widget.
- *  \return XML QString
- *
- *  Returns XML representation of the operation's widget.
- */
-const QString& ModuleBase_Operation::xmlRepresentation() const
+void ModuleBase_Operation::flushCreated()
 {
-  return myXmlRepr;
+  Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_CREATED));
 }
 
-/*!
- *  \brief Sets XML representation of the operation's widget.
- *  \param xmlRepr - XML QString
- *
- *  Sets XML representation of the operation's widget.
- */
-void ModuleBase_Operation::setXmlRepresentation(const QString& xmlRepr)
+FeaturePtr ModuleBase_Operation::createFeature(
+  const bool theFlushMessage, CompositeFeaturePtr theCompositeFeature)
 {
-  myXmlRepr = xmlRepr;
+  if (theCompositeFeature) {
+    myFeature = theCompositeFeature->addFeature(getDescription()->operationId().toStdString());
+  } else {
+    boost::shared_ptr<ModelAPI_Document> aDoc = document();
+    myFeature = aDoc->addFeature(getDescription()->operationId().toStdString());
+  }
+  if (myFeature) {  // TODO: generate an error if feature was not created
+    myIsModified = true;
+    // Model update should call "execute" of a feature.
+    //myFeature->execute();
+    // Init default values
+    /*QList<ModuleBase_ModelWidget*> aWidgets = getDescription()->modelWidgets();
+     QList<ModuleBase_ModelWidget*>::const_iterator anIt = aWidgets.begin(), aLast = aWidgets.end();
+     for (; anIt != aLast; anIt++) {
+     (*anIt)->storeValue(aFeature);
+     }*/
+  }
+
+  if (theFlushMessage)
+    flushCreated();
+  return myFeature;
 }
 
-/*!
- * \brief Starts operation
- *
- * Public slot. Verifies whether operation can be started and starts operation.
- * This slot is not virtual and cannot be redefined. Redefine startOperation method
- * to change behavior of operation. There is no point in using this method. It would
- * be better to inherit own operator from base one and redefine startOperation method
- * instead.
- */
+void ModuleBase_Operation::setFeature(FeaturePtr theFeature)
+{
+  myFeature = theFeature;
+  myIsEditing = true;
+}
+
+bool ModuleBase_Operation::hasObject(ObjectPtr theObj) const
+{
+  FeaturePtr aFeature = feature();
+  if (aFeature) {
+    if (aFeature == theObj)
+      return true;
+    std::list<ResultPtr> aResults = aFeature->results();
+    std::list<ResultPtr>::const_iterator aIt;
+    for (aIt = aResults.cbegin(); aIt != aResults.cend(); ++aIt) {
+      if ((*aIt) == theObj)
+        return true;
+    }
+  }
+  return false;
+}
+
+
+boost::shared_ptr<ModelAPI_Document> ModuleBase_Operation::document() const
+{
+  return ModelAPI_Session::get()->moduleDocument();
+}
+
+
 void ModuleBase_Operation::start()
 {
-  //document()->start(this);
-  document()->startOperation();
+  ModelAPI_Session::get()->startOperation();
 
   startOperation();
   emit started();
 }
 
-/*!
- * \brief Aborts operation
- *
- * Public slot. Aborts operation. This slot is not virtual and cannot be redefined.
- * Redefine abortOperation method to change behavior of operation instead
- */
+void ModuleBase_Operation::resume()
+{
+  if (myPropertyPanel)
+    connect(myPropertyPanel, SIGNAL(widgetActivated(ModuleBase_ModelWidget*)),
+            this,            SLOT(onWidgetActivated(ModuleBase_ModelWidget*)));
+  emit resumed();
+}
+
 void ModuleBase_Operation::abort()
 {
   abortOperation();
-  myState = Waiting;
   emit aborted();
+  if (myPropertyPanel)
+    disconnect(myPropertyPanel, 0, this, 0);
 
   stopOperation();
-  emit stopped();
 
-  document()->abortOperation();
+  ModelAPI_Session::get()->abortOperation();
+  emit stopped();
 }
 
-/*!
- * \brief Commits operation
- *
- * Public slot. Commits operation. This slot is not virtual and cannot be redefined.
- * Redefine commitOperation method to change behavior of operation instead
- */
-void ModuleBase_Operation::commit()
+bool ModuleBase_Operation::commit()
 {
-  commitOperation();
-  myState = Waiting;
-  emit committed();
+  if (canBeCommitted()) {
+    commitOperation();
+    emit committed();
 
-  stopOperation();
-  emit stopped();
+  if (myPropertyPanel)
+    disconnect(myPropertyPanel, 0, this, 0);
 
-  document()->finishOperation();
-}
+    stopOperation();
+    ModelAPI_Session::get()->finishOperation();
 
-/*!
- * \brief Stores a real value in model.
- * \param theValue - to store
- *
- * Public slot. Passes theValue into the model.
- */
-void ModuleBase_Operation::storeReal(double theValue)
-{
-  if(!myFeature){
-    #ifdef _DEBUG
-    qDebug() << "ModuleBase_Operation::storeReal: " <<
-        "trying to store value without opening a transaction.";
-    #endif
-    return;
+    emit stopped();
+
+    afterCommitOperation();
+    return true;
   }
-  QString anId = sender()->objectName();
-  std::shared_ptr<ModelAPI_Object> aData = myFeature->data();
-  std::shared_ptr<ModelAPI_AttributeDouble> aReal = aData->real(anId.toStdString());
-  aReal->setValue(theValue);
+  return false;
 }
 
-/*!
- * \brief Verifies whether operator is ready to start.
- * \return TRUE if operation is ready to start
- *
- * Default implementation returns TRUE. Redefine this method to add own verifications
- */
-bool ModuleBase_Operation::isReadyToStart() const
+void ModuleBase_Operation::setRunning(bool theState)
 {
-  return true;
+  if (!theState) {
+    abort();
+  }
 }
 
-/*!
- * \brief Virtual method called when operation is started
- *
- * Virtual method called when operation started (see start() method for more description)
- * Default implementation calls corresponding slot and commits immediately.
- */
-void ModuleBase_Operation::startOperation()
+bool ModuleBase_Operation::activateByPreselection()
 {
-  std::shared_ptr<ModelAPI_Document> aDoc = ModelAPI_PluginManager::get()->rootDocument();
-  myFeature = aDoc->addFeature(myOperationId.toStdString());
-  myFeature->execute();
-  //emit callSlot();
-  //commit();
-}
+  if (!myPropertyPanel)
+    return false;
+  if (myPreSelection.empty())
+    return false;
+  const QList<ModuleBase_ModelWidget*>& aWidgets = myPropertyPanel->modelWidgets();
+  if (aWidgets.empty())
+    return false;
+  
+  ModuleBase_ModelWidget* aWgt;
+  ModuleBase_ViewerPrs aPrs;
+  QList<ModuleBase_ModelWidget*>::const_iterator aWIt;
+  QList<ModuleBase_ViewerPrs>::const_iterator aPIt;
+  for (aWIt = aWidgets.constBegin(), aPIt = myPreSelection.constBegin();
+       (aWIt != aWidgets.constEnd()) && (aPIt != myPreSelection.constEnd());
+       ++aWIt, ++aPIt) {
+    aWgt = (*aWIt);
+    aPrs = (*aPIt);
+    ModuleBase_WidgetValueFeature aValue;
+    aValue.setObject(aPrs.object());
+    if (!aWgt->setValue(&aValue))
+      break;
+  }
+  if (canBeCommitted()) {
+    // if all widgets are filled with selection
+    commit();
+    return true;
+  }
 
-/*!
- * \brief Virtual method called when operation is started
- *
- * Virtual method called when operation stopped - committed or aborted.
- */
-void ModuleBase_Operation::stopOperation()
-{
+  //ModuleBase_ModelWidget* aActiveWgt = myPropertyPanel->activeWidget();
+  //if ((myPreSelection.size() > 0) && aActiveWgt) {
+  //  const ModuleBase_ViewerPrs& aPrs = myPreSelection.first();
+  //  ModuleBase_WidgetValueFeature aValue;
+  //  aValue.setObject(aPrs.object());
+  //  if (aActiveWgt->setValue(&aValue)) {
+  //    myPreSelection.removeOne(aPrs);
+  //    myPropertyPanel->activateNextWidget();
+  //  }
+  //  // If preselection is enough to make a valid feature - apply it immediately
+  //}
+  return false;
 }
 
-/*!
- * \brief Virtual method called when operation aborted
- *
- * Virtual method called when operation aborted (see abort() method for more description)
- */
-void ModuleBase_Operation::abortOperation()
+void ModuleBase_Operation::initSelection(ModuleBase_ISelection* theSelection)
 {
+  myPreSelection.clear();
+
+  // Check that the selected result are not results of operation feature
+  QList<ModuleBase_ViewerPrs> aSelected = theSelection->getSelected();
+  FeaturePtr aFeature = feature();
+  if (aFeature) {
+    std::list<ResultPtr> aResults = aFeature->results();
+    QList<ObjectPtr> aResList;
+    std::list<ResultPtr>::const_iterator aIt;
+    for (aIt = aResults.begin(); aIt != aResults.end(); ++aIt)
+      aResList.append(*aIt);
+
+    foreach (ModuleBase_ViewerPrs aPrs, aSelected) {
+      if ((!aResList.contains(aPrs.object())) && (aPrs.object() != aFeature))
+        myPreSelection.append(aPrs);
+    }
+  } else
+    myPreSelection = aSelected;
 }
 
-/*!
- * \brief Virtual method called when operation committed
- *
- * Virtual method called when operation committed (see commit() method for more description)
- */
-void ModuleBase_Operation::commitOperation()
+void ModuleBase_Operation::onWidgetActivated(ModuleBase_ModelWidget* theWidget)
 {
-  myFeature->execute();
+  //activateByPreselection();
+  //if (theWidget && myPropertyPanel) {
+  //  myPropertyPanel->activateNextWidget();
+  ////  //emit activateNextWidget(myActiveWidget);
+  //}
 }
 
-/*!
- * \brief Sets execution status
- * \param theStatus - execution status
- *
- * Sets myExecStatus to the given value
- */
-void ModuleBase_Operation::setExecStatus(const int theVal)
+bool ModuleBase_Operation::setWidgetValue(ObjectPtr theFeature, double theX, double theY)
 {
-  myExecStatus = (ExecStatus) theVal;
+  ModuleBase_ModelWidget* aActiveWgt = myPropertyPanel->activeWidget();
+  if (!aActiveWgt)
+    return false;
+  ModuleBase_WidgetValueFeature* aValue = new ModuleBase_WidgetValueFeature();
+  aValue->setObject(theFeature);
+  aValue->setPoint(boost::shared_ptr<GeomAPI_Pnt2d>(new GeomAPI_Pnt2d(theX, theY)));
+  bool isApplyed = aActiveWgt->setValue(aValue);
+
+  delete aValue;
+  myIsModified = (myIsModified || isApplyed);
+  return isApplyed;
 }
 
-/*!
- * \brief Sets state of operation
- * \param theState - state of operation to be set
- *
- *  Sets state of operation (see OperationState enumeration)
- */
-void ModuleBase_Operation::setState(const ModuleBase_Operation::OperationState theState)
-{
-  myState = theState;
+
+void ModuleBase_Operation::setPropertyPanel(ModuleBase_IPropertyPanel* theProp) 
+{ 
+  myPropertyPanel = theProp; 
+  connect(myPropertyPanel, SIGNAL(widgetActivated(ModuleBase_ModelWidget*)), this,
+          SLOT(onWidgetActivated(ModuleBase_ModelWidget*)));
 }