]> SALOME platform Git repositories - modules/shaper.git/blob - src/ModuleBase/ModuleBase_ModelWidget.cpp
Salome HOME
Issue #2052: Modification of parameters don't work (sketch, extrusion)
[modules/shaper.git] / src / ModuleBase / ModuleBase_ModelWidget.cpp
1 // Copyright (C) 2014-20xx CEA/DEN, EDF R&D
2
3 // File:        ModuleBase_ModelWidget.cpp
4 // Created:     25 Apr 2014
5 // Author:      Natalia ERMOLAEVA
6
7 #include "ModuleBase_ModelWidget.h"
8 #include "ModuleBase_ViewerPrs.h"
9 #include "ModuleBase_Tools.h"
10 #include "ModuleBase_WidgetValidator.h"
11
12 #include <Events_InfoMessage.h>
13
14 #include <ModelAPI_Data.h>
15 #include <ModelAPI_Attribute.h>
16 #include <ModelAPI_Events.h>
17 #include <ModelAPI_Session.h>
18 #include <ModelAPI_Validator.h>
19
20 #include <Config_Keywords.h>
21 #include <Config_WidgetAPI.h>
22 #include <Config_Translator.h>
23 #include <Config_PropManager.h>
24
25 #include <Events_Loop.h>
26
27 #include <QEvent>
28 #include <QLabel>
29 #include <QFocusEvent>
30 #include <QTextCodec>
31
32 //#define DEBUG_VALUE_STATE
33
34 //#define DEBUG_WIDGET_INSTANCE
35 //#define DEBUG_ENABLE_SKETCH_INPUT_FIELDS
36
37 ModuleBase_ModelWidget::ModuleBase_ModelWidget(QWidget* theParent,
38                                                const Config_WidgetAPI* theData)
39     : QWidget(theParent),
40       myIsEditing(false),
41       myState(Stored),
42       myIsValueStateBlocked(false),
43       myFlushUpdateBlocked(false),
44       myWidgetValidator(0)
45 {
46 #ifdef DEBUG_WIDGET_INSTANCE
47   qDebug("ModuleBase_ModelWidget::ModuleBase_ModelWidget");
48 #endif
49
50   myFeatureId = theData->featureId();
51
52   myIsInternal = theData->getBooleanAttribute(ATTR_INTERNAL, false);
53
54   myIsModifiedInEdit = theData->getProperty(ATTR_MODIFIED_IN_EDIT);
55
56   myDefaultValue = theData->getProperty(ATTR_DEFAULT);
57   myUseReset = theData->getBooleanAttribute(ATTR_USE_RESET, true);
58   myIsComputedDefault = theData->getProperty(ATTR_DEFAULT) == DOUBLE_WDG_DEFAULT_COMPUTED;
59   myAttributeID = theData ? theData->widgetId() : "";
60   myIsObligatory = theData->getBooleanAttribute(ATTR_OBLIGATORY, true);
61
62   myIsValueEnabled = On; // not defined or "true"
63   std::string anEnableValue = theData->getProperty(DOUBLE_WDG_ENABLE_VALUE);
64   if (anEnableValue == "false")
65     myIsValueEnabled = Off;
66   if (anEnableValue == DOUBLE_WDG_ENABLE_VALUE_BY_PREFERENCES)
67     myIsValueEnabled = DefinedInPreferences;
68
69   connect(this, SIGNAL(valuesChanged()), this, SLOT(onWidgetValuesChanged()));
70   connect(this, SIGNAL(valuesModified()), this, SLOT(onWidgetValuesModified()));
71 }
72
73 ModuleBase_ModelWidget::~ModuleBase_ModelWidget()
74 {
75 #ifdef DEBUG_WIDGET_INSTANCE
76   qDebug("ModuleBase_ModelWidget::~ModuleBase_ModelWidget");
77 #endif
78 }
79
80 bool ModuleBase_ModelWidget::reset()
81 {
82   bool aResult = resetCustom();
83   if (aResult)
84     setValueState(Reset);
85
86   return aResult;
87 }
88
89 bool ModuleBase_ModelWidget::isInitialized(ObjectPtr theObject) const
90 {
91   return theObject->data()->attribute(attributeID())->isInitialized();
92 }
93
94 bool ModuleBase_ModelWidget::isValueEnabled() const
95 {
96   bool anEnabled = true;
97   if (myIsValueEnabled == DefinedInPreferences) {
98 #ifdef DEBUG_ENABLE_SKETCH_INPUT_FIELDS
99     bool aCanDisable = false;
100 #else
101     //Config_PropManager::boolean(SKETCH_TAB_NAME, "disable_input_fields", "true");
102     bool aCanDisable = true;
103 #endif
104     if (aCanDisable)
105       anEnabled = false;
106   }
107   else if (myIsValueEnabled == Off)
108     anEnabled = false;
109   return anEnabled;
110 }
111
112 void ModuleBase_ModelWidget::processValueState()
113 {
114   if (myState == ModifiedInPP || myState == ModifiedInViewer)
115     storeValue();
116 }
117
118 Events_InfoMessage ModuleBase_ModelWidget::getValueStateError() const
119 {
120   Events_InfoMessage aMessage;
121
122   ModuleBase_ModelWidget::ValueState aState = getValueState();
123   if (aState != ModuleBase_ModelWidget::Stored) {
124     AttributePtr anAttr = feature()->attribute(attributeID());
125     if (anAttr.get()) {
126       const std::string& anAttributeName = anAttr->id();
127       switch (aState) {
128         case ModuleBase_ModelWidget::ModifiedInViewer:
129           aMessage = "Attribute \"%1\" is locked by modification value in the viewer.";
130           aMessage.addParameter(anAttributeName);
131           break;
132         case ModuleBase_ModelWidget::Reset:
133           aMessage = "Attribute \"%1\" is not initialized.";
134           aMessage.addParameter(anAttributeName);
135           break;
136         case ModuleBase_ModelWidget::ModifiedInPP: // Apply should be enabled in this mode
137         default:
138           break;
139       }
140     }
141   }
142   return aMessage;
143 }
144
145 QString ModuleBase_ModelWidget::getError(const bool theValueStateChecked) const
146 {
147   QString anError;
148
149   if (!feature().get())
150     return anError;
151
152   std::string aFeatureID = feature()->getKind();
153   std::string anAttributeID = attributeID();
154   AttributePtr anAttribute = feature()->attribute(anAttributeID);
155   if (!anAttribute.get())
156     return anError;
157
158   std::string aValidatorID;
159   Events_InfoMessage anErrorMsg;
160
161   static ModelAPI_ValidatorsFactory* aValidators = ModelAPI_Session::get()->validators();
162   if (!aValidators->validate(anAttribute, aValidatorID, anErrorMsg)) {
163     if (anErrorMsg.empty())
164       anErrorMsg = "Unknown error.";
165
166     if (anErrorMsg.context().empty()) {
167       anErrorMsg.setContext(aFeatureID + ":" + anAttributeID + ":" + aValidatorID);
168     }
169   }
170
171   if (anErrorMsg.empty() && theValueStateChecked) {
172     anErrorMsg = getValueStateError();
173   }
174
175   if (!anErrorMsg.empty()) {
176     anError = ModuleBase_Tools::translate(anErrorMsg);
177   }
178
179   return anError;
180 }
181
182 void ModuleBase_ModelWidget::enableFocusProcessing()
183 {
184   QList<QWidget*> aMyControls = getControls();
185   foreach(QWidget*  eachControl, aMyControls) {
186       eachControl->setFocusPolicy(Qt::StrongFocus);
187       eachControl->installEventFilter(this);
188   }
189 }
190
191 void ModuleBase_ModelWidget::setHighlighted(bool isHighlighted)
192 {
193   QList<QWidget*> aWidgetList = getControls();
194   foreach(QWidget* aWidget, aWidgetList) {
195     QLabel* aLabel = qobject_cast<QLabel*>(aWidget);
196     // We won't set the effect to QLabels - it looks ugly
197     if(aLabel) continue;
198     // If effect is the installed on a different widget, setGraphicsEffect() will
199     // remove the effect from the widget and install it on this widget.
200     // That's why we create a new effect for each widget
201     ModuleBase_Tools::setShadowEffect(aWidget, isHighlighted);
202   }
203 }
204
205 void ModuleBase_ModelWidget::setFeature(const FeaturePtr& theFeature, const bool theToStoreValue,
206                                         const bool isUpdateFlushed)
207 {
208   /// it is possible to give this flag as parameter in storeValue/storeCustomValue
209   /// after debug, it may be corrected
210   myFlushUpdateBlocked = !isUpdateFlushed;
211   myFeature = theFeature;
212   if (theToStoreValue) {
213     /// it is possible that the attribute is filled before the operation is started,
214     /// e.g. by reentrant operation case some attributes are filled by values of
215     /// feature of previous operation, we should not lost them here
216     if (!theFeature->data()->attribute(attributeID())->isInitialized())
217       storeValue();
218   }
219   myFlushUpdateBlocked = false;
220 }
221
222 bool ModuleBase_ModelWidget::focusTo()
223 {
224 #ifdef DEBUG_WIDGET_INSTANCE
225   qDebug("ModuleBase_ModelWidget::focusTo");
226 #endif
227   QList<QWidget*> aControls = getControls();
228   QList<QWidget*>::const_iterator anIt = aControls.begin(), aLast = aControls.end();
229   bool isFocusAccepted = false;
230   for (; anIt != aLast && !isFocusAccepted; anIt++) {
231     QWidget* aWidget = *anIt;
232     if (aWidget && aWidget->focusPolicy() != Qt::NoFocus) {
233       ModuleBase_Tools::setFocus(aWidget, "ModuleBase_ModelWidget::focusTo()");
234       isFocusAccepted = true;
235     }
236   }
237   return isFocusAccepted;
238 }
239
240 void ModuleBase_ModelWidget::activate()
241 {
242 #ifdef DEBUG_WIDGET_INSTANCE
243   qDebug("ModuleBase_ModelWidget::activate");
244 #endif
245   // the control value is stored to the mode by the focus in on the widget
246   // we need the value is initialized in order to enable the apply button in the property panel.
247   // It should happens in the creation mode only because all fields are filled in the edition mode
248   if (!isEditingMode()) {
249     AttributePtr anAttribute = myFeature->data()->attribute(myAttributeID);
250     if (anAttribute.get() != NULL && !anAttribute->isInitialized())
251       initializeValueByActivate();
252   }
253
254   if (myWidgetValidator)
255     myWidgetValidator->activateFilters(true);
256
257   activateCustom();
258 }
259
260 void ModuleBase_ModelWidget::deactivate()
261 {
262 #ifdef DEBUG_WIDGET_INSTANCE
263   qDebug("ModuleBase_ModelWidget::deactivate");
264 #endif
265   myIsValueStateBlocked = false;
266   myState = Stored;
267   if (myWidgetValidator)
268     myWidgetValidator->activateFilters(false);
269 }
270
271 void ModuleBase_ModelWidget::initializeValueByActivate()
272 {
273   if (isComputedDefault()) {
274     if (myFeature->compute(myAttributeID)) {
275       restoreValue();
276     }
277   }
278   else {
279     storeValue();
280   }
281 }
282
283 QWidget* ModuleBase_ModelWidget::getControlAcceptingFocus(const bool isFirst)
284 {
285   QWidget* aControl = 0;
286
287   QList<QWidget*> aControls = getControls();
288   int aSize = aControls.size();
289
290   if (isFirst) {
291     for (int i = 0; i < aSize && !aControl; i++)  {
292       if (aControls[i]->focusPolicy() != Qt::NoFocus)
293         aControl = aControls[i];
294     }
295   }
296   else {
297     for (int i = aSize - 1; i >= 0 && !aControl; i--)  {
298       if (aControls[i]->focusPolicy() != Qt::NoFocus)
299         aControl = aControls[i];
300     }
301   }
302   return aControl;
303 }
304
305 void ModuleBase_ModelWidget::setDefaultValue(const std::string& theValue)
306 {
307   myDefaultValue = theValue;
308 }
309
310 bool ModuleBase_ModelWidget::storeValue()
311 {
312   setValueState(Stored);
313
314   emit beforeValuesChanged();
315   bool isDone = false;
316   // value is stored only in creation mode and in edition if there is not
317   // XML flag prohibited modification in edit mode(macro feature circle/arc)
318   if (!isEditingMode() || isModifiedInEdit().empty())
319     isDone = storeValueCustom();
320   else {
321     /// store value in an alternative attribute if possible(attribute has the same type)
322     std::string aWidgetAttribute = attributeID();
323     myAttributeID = isModifiedInEdit();
324     storeValueCustom();
325     myAttributeID = aWidgetAttribute;
326     // operation will be restarted but if isDone == true, PagedContainer will try to set focus
327     // to the current widget, but will be already deleted
328     isDone = false;
329   }
330
331   emit afterValuesChanged();
332
333   return isDone;
334 }
335 #ifdef DEBUG_VALUE_STATE
336 std::string getDebugInfo(const ModuleBase_ModelWidget::ValueState& theState)
337 {
338   std::string anInfo;
339   switch (theState) {
340     case ModuleBase_ModelWidget::Stored:           anInfo = "Stored          "; break;
341     case ModuleBase_ModelWidget::ModifiedInPP:     anInfo = "ModifiedInPP    "; break;
342     case ModuleBase_ModelWidget::ModifiedInViewer: anInfo = "ModifiedInViewer"; break;
343     case ModuleBase_ModelWidget::Reset:            anInfo = "Reset           "; break;
344     default: break;
345   }
346   return anInfo;
347 }
348
349 #endif
350 ModuleBase_ModelWidget::ValueState ModuleBase_ModelWidget::setValueState
351                                          (const ModuleBase_ModelWidget::ValueState& theState)
352 {
353   ValueState aState = myState;
354
355   if (myState != theState && !myIsValueStateBlocked) {
356 #ifdef DEBUG_VALUE_STATE
357     qDebug(QString("setValueState: previous state = %1,\t new state = %2")
358            .arg(getDebugInfo(myState).c_str())
359            .arg(getDebugInfo(theState).c_str()).toStdString().c_str());
360 #endif
361     myState = theState;
362     emit valueStateChanged(aState);
363   }
364   return aState;
365 }
366
367 bool ModuleBase_ModelWidget::blockValueState(const bool theBlocked)
368 {
369   bool isBlocked = myIsValueStateBlocked;
370   myIsValueStateBlocked = theBlocked;
371   return isBlocked;
372 }
373
374 bool ModuleBase_ModelWidget::restoreValue()
375 {
376   emit beforeValuesRestored();
377   bool isDone = restoreValueCustom();
378   emit afterValuesRestored();
379
380   return isDone;
381 }
382
383 void ModuleBase_ModelWidget::updateObject(ObjectPtr theObject)
384 {
385   if (!myFlushUpdateBlocked) {
386 #ifdef DEBUG_WIDGET_INSTANCE
387     qDebug("ModuleBase_ModelWidget::updateObject");
388 #endif
389     ModuleBase_Tools::flushUpdated(theObject);
390     emit objectUpdated();
391   }
392 }
393
394 void ModuleBase_ModelWidget::moveObject(ObjectPtr theObj)
395 {
396   //blockUpdateViewer(true);
397 #ifdef DEBUG_WIDGET_INSTANCE
398   qDebug("ModuleBase_ModelWidget::moveObject");
399 #endif
400
401   static Events_ID anEvent = Events_Loop::eventByName(EVENT_OBJECT_MOVED);
402   ModelAPI_EventCreator::get()->sendUpdated(theObj, anEvent);
403   Events_Loop::loop()->flush(anEvent);
404
405   //blockUpdateViewer(false);
406 }
407
408 bool ModuleBase_ModelWidget::processEnter()
409 {
410   return false;
411 }
412
413 bool ModuleBase_ModelWidget::processDelete()
414 {
415   // we consider that model objects eats delete key in order to
416   // do nothing by for example symbol delete in line edit or spin box
417   return true;
418 }
419
420 bool ModuleBase_ModelWidget::eventFilter(QObject* theObject, QEvent *theEvent)
421 {
422   QWidget* aWidget = qobject_cast<QWidget*>(theObject);
423   if (theEvent->type() == QEvent::FocusIn) {
424     #ifdef _DEBUG
425     // The following two lines are for debugging purpose only
426     QFocusEvent* aFocusEvent = dynamic_cast<QFocusEvent*>(theEvent);
427     bool isWinFocus = aFocusEvent->reason() == Qt::ActiveWindowFocusReason;
428     #endif
429     if (getControls().contains(aWidget)) {
430       emit focusInWidget(this);
431     }
432   }
433   else if (theEvent->type() == QEvent::FocusOut) {
434     QFocusEvent* aFocusEvent = dynamic_cast<QFocusEvent*>(theEvent);
435
436     Qt::FocusReason aReason = aFocusEvent->reason();
437     bool aMouseOrKey = aReason == Qt::MouseFocusReason ||
438                         aReason == Qt::TabFocusReason ||
439                         aReason == Qt::BacktabFocusReason ||
440                         aReason == Qt::OtherFocusReason; // to process widget->setFocus()
441     if (aMouseOrKey && getControls().contains(aWidget)) {
442       if (getValueState() == ModifiedInPP) {
443         storeValue();
444       }
445     }
446   }
447   // pass the event on to the parent class
448
449   return QObject::eventFilter(theObject, theEvent);
450 }
451
452 //**************************************************************
453 void ModuleBase_ModelWidget::onWidgetValuesChanged()
454 {
455   storeValue();
456 }
457
458 //**************************************************************
459 void ModuleBase_ModelWidget::onWidgetValuesModified()
460 {
461   setValueState(ModifiedInPP);
462 }
463
464 QString ModuleBase_ModelWidget::translate(const std::string& theStr) const
465 {
466   return ModuleBase_Tools::translate(context(), theStr);
467 }