src/ModuleBase/ModuleBase_ModelWidget.cpp

   1 // Copyright (C) 2014-2017  CEA/DEN, EDF R&D
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License, or (at your option) any later version.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or
  18 // email : webmaster.salome@opencascade.com<mailto:webmaster.salome@opencascade.com>
  19 //
  20
  21 #include "ModuleBase_ModelWidget.h"
  22 #include "ModuleBase_IPropertyPanel.h"
  23 #include "ModuleBase_ViewerPrs.h"
  24 #include "ModuleBase_Tools.h"
  25 #include "ModuleBase_WidgetValidator.h"
  26
  27 #include <Events_InfoMessage.h>
  28
  29 #include <ModelAPI_Data.h>
  30 #include <ModelAPI_Attribute.h>
  31 #include <ModelAPI_Events.h>
  32 #include <ModelAPI_Session.h>
  33 #include <ModelAPI_Validator.h>
  34
  35 #include <Config_Keywords.h>
  36 #include <Config_WidgetAPI.h>
  37 #include <Config_Translator.h>
  38 #include <Config_PropManager.h>
  39
  40 #include <Events_Loop.h>
  41
  42 #include <QEvent>
  43 #include <QLabel>
  44 #include <QFocusEvent>
  45 #include <QTextCodec>
  46
  47 //#define DEBUG_VALUE_STATE
  48
  49 //#define DEBUG_WIDGET_INSTANCE
  50 //#define DEBUG_ENABLE_SKETCH_INPUT_FIELDS
  51
  52 //**************************************************************
  53 ModuleBase_ModelWidget::ModuleBase_ModelWidget(QWidget* theParent,
  54                                                const Config_WidgetAPI* theData)
  55     : QWidget(theParent),
  56       myIsEditing(false),
  57       myState(Stored),
  58       myIsValueStateBlocked(false),
  59       myFlushUpdateBlocked(false),
  60       myWidgetValidator(0)
  61 {
  62 #ifdef DEBUG_WIDGET_INSTANCE
  63   qDebug("ModuleBase_ModelWidget::ModuleBase_ModelWidget");
  64 #endif
  65
  66   myFeatureId = theData->featureId();
  67
  68   myIsInternal = theData->getBooleanAttribute(ATTR_INTERNAL, false);
  69
  70   myIsModifiedInEdit = theData->getProperty(ATTR_MODIFIED_IN_EDIT);
  71
  72   myDefaultValue = theData->getProperty(ATTR_DEFAULT);
  73   myUseReset = theData->getBooleanAttribute(ATTR_USE_RESET, true);
  74   myIsComputedDefault = theData->getProperty(ATTR_DEFAULT) == DOUBLE_WDG_DEFAULT_COMPUTED;
  75   myAttributeID = theData ? theData->widgetId() : "";
  76   myIsObligatory = theData->getBooleanAttribute(ATTR_OBLIGATORY, true);
  77
  78   myIsValueEnabled = On; // not defined or "true"
  79   std::string anEnableValue = theData->getProperty(DOUBLE_WDG_ENABLE_VALUE);
  80   if (anEnableValue == "false")
  81     myIsValueEnabled = Off;
  82   if (anEnableValue == DOUBLE_WDG_ENABLE_VALUE_BY_PREFERENCES)
  83     myIsValueEnabled = DefinedInPreferences;
  84
  85   connect(this, SIGNAL(valuesChanged()), this, SLOT(onWidgetValuesChanged()));
  86   connect(this, SIGNAL(valuesModified()), this, SLOT(onWidgetValuesModified()));
  87 }
  88
  89 //**************************************************************
  90 ModuleBase_ModelWidget::~ModuleBase_ModelWidget()
  91 {
  92 #ifdef DEBUG_WIDGET_INSTANCE
  93   qDebug("ModuleBase_ModelWidget::~ModuleBase_ModelWidget");
  94 #endif
  95 }
  96
  97 //**************************************************************
  98 bool ModuleBase_ModelWidget::reset()
  99 {
 100   bool aResult = resetCustom();
 101   if (aResult)
 102     setValueState(Reset);
 103
 104   return aResult;
 105 }
 106
 107 //**************************************************************
 108 bool ModuleBase_ModelWidget::isInitialized(ObjectPtr theObject) const
 109 {
 110   return theObject->data()->attribute(attributeID())->isInitialized();
 111 }
 112
 113 //**************************************************************
 114 void ModuleBase_ModelWidget::selectionModes(int& theModuleSelectionModes, QIntList& theModes)
 115 {
 116   theModuleSelectionModes = -1;
 117   if (myWidgetValidator)
 118     myWidgetValidator->selectionModes(theModuleSelectionModes, theModes);
 119 }
 120
 121 //**************************************************************
 122 void ModuleBase_ModelWidget::selectionFilters(QIntList& theModuleSelectionFilters,
 123                                               SelectMgr_ListOfFilter& theSelectionFilters)
 124 {
 125   if (myWidgetValidator)
 126     myWidgetValidator->selectionFilters(theModuleSelectionFilters, theSelectionFilters);
 127 }
 128
 129 //**************************************************************
 130 bool ModuleBase_ModelWidget::isValueEnabled() const
 131 {
 132   bool anEnabled = true;
 133   if (myIsValueEnabled == DefinedInPreferences) {
 134 #ifdef DEBUG_ENABLE_SKETCH_INPUT_FIELDS
 135     bool aCanDisable = false;
 136 #else
 137     //Config_PropManager::boolean(SKETCH_TAB_NAME, "disable_input_fields", "true");
 138     bool aCanDisable = true;
 139 #endif
 140     if (aCanDisable)
 141       anEnabled = false;
 142   }
 143   else if (myIsValueEnabled == Off)
 144     anEnabled = false;
 145   return anEnabled;
 146 }
 147
 148 //**************************************************************
 149 void ModuleBase_ModelWidget::processValueState()
 150 {
 151   if (myState == ModifiedInPP || myState == ModifiedInViewer)
 152     storeValue();
 153 }
 154
 155 //**************************************************************
 156 Events_InfoMessage ModuleBase_ModelWidget::getValueStateError() const
 157 {
 158   Events_InfoMessage aMessage;
 159
 160   ModuleBase_ModelWidget::ValueState aState = getValueState();
 161   if (aState != ModuleBase_ModelWidget::Stored) {
 162     AttributePtr anAttr = feature()->attribute(attributeID());
 163     if (anAttr.get()) {
 164       const std::string& anAttributeName = anAttr->id();
 165       switch (aState) {
 166         case ModuleBase_ModelWidget::ModifiedInViewer:
 167           aMessage = "Attribute \"%1\" is locked by modification value in the viewer.";
 168           aMessage.addParameter(anAttributeName);
 169           break;
 170         case ModuleBase_ModelWidget::Reset:
 171           aMessage = "Attribute \"%1\" is not initialized.";
 172           aMessage.addParameter(anAttributeName);
 173           break;
 174         case ModuleBase_ModelWidget::ModifiedInPP: // Apply should be enabled in this mode
 175         default:
 176           break;
 177       }
 178     }
 179   }
 180   return aMessage;
 181 }
 182
 183 //**************************************************************
 184 QString ModuleBase_ModelWidget::getError(const bool theValueStateChecked) const
 185 {
 186   QString anError;
 187
 188   if (!feature().get())
 189     return anError;
 190
 191   std::string aFeatureID = feature()->getKind();
 192   std::string anAttributeID = attributeID();
 193   AttributePtr anAttribute = feature()->attribute(anAttributeID);
 194   if (!anAttribute.get())
 195     return anError;
 196
 197   std::string aValidatorID;
 198   Events_InfoMessage anErrorMsg;
 199
 200   static ModelAPI_ValidatorsFactory* aValidators = ModelAPI_Session::get()->validators();
 201   if (!aValidators->validate(anAttribute, aValidatorID, anErrorMsg)) {
 202     if (anErrorMsg.empty())
 203       anErrorMsg = "Unknown error.";
 204
 205     if (anErrorMsg.context().empty()) {
 206       anErrorMsg.setContext(aFeatureID + ":" + anAttributeID + ":" + aValidatorID);
 207     }
 208   }
 209
 210   if (anErrorMsg.empty() && theValueStateChecked) {
 211     anErrorMsg = getValueStateError();
 212   }
 213
 214   if (!anErrorMsg.empty()) {
 215     anError = ModuleBase_Tools::translate(anErrorMsg);
 216   }
 217
 218   return anError;
 219 }
 220
 221 //**************************************************************
 222 void ModuleBase_ModelWidget::enableFocusProcessing()
 223 {
 224   QList<QWidget*> aMyControls = getControls();
 225   foreach(QWidget*  eachControl, aMyControls) {
 226       eachControl->setFocusPolicy(Qt::StrongFocus);
 227       eachControl->installEventFilter(this);
 228   }
 229 }
 230
 231 //**************************************************************
 232 void ModuleBase_ModelWidget::setHighlighted(bool isHighlighted)
 233 {
 234   QList<QWidget*> aWidgetList = getControls();
 235   foreach(QWidget* aWidget, aWidgetList) {
 236     QLabel* aLabel = qobject_cast<QLabel*>(aWidget);
 237     // We won't set the effect to QLabels - it looks ugly
 238     if(aLabel) continue;
 239     // If effect is the installed on a different widget, setGraphicsEffect() will
 240     // remove the effect from the widget and install it on this widget.
 241     // That's why we create a new effect for each widget
 242     ModuleBase_Tools::setShadowEffect(aWidget, isHighlighted);
 243   }
 244 }
 245
 246 //**************************************************************
 247 void ModuleBase_ModelWidget::setFeature(const FeaturePtr& theFeature, const bool theToStoreValue,
 248                                         const bool isUpdateFlushed)
 249 {
 250   /// it is possible to give this flag as parameter in storeValue/storeCustomValue
 251   /// after debug, it may be corrected
 252   myFlushUpdateBlocked = !isUpdateFlushed;
 253   myFeature = theFeature;
 254   if (theToStoreValue) {
 255     /// it is possible that the attribute is filled before the operation is started,
 256     /// e.g. by reentrant operation case some attributes are filled by values of
 257     /// feature of previous operation, we should not lost them here
 258     if (!theFeature->data()->attribute(attributeID())->isInitialized())
 259       storeValue();
 260   }
 261   myFlushUpdateBlocked = false;
 262 }
 263
 264 //**************************************************************
 265 bool ModuleBase_ModelWidget::focusTo()
 266 {
 267 #ifdef DEBUG_WIDGET_INSTANCE
 268   qDebug("ModuleBase_ModelWidget::focusTo");
 269 #endif
 270   QList<QWidget*> aControls = getControls();
 271   QList<QWidget*>::const_iterator anIt = aControls.begin(), aLast = aControls.end();
 272   bool isFocusAccepted = false;
 273   for (; anIt != aLast && !isFocusAccepted; anIt++) {
 274     QWidget* aWidget = *anIt;
 275     if (aWidget && aWidget->focusPolicy() != Qt::NoFocus) {
 276       ModuleBase_Tools::setFocus(aWidget, "ModuleBase_ModelWidget::focusTo()");
 277       isFocusAccepted = true;
 278     }
 279   }
 280   return isFocusAccepted;
 281 }
 282
 283 //**************************************************************
 284 void ModuleBase_ModelWidget::activate()
 285 {
 286 #ifdef DEBUG_WIDGET_INSTANCE
 287   qDebug("ModuleBase_ModelWidget::activate");
 288 #endif
 289   // the control value is stored to the mode by the focus in on the widget
 290   // we need the value is initialized in order to enable the apply button in the property panel.
 291   // It should happens in the creation mode only because all fields are filled in the edition mode
 292   if (!isEditingMode()) {
 293     AttributePtr anAttribute = myFeature->data()->attribute(myAttributeID);
 294     if (anAttribute.get() != NULL && !anAttribute->isInitialized())
 295       initializeValueByActivate();
 296   }
 297   activateCustom();
 298 }
 299
 300 //**************************************************************
 301 void ModuleBase_ModelWidget::deactivate()
 302 {
 303 #ifdef DEBUG_WIDGET_INSTANCE
 304   qDebug("ModuleBase_ModelWidget::deactivate");
 305 #endif
 306   myIsValueStateBlocked = false;
 307   myState = Stored;
 308   if (myWidgetValidator)
 309     myWidgetValidator->clearValidatedCash();
 310 }
 311
 312 //**************************************************************
 313 void ModuleBase_ModelWidget::initializeValueByActivate()
 314 {
 315   if (isComputedDefault()) {
 316     if (myFeature->compute(myAttributeID)) {
 317       restoreValue();
 318     }
 319   }
 320   else {
 321     storeValue();
 322   }
 323 }
 324
 325 //**************************************************************
 326 QWidget* ModuleBase_ModelWidget::getControlAcceptingFocus(const bool isFirst)
 327 {
 328   QWidget* aControl = 0;
 329
 330   QList<QWidget*> aControls = getControls();
 331   int aSize = aControls.size();
 332
 333   if (isFirst) {
 334     for (int i = 0; i < aSize && !aControl; i++)  {
 335       if (aControls[i]->focusPolicy() != Qt::NoFocus)
 336         aControl = aControls[i];
 337     }
 338   }
 339   else {
 340     for (int i = aSize - 1; i >= 0 && !aControl; i--)  {
 341       if (aControls[i]->focusPolicy() != Qt::NoFocus)
 342         aControl = aControls[i];
 343     }
 344   }
 345   return aControl;
 346 }
 347
 348 //**************************************************************
 349 void ModuleBase_ModelWidget::setDefaultValue(const std::string& theValue)
 350 {
 351   myDefaultValue = theValue;
 352 }
 353
 354 //**************************************************************
 355 bool ModuleBase_ModelWidget::storeValue()
 356 {
 357   setValueState(Stored);
 358
 359   emit beforeValuesChanged();
 360   bool isDone = false;
 361   // value is stored only in creation mode and in edition if there is not
 362   // XML flag prohibited modification in edit mode(macro feature circle/arc)
 363   if (!isEditingMode() || isModifiedInEdit().empty())
 364     isDone = storeValueCustom();
 365   else {
 366     /// store value in an alternative attribute if possible(attribute has the same type)
 367     std::string aWidgetAttribute = attributeID();
 368     myAttributeID = isModifiedInEdit();
 369     storeValueCustom();
 370     myAttributeID = aWidgetAttribute;
 371     // operation will be restarted but if isDone == true, PagedContainer will try to set focus
 372     // to the current widget, but will be already deleted
 373     isDone = false;
 374   }
 375
 376   emit afterValuesChanged();
 377
 378   return isDone;
 379 }
 380 #ifdef DEBUG_VALUE_STATE
 381
 382 //**************************************************************
 383 std::string getDebugInfo(const ModuleBase_ModelWidget::ValueState& theState)
 384 {
 385   std::string anInfo;
 386   switch (theState) {
 387     case ModuleBase_ModelWidget::Stored:           anInfo = "Stored          "; break;
 388     case ModuleBase_ModelWidget::ModifiedInPP:     anInfo = "ModifiedInPP    "; break;
 389     case ModuleBase_ModelWidget::ModifiedInViewer: anInfo = "ModifiedInViewer"; break;
 390     case ModuleBase_ModelWidget::Reset:            anInfo = "Reset           "; break;
 391     default: break;
 392   }
 393   return anInfo;
 394 }
 395 #endif
 396
 397 //**************************************************************
 398 ModuleBase_ModelWidget::ValueState ModuleBase_ModelWidget::setValueState
 399                                          (const ModuleBase_ModelWidget::ValueState& theState)
 400 {
 401   ValueState aState = myState;
 402
 403   if (myState != theState && !myIsValueStateBlocked) {
 404 #ifdef DEBUG_VALUE_STATE
 405     qDebug(QString("setValueState: previous state = %1,\t new state = %2")
 406            .arg(getDebugInfo(myState).c_str())
 407            .arg(getDebugInfo(theState).c_str()).toStdString().c_str());
 408 #endif
 409     myState = theState;
 410     emit valueStateChanged(aState);
 411   }
 412   return aState;
 413 }
 414
 415 //**************************************************************
 416 bool ModuleBase_ModelWidget::blockValueState(const bool theBlocked)
 417 {
 418   bool isBlocked = myIsValueStateBlocked;
 419   myIsValueStateBlocked = theBlocked;
 420   return isBlocked;
 421 }
 422
 423 //**************************************************************
 424 bool ModuleBase_ModelWidget::restoreValue()
 425 {
 426   emit beforeValuesRestored();
 427   bool isDone = restoreValueCustom();
 428   emit afterValuesRestored();
 429
 430   return isDone;
 431 }
 432
 433 //**************************************************************
 434 void ModuleBase_ModelWidget::updateObject(ObjectPtr theObject)
 435 {
 436   if (!myFlushUpdateBlocked) {
 437 #ifdef DEBUG_WIDGET_INSTANCE
 438     qDebug("ModuleBase_ModelWidget::updateObject");
 439 #endif
 440     ModuleBase_Tools::flushUpdated(theObject);
 441     emit objectUpdated();
 442   }
 443 }
 444
 445 //**************************************************************
 446 bool ModuleBase_ModelWidget::canProcessAction(ModuleBase_ActionType theActionType,
 447                                               bool& isActionEnabled)
 448 {
 449   isActionEnabled = false;
 450   switch (theActionType) {
 451     case ActionEnter: return false;
 452     case ActionEscape: return false;
 453     case ActionDelete: return true;
 454     case ActionSelection: return true;
 455     case ActionUndo:
 456     case ActionRedo:
 457     default:
 458       return false;
 459   }
 460 }
 461
 462 //**************************************************************
 463 bool ModuleBase_ModelWidget::processAction(ModuleBase_ActionType theActionType,
 464                                            const ActionParamPtr& theParam)
 465 {
 466   switch (theActionType) {
 467     case ActionEnter:
 468       return processEnter();
 469     case ActionEscape:
 470       return processEscape();
 471     case ActionDelete:
 472       return processDelete();
 473     case ActionSelection:
 474       processSelection();
 475     case ActionUndo:
 476     case ActionRedo:
 477     default:
 478       return false;
 479   }
 480 }
 481
 482 //**************************************************************
 483 bool ModuleBase_ModelWidget::processEnter()
 484 {
 485   return false;
 486 }
 487
 488 //**************************************************************
 489 bool ModuleBase_ModelWidget::processEscape()
 490 {
 491   return false;
 492 }
 493
 494 //**************************************************************
 495 bool ModuleBase_ModelWidget::processDelete()
 496 {
 497   // we consider that model objects eats delete key in order to
 498   // do nothing by for example symbol delete in line edit or spin box
 499   return true;
 500 }
 501
 502 //**************************************************************
 503 bool ModuleBase_ModelWidget::processSelection()
 504 {
 505   return false;
 506 }
 507
 508 //**************************************************************
 509 bool ModuleBase_ModelWidget::eventFilter(QObject* theObject, QEvent *theEvent)
 510 {
 511   QWidget* aWidget = qobject_cast<QWidget*>(theObject);
 512   if (theEvent->type() == QEvent::FocusIn) {
 513     QFocusEvent* aFocusEvent = dynamic_cast<QFocusEvent*>(theEvent);
 514     Qt::FocusReason aReason = aFocusEvent->reason();
 515     bool aMouseOrKey = aReason == Qt::MouseFocusReason ||
 516                         /*aReason == Qt::TabFocusReason ||
 517                         //aReason == Qt::BacktabFocusReason ||*/
 518                         aReason == Qt::OtherFocusReason; // to process widget->setFocus()
 519     if (aMouseOrKey && getControls().contains(aWidget)) {
 520     //if (getControls().contains(aWidget)) {
 521       emitFocusInWidget();
 522     }
 523   }
 524   else if (theEvent->type() == QEvent::FocusOut) {
 525     QFocusEvent* aFocusEvent = dynamic_cast<QFocusEvent*>(theEvent);
 526
 527     Qt::FocusReason aReason = aFocusEvent->reason();
 528     bool aMouseOrKey = aReason == Qt::MouseFocusReason ||
 529                         aReason == Qt::TabFocusReason ||
 530                         aReason == Qt::BacktabFocusReason ||
 531                         aReason == Qt::OtherFocusReason; // to process widget->setFocus()
 532     if (aMouseOrKey && getControls().contains(aWidget)) {
 533       if (getValueState() == ModifiedInPP) {
 534         storeValue();
 535       }
 536     }
 537   }
 538   // pass the event on to the parent class
 539
 540   return QObject::eventFilter(theObject, theEvent);
 541 }
 542
 543 //**************************************************************
 544 void ModuleBase_ModelWidget::onWidgetValuesChanged()
 545 {
 546   storeValue();
 547 }
 548
 549 //**************************************************************
 550 void ModuleBase_ModelWidget::onWidgetValuesModified()
 551 {
 552   setValueState(ModifiedInPP);
 553 }
 554
 555 //**************************************************************
 556 QString ModuleBase_ModelWidget::translate(const std::string& theStr) const
 557 {
 558   return ModuleBase_Tools::translate(context(), theStr);
 559 }
 560
 561 //**************************************************************
 562 ModuleBase_ModelWidget* ModuleBase_ModelWidget::findModelWidget(ModuleBase_IPropertyPanel* theProp,
 563                                                                 QWidget* theWidget)
 564 {
 565   ModuleBase_ModelWidget* aModelWidget = 0;
 566   if (!theWidget)
 567     return aModelWidget;
 568
 569   QObject* aParent = theWidget->parent();
 570   while (aParent) {
 571     aModelWidget = qobject_cast<ModuleBase_ModelWidget*>(aParent);
 572     if (aModelWidget)
 573       break;
 574     aParent = aParent->parent();
 575   }
 576   return aModelWidget;
 577 }