Simplified calculation of fly out distance and creation of constraints limited only...

[modules/shaper.git] / src / XGUI / XGUI_OperationMgr.cpp

diff --git a/src/XGUI/XGUI_OperationMgr.cpp b/src/XGUI/XGUI_OperationMgr.cpp
index 259d3411d4aac5f85da5bcc76dc4cec6131f7ad1..2382354ea57b469471d9588722e1b8e8f43f7d66 100644 (file)
--- a/src/XGUI/XGUI_OperationMgr.cpp
+++ b/src/XGUI/XGUI_OperationMgr.cpp
@@ -5,10 +5,14 @@
 // Author:      Natalia ERMOLAEVA
 
 #include "XGUI_OperationMgr.h"
+#include "XGUI_ModuleConnector.h"
+#include "XGUI_Workshop.h"
+#include "XGUI_ErrorMgr.h"
 
 #include "ModuleBase_Operation.h"
 #include "ModuleBase_IWorkshop.h"
 #include "ModuleBase_IModule.h"
+#include <ModuleBase_IViewer.h>
 #include "ModuleBase_OperationDescription.h"
 #include "ModuleBase_OperationFeature.h"
 
@@ -135,8 +139,9 @@ bool XGUI_OperationMgr::abortAllOperations()
     return aResult;
 
   if (operationsCount() == 1) {
-    if (canStopOperation()) {
-      abortOperation(currentOperation());
+    ModuleBase_Operation* aCurrentOperation = currentOperation();
+    if (canStopOperation(aCurrentOperation)) {
+      abortOperation(aCurrentOperation);
     }
     else
       aResult = false;
@@ -182,10 +187,13 @@ void XGUI_OperationMgr::onValidateOperation()
 {
   if (!hasOperation())
     return;
-  ModuleBase_Operation* anOperation = currentOperation();
-  if(anOperation) {
-    bool aCanCommit = myWorkshop->module()->canCommitOperation();
-    setApplyEnabled(!myIsValidationLock && aCanCommit && anOperation->isValid());
+  //ModuleBase_Operation* anOperation = currentOperation();
+  ModuleBase_OperationFeature* aFOperation = dynamic_cast<ModuleBase_OperationFeature*>
+                                                                          (currentOperation());
+  if(aFOperation && aFOperation->feature().get()) {
+    //bool aCanCommit = myWorkshop->module()->canCommitOperation();
+    //setApplyEnabled(!myIsValidationLock && aCanCommit && anOperation->isValid());
+    setApplyEnabled(myWorkshop->module()->getFeatureError(aFOperation->feature()).isEmpty());
   }
 }
 
@@ -198,18 +206,30 @@ void XGUI_OperationMgr::setLockValidating(bool toLock)
 void XGUI_OperationMgr::setApplyEnabled(const bool theEnabled)
 {
   myIsApplyEnabled = theEnabled;
-  emit validationStateChanged(theEnabled);
+  ModuleBase_OperationFeature* aFOperation = dynamic_cast<ModuleBase_OperationFeature*>
+                                                                          (currentOperation());
+  if (aFOperation) {
+    workshop()->errorMgr()->updateActions(aFOperation->feature());
+  }
+  //emit validationStateChanged(theEnabled);
 }
 
 void XGUI_OperationMgr::updateApplyOfOperations(ModuleBase_Operation* theOperation)
 {
-  if (theOperation)
-    emit nestedStateChanged(theOperation->getDescription()->operationId().toStdString(),
-                            theOperation->isValid());
+  XGUI_ErrorMgr* anErrorMgr = workshop()->errorMgr();
+  if (theOperation) {
+    ModuleBase_OperationFeature* aFOperation = dynamic_cast<ModuleBase_OperationFeature*>(theOperation);
+    if (aFOperation)
+      anErrorMgr->updateAcceptAllAction(aFOperation->feature());
+    //emit nestedStateChanged(theOperation->getDescription()->operationId().toStdString(),
+    //                        theOperation->isValid());
+  }
   else {
     foreach(ModuleBase_Operation* anOperation, myOperations) {
-      emit nestedStateChanged(anOperation->getDescription()->operationId().toStdString(),
-                              anOperation->isValid());
+      if (anOperation)
+        updateApplyOfOperations(anOperation);
+      //emit nestedStateChanged(anOperation->getDescription()->operationId().toStdString(),
+      //                        anOperation->isValid());
     }
   }
 }
@@ -237,13 +257,13 @@ bool XGUI_OperationMgr::isParentOperationValid() const
   return aPrevOp && aPrevOp->isValid();
 }
 
-bool XGUI_OperationMgr::canStopOperation()
+bool XGUI_OperationMgr::canStopOperation(ModuleBase_Operation* theOperation)
 {
-  ModuleBase_Operation* anOperation = currentOperation();
-  if(operationsCount() > 1) //in case of nested (sketch) operation no confirmation needed
+  //in case of nested (sketch) operation no confirmation needed
+  if (isGrantedOperation(theOperation))
     return true;
-  if (anOperation && anOperation->isModified()) {
-    QString aMessage = tr("%1 operation will be aborted.").arg(anOperation->id());
+  if (theOperation && theOperation->isModified()) {
+    QString aMessage = tr("%1 operation will be aborted.").arg(theOperation->id());
     int anAnswer = QMessageBox::question(qApp->activeWindow(),
                                          tr("Abort operation"),
                                          aMessage,
@@ -268,13 +288,35 @@ void XGUI_OperationMgr::resumeOperation(ModuleBase_Operation* theOperation)
   theOperation->resume();
 }
 
-bool XGUI_OperationMgr::canStartOperation(QString theId)
+bool XGUI_OperationMgr::isGrantedOperation(ModuleBase_Operation* theOperation)
+{
+  bool isGranted = false;
+
+  QListIterator<ModuleBase_Operation*> anIt(myOperations);
+  anIt.toBack();
+  ModuleBase_Operation* aPreviousOperation = 0;
+  while (anIt.hasPrevious()) {
+    ModuleBase_Operation* anOp = anIt.previous();
+    if (anOp == theOperation) {
+      if (anIt.hasPrevious())
+        aPreviousOperation = anIt.previous();
+      break;
+    }
+  }
+  if (aPreviousOperation)
+    isGranted = aPreviousOperation->isGranted(theOperation->id());
+
+  return isGranted;
+}
+
+bool XGUI_OperationMgr::canStartOperation(const QString& theId, const bool isAdditionallyGranted)
 {
   bool aCanStart = true;
   ModuleBase_Operation* aCurrentOp = currentOperation();
   if (aCurrentOp) {
-    if (!aCurrentOp->isGranted(theId)) {
-      if (canStopOperation()) {
+    bool aGranted = aCurrentOp->isGranted(theId) || isAdditionallyGranted;
+    if (!aGranted) {
+      if (canStopOperation(aCurrentOp)) {
         if (myIsApplyEnabled && aCurrentOp->isModified())
           aCurrentOp->commit();
         else
@@ -314,8 +356,9 @@ void XGUI_OperationMgr::onCommitOperation()
 
 void XGUI_OperationMgr::onAbortOperation()
 {
-  if (hasOperation() && canStopOperation()) {
-    abortOperation(currentOperation());
+  ModuleBase_Operation* aCurrentOperation = currentOperation();
+  if (aCurrentOperation && canStopOperation(aCurrentOperation)) {
+    abortOperation(aCurrentOperation);
   }
 }
 
@@ -334,6 +377,7 @@ void XGUI_OperationMgr::onOperationAborted()
 
 void XGUI_OperationMgr::onOperationCommitted()
 {
+  // apply state for all features from the stack of operations should be updated
   updateApplyOfOperations();
 
   ModuleBase_Operation* aSenderOperation = dynamic_cast<ModuleBase_Operation*>(sender());
@@ -388,6 +432,20 @@ bool XGUI_OperationMgr::onKeyReleased(QKeyEvent* theEvent)
       emit keyEnterReleased();
       commitOperation();
     }
+    case Qt::Key_N:
+    case Qt::Key_P: {
+      bool noModifiers = (theEvent->modifiers() == Qt::NoModifier);
+      if (noModifiers) {
+        ModuleBase_IViewer* aViewer = myWorkshop->viewer();
+        Handle(AIS_InteractiveContext) aContext = aViewer->AISContext();
+        Handle(V3d_View) aView = aViewer->activeView();
+        if ((theEvent->key() == Qt::Key_N))
+          aContext->HilightNextDetected(aView);
+        else if ((theEvent->key() == Qt::Key_P))
+          aContext->HilightPreviousDetected(aView);
+      }
+    }
+
     break;
     default:
       isAccepted = false;
@@ -399,3 +457,9 @@ bool XGUI_OperationMgr::onKeyReleased(QKeyEvent* theEvent)
   return isAccepted;
 }
 
+XGUI_Workshop* XGUI_OperationMgr::workshop() const
+{
+  XGUI_ModuleConnector* aConnector = dynamic_cast<XGUI_ModuleConnector*>(myWorkshop);
+  return aConnector->workshop();
+}
+