X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FXGUI%2FXGUI_ErrorMgr.cpp;h=b93c58c09110af825f5282aee538be6906db74c1;hb=39aa2839a4269a2fc87cfe3b4487cce8f3df9a6f;hp=7a7a86c202872fd938a8d5554ea793b1f7ed7167;hpb=803af3deaa4abc9b937e8cfb4a42e7060b6acc22;p=modules%2Fshaper.git

diff --git a/src/XGUI/XGUI_ErrorMgr.cpp b/src/XGUI/XGUI_ErrorMgr.cpp
index 7a7a86c20..b93c58c09 100644
--- a/src/XGUI/XGUI_ErrorMgr.cpp
+++ b/src/XGUI/XGUI_ErrorMgr.cpp
@@ -7,96 +7,178 @@
 #include "XGUI_ErrorMgr.h"
 
 #include "XGUI_OperationMgr.h"
+#include "XGUI_ModuleConnector.h"
+#include "XGUI_Workshop.h"
+#include "XGUI_ActionsMgr.h"
 
 #include <ModuleBase_IPropertyPanel.h>
+#include <ModuleBase_IWorkshop.h>
+#include <ModuleBase_IModule.h>
 #include <ModuleBase_ModelWidget.h>
 #include <ModuleBase_OperationFeature.h>
 
+#include <ModuleBase_Tools.h>
+#include <QDebug>
+
 #include <ModelAPI_Attribute.h>
 #include <ModelAPI_Session.h>
 #include <ModelAPI_Validator.h>
 
+#include <QLabel>
+#include <QAction>
+#include <QApplication>
+#include <QDesktopWidget>
+#include <QDialog>
+#include <QCursor>
+#include <QHBoxLayout>
 #include <QLabel>
 
-XGUI_ErrorMgr::XGUI_ErrorMgr(QObject* theParent /*= 0*/)
-  : ModuleBase_IErrorMgr(theParent)
-{
+const QString INVALID_VALUE = "invalid_action";
 
+//#define DEBUG_ERROR_STATE
+
+XGUI_ErrorMgr::XGUI_ErrorMgr(QObject* theParent, ModuleBase_IWorkshop* theWorkshop)
+  : ModuleBase_IErrorMgr(theParent),
+    myErrorDialog(0),
+    myErrorLabel(0),
+    myWorkshop(theWorkshop),
+    myAcceptAllToolTip(""),
+    myAcceptAllStatusTip(""),
+    myAcceptToolTip(""),
+    myAcceptStatusTip("")
+{
 }
 
 XGUI_ErrorMgr::~XGUI_ErrorMgr()
 {
+}
 
+void XGUI_ErrorMgr::updateActions(const FeaturePtr& theFeature)
+{
+  //update Ok Action and header of property panel if the current operation started for the feature
+  XGUI_ActionsMgr* anActionsMgr = workshop()->actionsMgr();
+  ModuleBase_OperationFeature* aFOperation = dynamic_cast<ModuleBase_OperationFeature*>
+                                      (workshop()->operationMgr()->currentOperation());
+  if (aFOperation && aFOperation->feature() == theFeature) {
+    ModuleBase_ModelWidget* anActiveWidget = activeWidget();
+    bool isApplyEnabledByActiveWidget = false;
+    if (anActiveWidget)
+      isApplyEnabledByActiveWidget = anActiveWidget->getValueState() ==
+                                     ModuleBase_ModelWidget::ModifiedInPP;
+    QString anError = "";
+    QString aWidgetError = "";
+    if (!isApplyEnabledByActiveWidget) {
+      anError = myWorkshop->module()->getFeatureError(theFeature);
+      if (anActiveWidget)
+        aWidgetError = anActiveWidget->getError();
+      if (anError.isEmpty())
+        anError = aWidgetError;
+    }
+    updateAcceptActionState(anError);
+    updateToolTip(anActiveWidget, aWidgetError);
+    myWorkshop->setStatusBarMessage(anError);
+
+#ifdef DEBUG_ERROR_STATE
+    QString anInfo = ModuleBase_Tools::objectInfo(theFeature);
+
+    QString aResultInfo = QString("valid = %1, anError = %2, aWidgetError = %3")
+                          .arg(anError.isEmpty()).arg(anError).arg(aWidgetError);
+    qDebug(QString("XGUI_ErrorMgr::updateActions for %1, result: %2").arg(anInfo)
+                  .arg(aResultInfo).toStdString().c_str());
+#endif
+  }
 }
 
-const char* toString(ModelAPI_ExecState theExecState) 
+void XGUI_ErrorMgr::updateAcceptAllAction(const FeaturePtr& theFeature)
 {
-#define TO_STRING(__NAME__) case __NAME__: return #__NAME__;
-  switch (theExecState) {
-  TO_STRING(ModelAPI_StateDone)
-  TO_STRING(ModelAPI_StateMustBeUpdated)
-  TO_STRING(ModelAPI_StateExecFailed)
-  TO_STRING(ModelAPI_StateInvalidArgument)
-  TO_STRING(ModelAPI_StateNothing)
-  default: return "Unknown ExecState.";
+  if (myAcceptAllToolTip.isEmpty() && myAcceptToolTip.isEmpty())
+    storeInitialActionValues();
+
+  QString anError = "";
+  /// to allow the module have the button always enabled
+  bool isActionStateEnabled =
+    myWorkshop->module()->isActionEnableStateFixed(XGUI_ActionsMgr::AcceptAll);
+  if (!isActionStateEnabled) {
+    anError = myWorkshop->module()->getFeatureError(theFeature);
+    if (anError.isEmpty()) {
+      ModuleBase_ModelWidget* anActiveWidget = activeWidget();
+      if (anActiveWidget)
+        anError = anActiveWidget->getError();
+    }
+  }
+  XGUI_ActionsMgr* anActionsMgr = workshop()->actionsMgr();
+  if (workshop()->isFeatureOfNested(theFeature)) {
+    QAction* anAcceptAllAction = anActionsMgr->operationStateAction(XGUI_ActionsMgr::AcceptAll);
+    bool anEnabled = anError.isEmpty();
+    anAcceptAllAction->setEnabled(anEnabled);
+    anAcceptAllAction->setToolTip(!anEnabled ? anError : myAcceptAllToolTip);
+    anAcceptAllAction->setStatusTip(!anEnabled ? anError : myAcceptAllStatusTip);
   }
-#undef TO_STRING
 }
 
-void XGUI_ErrorMgr::onValidationStateChanged()
+bool XGUI_ErrorMgr::isApplyEnabled() const
 {
-  XGUI_OperationMgr* anOperationMgr = dynamic_cast<XGUI_OperationMgr*>(sender());
-  if (!anOperationMgr)
-    return;
+  bool isEnabled = false;
+  XGUI_ActionsMgr* anActionsMgr = workshop()->actionsMgr();
   ModuleBase_OperationFeature* aFOperation = dynamic_cast<ModuleBase_OperationFeature*>
-                                                  (anOperationMgr->currentOperation());
-  if (!myPropertyPanel || !aFOperation)
-    return;
-
-  // get feature
-  FeaturePtr aFeature = aFOperation->feature();
-  if (!aFeature.get() || !aFeature->data()->isValid())
-    return;
-
-  // set error indication
-  QString anError = QString::fromStdString(aFeature->error());
-  if (anError.isEmpty()) {
-    bool isDone = ( aFeature->data()->execState() == ModelAPI_StateDone
-                 || aFeature->data()->execState() == ModelAPI_StateMustBeUpdated );
-    if (!isDone)
-      anError = toString(aFeature->data()->execState());
+                                      (workshop()->operationMgr()->currentOperation());
+  if (aFOperation) {
+    QAction* anOkAction = anActionsMgr->operationStateAction(XGUI_ActionsMgr::Accept);
+    isEnabled = anOkAction && anOkAction->isEnabled();
   }
+  return isEnabled;
+}
 
-  QWidget* aWidget = myPropertyPanel->headerWidget();
-  if (aWidget) {
-    aWidget->setToolTip(anError);
-    aWidget->setStyleSheet(anError.isEmpty() ? "" : "background-color:pink;");
-  }
+void XGUI_ErrorMgr::storeInitialActionValues()
+{
+  ModuleBase_ModelWidget* anActiveWidget = activeWidget();
+  XGUI_ActionsMgr* anActionsMgr = workshop()->actionsMgr();
+  QAction* anAcceptAllAction = anActionsMgr->operationStateAction(XGUI_ActionsMgr::AcceptAll);
+  myAcceptAllToolTip = anAcceptAllAction->toolTip();
+  myAcceptAllStatusTip = anAcceptAllAction->statusTip();
+
+  QAction* anOkAction = anActionsMgr->operationStateAction(XGUI_ActionsMgr::Accept);
+  myAcceptToolTip = anOkAction->toolTip();
+  myAcceptStatusTip = anOkAction->toolTip();
 }
 
+void XGUI_ErrorMgr::updateAcceptActionState(const QString& theError)
+{
+  XGUI_ActionsMgr* anActionsMgr = workshop()->actionsMgr();
+  QAction* anAcceptAction = anActionsMgr->operationStateAction(XGUI_ActionsMgr::Accept);
+
+  if (myAcceptAllToolTip.isEmpty() && myAcceptToolTip.isEmpty())
+    storeInitialActionValues();
+
+  bool anEnabled = theError.isEmpty();
+  anAcceptAction->setEnabled(anEnabled);
+  anAcceptAction->setToolTip(anEnabled ? myAcceptToolTip : theError);
+  anAcceptAction->setStatusTip(anEnabled ? myAcceptStatusTip : theError);
+  // some operations have no property panel, so it is important to check that it is not null
+  if (myPropertyPanel) {
+    // update controls error information
+    QWidget* aWidget = myPropertyPanel->headerWidget();
+    if (aWidget)
+      aWidget->setToolTip(theError);
+  }
+}
 void XGUI_ErrorMgr::onWidgetChanged()
 {
-  static ModelAPI_ValidatorsFactory* aValidators = ModelAPI_Session::get()->validators();
-
   ModuleBase_ModelWidget* aModelWidget = dynamic_cast<ModuleBase_ModelWidget*>(sender());
   if (!aModelWidget || !aModelWidget->feature().get())
     return;
 
-  std::string anAttributeID = aModelWidget->attributeID();
-  AttributePtr anAttribute = aModelWidget->feature()->attribute(anAttributeID);
-  if (!anAttribute.get())
-    return;
+  QString aWidgetError = aModelWidget->getError();
+  updateToolTip(aModelWidget, aWidgetError);
+}
 
-  std::string aValidatorID;
-  std::string anErrorMsg;
-  if (!aValidators->validate(anAttribute, aValidatorID, anErrorMsg)) {
-    if (anErrorMsg.empty())
-      anErrorMsg = "unknown error.";
-    anErrorMsg = "Attribute \"" + anAttributeID + "\" invalidated by \"" + aValidatorID + "\" with error: " + anErrorMsg;
-  }
+void XGUI_ErrorMgr::updateToolTip(ModuleBase_ModelWidget* theWidget,
+                                  const QString& theError)
+{
+  if (!theWidget)
+    return;
 
-  QString anError = QString::fromStdString(anErrorMsg);
-  QList<QWidget*> aWidgetList = aModelWidget->getControls();
+  QList<QWidget*> aWidgetList = theWidget->getControls();
   foreach(QWidget* aWidget, aWidgetList) {
     QLabel* aLabel = qobject_cast<QLabel*>(aWidget);
     // We won't set the effect to QLabels - it looks ugly
@@ -105,12 +187,34 @@ void XGUI_ErrorMgr::onWidgetChanged()
     // Get the original tool tip of the widget
     QString aTTip = aWidget->toolTip().section("Errors:\n", 0, 0).trimmed();
     // Add the error message into the tool tip
-    if (!anError.isEmpty()) {
+    if (!theError.isEmpty()) {
       if (!aTTip.isEmpty())
         aTTip.append('\n');
-      aTTip += "Errors:\n" + anError;
+      aTTip += "Errors:\n" + theError;
     }
     aWidget->setToolTip(aTTip);
-    aWidget->setStyleSheet(anError.isEmpty() ? "" : "background-color:pink;");
+    //aWidget->setStyleSheet(anError.isEmpty() ? "" : "background-color:pink;");
+  }
+}
+
+XGUI_Workshop* XGUI_ErrorMgr::workshop() const
+{
+  XGUI_ModuleConnector* aConnector = dynamic_cast<XGUI_ModuleConnector*>(myWorkshop);
+  return aConnector->workshop();
+}
+
+ModuleBase_ModelWidget* XGUI_ErrorMgr::activeWidget() const
+{
+  ModuleBase_ModelWidget* anActiveWidget = 0;
+
+  ModuleBase_OperationFeature* aFOperation = dynamic_cast<ModuleBase_OperationFeature*>
+                                      (workshop()->operationMgr()->currentOperation());
+  if (aFOperation) {
+    ModuleBase_IPropertyPanel* aPropertyPanel = aFOperation->propertyPanel();
+    if (aPropertyPanel) {
+      anActiveWidget = aPropertyPanel->activeWidget();
+    }
   }
+  return anActiveWidget;
 }
+