X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FModuleBase%2FModuleBase_Operation.cpp;h=bfe58446d370168a50092075ea228460c6ca7c25;hb=8b3ac2b938bd55064a6f260ca7ec9c9a84cd977e;hp=fd0724f287ef8e32fbeb2045f18e0961f75beae3;hpb=69147ab3e4b228b773dd84f8458e46df6028e2de;p=modules%2Fshaper.git

diff --git a/src/ModuleBase/ModuleBase_Operation.cpp b/src/ModuleBase/ModuleBase_Operation.cpp
index fd0724f28..bfe58446d 100644
--- a/src/ModuleBase/ModuleBase_Operation.cpp
+++ b/src/ModuleBase/ModuleBase_Operation.cpp
@@ -1,3 +1,5 @@
+// Copyright (C) 2014-20xx CEA/DEN, EDF R&D
+
 /*
  * ModuleBase_Operation.cpp
  *
@@ -9,6 +11,10 @@
 
 #include "ModuleBase_OperationDescription.h"
 #include "ModuleBase_ModelWidget.h"
+#include "ModuleBase_ViewerPrs.h"
+#include "ModuleBase_IPropertyPanel.h"
+#include "ModuleBase_ISelection.h"
+#include "ModuleBase_IViewer.h"
 
 #include <ModelAPI_AttributeDouble.h>
 #include <ModelAPI_Document.h>
@@ -17,21 +23,33 @@
 #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>
 
+#include <QTimer>
+
 #ifdef _DEBUG
 #include <QDebug>
 #endif
 
 ModuleBase_Operation::ModuleBase_Operation(const QString& theId, QObject* theParent)
-    : ModuleBase_IOperation(theId, theParent)
+    : QObject(theParent),
+      myIsEditing(false),
+      myIsModified(false),
+      myPropertyPanel(NULL)
 {
+  myDescription = new ModuleBase_OperationDescription(theId);
 }
 
 ModuleBase_Operation::~ModuleBase_Operation()
 {
+  delete myDescription;
+  clearPreselection();
 }
 
 QString ModuleBase_Operation::id() const
@@ -48,139 +66,286 @@ bool ModuleBase_Operation::isValid() const
 {
   if (!myFeature)
     return true; // rename operation
+  if (myFeature->isAction())
+    return true;
   //Get validators for the Id
   SessionPtr aMgr = ModelAPI_Session::get();
   ModelAPI_ValidatorsFactory* aFactory = aMgr->validators();
   return aFactory->validate(myFeature);
 }
 
-bool ModuleBase_Operation::isNestedOperationsEnabled() const
+
+bool ModuleBase_Operation::canBeCommitted() const
 {
-  return true;
+  return isValid();
 }
 
-void ModuleBase_Operation::storeCustomValue()
+void ModuleBase_Operation::flushUpdated()
 {
-  if (!myFeature) {
-#ifdef _DEBUG
-    qDebug() << "ModuleBase_Operation::storeCustom: " <<
-    "trying to store value without opening a transaction.";
-#endif
-    return;
+  Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_UPDATED));
+}
+
+void ModuleBase_Operation::flushCreated()
+{
+  Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_CREATED));
+}
+
+FeaturePtr ModuleBase_Operation::createFeature(const bool theFlushMessage)
+{
+  if (myParentFeature.get()) {
+    myFeature = myParentFeature->addFeature(getDescription()->operationId().toStdString());
+  } else {
+    std::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);
+     }*/
   }
 
-  ModuleBase_ModelWidget* aCustom = dynamic_cast<ModuleBase_ModelWidget*>(sender());
-  if (aCustom)
-    aCustom->storeValue();
+  if (theFlushMessage)
+    flushCreated();
+  return myFeature;
 }
 
-void ModuleBase_Operation::onWidgetActivated(ModuleBase_ModelWidget* theWidget)
+void ModuleBase_Operation::setFeature(FeaturePtr theFeature)
 {
+  myFeature = theFeature;
+  myIsEditing = true;
 }
 
-void ModuleBase_Operation::startOperation()
+bool ModuleBase_Operation::hasObject(ObjectPtr theObj) const
 {
-  if (!myIsEditing)
-    createFeature();
-  //emit callSlot();
-  //commit();
+  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 (theObj == (*aIt))
+        return true;
+    }
+  }
+  return false;
 }
 
-void ModuleBase_Operation::stopOperation()
+
+std::shared_ptr<ModelAPI_Document> ModuleBase_Operation::document() const
 {
+  return ModelAPI_Session::get()->moduleDocument();
 }
 
-void ModuleBase_Operation::abortOperation()
+
+void ModuleBase_Operation::start()
 {
+  QString anId = getDescription()->operationId();
+  ModelAPI_Session::get()->startOperation(anId.toStdString());
+
+  if (!myIsEditing)
+    createFeature();
+
+  startOperation();
+  emit started();
+
 }
 
-void ModuleBase_Operation::commitOperation()
+void ModuleBase_Operation::postpone()
 {
+  postponeOperation();
+  emit postponed();
 }
 
-void ModuleBase_Operation::afterCommitOperation()
+void ModuleBase_Operation::resume()
 {
+  resumeOperation();
+  emit resumed();
 }
 
-bool ModuleBase_Operation::canBeCommitted() const
+void ModuleBase_Operation::abort()
 {
-  if (ModuleBase_IOperation::canBeCommitted()) {
-    /*    FeaturePtr aFeature = feature();
-     std::string aId = aFeature->getKind();
-
-     SessionPtr aMgr = ModelAPI_Session::get();
-     ModelAPI_ValidatorsFactory* aFactory = aMgr->validators();
-     std::list<ModelAPI_Validator*> aValidators;
-     aFactory->validators(aId, aValidators);
-     std::list<ModelAPI_Validator*>::const_iterator aIt;
-     for (aIt = aValidators.cbegin(); aIt != aValidators.cend(); ++aIt) {
-     const ModuleBase_FeatureValidator* aFValidator = 
-     dynamic_cast<const ModuleBase_FeatureValidator*>(*aIt);
-     if (aFValidator) {
-     if (!aFValidator->isValid(aFeature))
-     return false;
-     }
-     }*/
+  abortOperation();
+  emit aborted();
+
+  stopOperation();
+
+  ModelAPI_Session::get()->abortOperation();
+  emit stopped();
+}
+
+bool ModuleBase_Operation::commit()
+{
+  if (canBeCommitted()) {
+    commitOperation();
+    // check whether there are modifications performed during the current operation
+    // in the model
+    // in case if there are no modifications, do not increase the undo/redo stack
+    if (ModelAPI_Session::get()->isModified())
+      ModelAPI_Session::get()->finishOperation();
+    else
+      ModelAPI_Session::get()->abortOperation();
+
+    stopOperation();
+    emit stopped();
+    emit committed();
+
+    afterCommitOperation();
     return true;
   }
   return false;
 }
 
-void ModuleBase_Operation::flushUpdated()
+void ModuleBase_Operation::setRunning(bool theState)
 {
-  Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_UPDATED));
+  if (!theState) {
+    abort();
+  }
 }
 
-void ModuleBase_Operation::flushCreated()
+void ModuleBase_Operation::activateByPreselection()
 {
-  Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_CREATED));
-}
+  if (!myPropertyPanel || myPreSelection.empty()) {
+    myPropertyPanel->activateNextWidget(NULL);
+    return;
+  }
+  const QList<ModuleBase_ModelWidget*>& aWidgets = myPropertyPanel->modelWidgets();
+  if (aWidgets.empty()) {
+    myPropertyPanel->activateNextWidget(NULL);
+    return;
+  }
+  
+  ModuleBase_ModelWidget* aWgt, *aFilledWgt = 0;
+  QList<ModuleBase_ModelWidget*>::const_iterator aWIt;
+  QList<ModuleBase_ViewerPrs>::const_iterator aPIt;
+  bool isSet = false;
+  for (aWIt = aWidgets.constBegin(), aPIt = myPreSelection.constBegin();
+       (aWIt != aWidgets.constEnd()) && (aPIt != myPreSelection.constEnd());
+       ++aWIt) {
+    aWgt = (*aWIt);
+    ModuleBase_ViewerPrs aValue = (*aPIt);
+    if (!aWgt->canSetValue())
+      continue;
 
-FeaturePtr ModuleBase_Operation::createFeature(const bool theFlushMessage)
-{
-  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);
-     }*/
+    ++aPIt;
+    if (!aWgt->setSelection(aValue)) {
+      isSet = false;
+      break;
+    } else {
+      isSet = true;
+      aFilledWgt = aWgt;
+    }
   }
 
-  if (theFlushMessage)
-    flushCreated();
-  return myFeature;
+  myPropertyPanel->activateNextWidget(aFilledWgt);
+  if (aFilledWgt)
+    emit activatedByPreselection();
+
 }
 
-void ModuleBase_Operation::setFeature(FeaturePtr theFeature)
+void ModuleBase_Operation::setParentFeature(CompositeFeaturePtr theParent)
 {
-  myFeature = theFeature;
+  myParentFeature = theParent;
 }
 
-void ModuleBase_Operation::setEditingFeature(FeaturePtr theFeature)
+CompositeFeaturePtr ModuleBase_Operation::parentFeature() const
 {
-  setFeature(theFeature);
-  myIsEditing = true;
+  return myParentFeature;
 }
 
-bool ModuleBase_Operation::hasObject(ObjectPtr theObj) const
+void ModuleBase_Operation::initSelection(ModuleBase_ISelection* theSelection,
+                                         ModuleBase_IViewer* theViewer)
 {
+  clearPreselection();
+
+  QList<ModuleBase_ViewerPrs> aPreSelected;
+  // Check that the selected result are not results of operation feature
   FeaturePtr aFeature = feature();
   if (aFeature) {
-    if (aFeature == theObj)
-      return true;
+    QList<ModuleBase_ViewerPrs> aSelected = theSelection->getSelected();
+
     std::list<ResultPtr> aResults = aFeature->results();
+    QObjectPtrList aResList;
     std::list<ResultPtr>::const_iterator aIt;
-    for (aIt = aResults.cbegin(); aIt != aResults.cend(); ++aIt) {
-      if ((*aIt) == theObj)
-        return true;
+    for (aIt = aResults.begin(); aIt != aResults.end(); ++aIt)
+      aResList.append(*aIt);
+
+    foreach (ModuleBase_ViewerPrs aPrs, aSelected) {
+      if ((!aResList.contains(aPrs.object())) && (aPrs.object() != aFeature))
+        aPreSelected.append(aPrs);
     }
-  }
+  } else
+    aPreSelected = theSelection->getSelected();
+
+  // convert the selection values to the values, which are set to the operation widgets
+
+  //Handle(V3d_View) aView = theViewer->activeView();
+  //foreach (ModuleBase_ViewerPrs aPrs, aPreSelected) {
+  //  ModuleBase_WidgetValueFeature* aValue = new ModuleBase_WidgetValueFeature();
+  //  aValue->setObject(aPrs.object());
+
+  //  double aX, anY;
+  //  if (getViewerPoint(aPrs, theViewer, aX, anY))
+  //    aValue->setPoint(std::shared_ptr<GeomAPI_Pnt2d>(new GeomAPI_Pnt2d(aX, anY)));
+  //  myPreSelection.append(aValue);
+  //}
+  myPreSelection = aPreSelected;
+}
+
+//void ModuleBase_Operation::onWidgetActivated(ModuleBase_ModelWidget* theWidget)
+//{
+//  //activateByPreselection();
+//  //if (theWidget && myPropertyPanel) {
+//  //  myPropertyPanel->activateNextWidget();
+//  ////  //emit activateNextWidget(myActiveWidget);
+//  //}
+//}
+
+//bool ModuleBase_Operation::setWidgetValue(ObjectPtr theFeature, double theX, double theY)
+//{
+//  ModuleBase_ModelWidget* aActiveWgt = myPropertyPanel->activeWidget();
+//  if (!aActiveWgt)
+//    return false;
+//  ModuleBase_WidgetValueFeature* aValue = new ModuleBase_WidgetValueFeature();
+//  aValue->setObject(theFeature);
+//  aValue->setPoint(std::shared_ptr<GeomAPI_Pnt2d>(new GeomAPI_Pnt2d(theX, theY)));
+//  bool isApplyed = aActiveWgt->setValue(aValue);
+//
+//  delete aValue;
+//  myIsModified = (myIsModified || isApplyed);
+//  return isApplyed;
+//}
+
+bool ModuleBase_Operation::getViewerPoint(ModuleBase_ViewerPrs thePrs,
+                                               ModuleBase_IViewer* theViewer,
+                                               double& theX, double& theY)
+{
   return false;
 }
 
+void ModuleBase_Operation::clearPreselection()
+{
+  myPreSelection.clear();
+}
+
+void ModuleBase_Operation::setPropertyPanel(ModuleBase_IPropertyPanel* theProp) 
+{ 
+  myPropertyPanel = theProp; 
+  myPropertyPanel->setEditingMode(isEditOperation());
+
+  // Do not activate widgets by default if the current operation is editing operation
+  // Because we don't know which widget is going to be edited. 
+  if (!isEditOperation())
+    activateByPreselection();
+}
+
+bool ModuleBase_Operation::isGranted(QString theId) const
+{
+  return myNestedFeatures.contains(theId);
+}