]> SALOME platform Git repositories - modules/shaper.git/blob - src/ModuleBase/ModuleBase_OperationFeature.cpp
Salome HOME
Method isStable is defined
[modules/shaper.git] / src / ModuleBase / ModuleBase_OperationFeature.cpp
1 // Copyright (C) 2014-20xx CEA/DEN, EDF R&D
2
3 /*
4  * ModuleBase_OperationFeature.cpp
5  *
6  *  Created on: Apr 2, 2014
7  *      Author: sbh
8  */
9
10 #include "ModuleBase_OperationFeature.h"
11
12 #include "ModuleBase_OperationDescription.h"
13 #include "ModuleBase_ModelWidget.h"
14 #include "ModuleBase_ViewerPrs.h"
15 #include "ModuleBase_IPropertyPanel.h"
16 #include "ModuleBase_ISelection.h"
17 #include "ModuleBase_IViewer.h"
18
19 #include <ModelAPI_AttributeDouble.h>
20 #include <ModelAPI_Document.h>
21 #include <ModelAPI_Feature.h>
22 #include <ModelAPI_Data.h>
23 #include <ModelAPI_Document.h>
24 #include <ModelAPI_Events.h>
25 #include <ModelAPI_Result.h>
26 #include <ModelAPI_Object.h>
27 #include <ModelAPI_Validator.h>
28 #include <ModelAPI_Session.h>
29
30 #include <GeomAPI_Pnt2d.h>
31
32 #include <Events_Loop.h>
33
34 #include <QTimer>
35
36 #ifdef _DEBUG
37 #include <QDebug>
38 #endif
39
40 ModuleBase_OperationFeature::ModuleBase_OperationFeature(const QString& theId, QObject* theParent)
41 : ModuleBase_Operation(theId, theParent),
42   myIsEditing(false)
43 {
44 }
45
46 ModuleBase_OperationFeature::~ModuleBase_OperationFeature()
47 {
48   clearPreselection();
49 }
50
51 FeaturePtr ModuleBase_OperationFeature::feature() const
52 {
53   return myFeature;
54 }
55
56 bool ModuleBase_OperationFeature::isValid() const
57 {
58   if (!myFeature || !myFeature->data()->isValid())
59     return true; // rename operation
60   if (myFeature->isAction())
61     return true;
62   //Get validators for the Id
63   SessionPtr aMgr = ModelAPI_Session::get();
64   ModelAPI_ValidatorsFactory* aFactory = aMgr->validators();
65   bool aValid = aFactory->validate(myFeature);
66
67   // the feature exec state should be checked in order to do not apply features, which result can not
68   // be built. E.g. extrusion on sketch, where the "to" is a perpendicular plane to the sketch
69   bool isDone = ( myFeature->data()->execState() == ModelAPI_StateDone
70                || myFeature->data()->execState() == ModelAPI_StateMustBeUpdated );
71
72   return aValid && isDone;
73 }
74
75 void ModuleBase_OperationFeature::startOperation()
76 {
77   FeaturePtr aFeature = feature();
78   if (!aFeature.get() || !isEditOperation())
79     return;
80
81   myVisualizedObjects.clear();
82   // store hidden result features
83   std::list<ResultPtr> aResults = aFeature->results();
84   std::list<ResultPtr>::const_iterator aIt;
85   for (aIt = aResults.begin(); aIt != aResults.end(); ++aIt) {
86     ObjectPtr anObject = *aIt;
87     if (anObject.get() && !anObject->isDisplayed()) {
88       myVisualizedObjects.insert(*aIt);
89       anObject->setDisplayed(true);
90     }
91   }
92   if (!aFeature->isDisplayed()) {
93     myVisualizedObjects.insert(aFeature);
94     aFeature->setDisplayed(true);
95   }
96   Events_Loop::loop()->flush(Events_Loop::loop()->eventByName(EVENT_OBJECT_TO_REDISPLAY));
97 }
98
99 void ModuleBase_OperationFeature::stopOperation()
100 {
101   FeaturePtr aFeature = feature();
102   if (!aFeature.get() || !isEditOperation())
103     return;
104
105   // store hidden result features
106   std::list<ResultPtr> aResults = aFeature->results();
107   std::list<ResultPtr>::const_iterator aIt;
108   for (aIt = aResults.begin(); aIt != aResults.end(); ++aIt) {
109     ObjectPtr anObject = *aIt;
110     if (anObject.get() && myVisualizedObjects.find(anObject) != myVisualizedObjects.end()) {
111       anObject->setDisplayed(false);
112     }
113   }
114   if (myVisualizedObjects.find(aFeature) != myVisualizedObjects.end()) {
115     aFeature->setDisplayed(false);
116   }
117   aFeature->setStable(true);
118   if (myVisualizedObjects.size() > 0)
119     Events_Loop::loop()->flush(Events_Loop::loop()->eventByName(EVENT_OBJECT_TO_REDISPLAY));
120 }
121
122 FeaturePtr ModuleBase_OperationFeature::createFeature(const bool theFlushMessage)
123 {
124   if (myParentFeature.get()) {
125     myFeature = myParentFeature->addFeature(getDescription()->operationId().toStdString());
126   } else {
127     std::shared_ptr<ModelAPI_Document> aDoc = ModelAPI_Session::get()->activeDocument();
128     myFeature = aDoc->addFeature(getDescription()->operationId().toStdString());
129   }
130   if (myFeature) {  // TODO: generate an error if feature was not created
131     setIsModified(true);
132     // Model update should call "execute" of a feature.
133     //myFeature->execute();
134     // Init default values
135     /*QList<ModuleBase_ModelWidget*> aWidgets = getDescription()->modelWidgets();
136      QList<ModuleBase_ModelWidget*>::const_iterator anIt = aWidgets.begin(), aLast = aWidgets.end();
137      for (; anIt != aLast; anIt++) {
138      (*anIt)->storeValue(aFeature);
139      }*/
140   }
141
142   if (theFlushMessage)
143     Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_CREATED));
144   return myFeature;
145 }
146
147 void ModuleBase_OperationFeature::setFeature(FeaturePtr theFeature)
148 {
149   myFeature = theFeature;
150   myFeature->setStable(false);
151   myIsEditing = true;
152 }
153
154 bool ModuleBase_OperationFeature::hasObject(ObjectPtr theObj) const
155 {
156   FeaturePtr aFeature = feature();
157   if (aFeature) {
158     if (aFeature == theObj)
159       return true;
160     std::list<ResultPtr> aResults = aFeature->results();
161     std::list<ResultPtr>::const_iterator aIt;
162     for (aIt = aResults.cbegin(); aIt != aResults.cend(); ++aIt) {
163       if (theObj == (*aIt))
164         return true;
165     }
166   }
167   return false;
168 }
169
170 bool ModuleBase_OperationFeature::isDisplayedOnStart(ObjectPtr theObject)
171 {
172   return myVisualizedObjects.find(theObject) != myVisualizedObjects.end();
173 }
174
175 void ModuleBase_OperationFeature::start()
176 {
177   setIsModified(false);
178   QString anId = getDescription()->operationId();
179   if (myIsEditing) {
180     anId = anId.append(EditSuffix());
181   }
182   ModelAPI_Session::get()->startOperation(anId.toStdString());
183
184   startOperation();
185
186   if (!myIsEditing) {
187     FeaturePtr aFeature = createFeature();
188     // if the feature is not created, there is no sense to start the operation
189     if (aFeature.get() == NULL) {
190       // it is necessary to abor the operation in the session and emit the aborted signal
191       // in order to update commands status in the workshop, to be exact the feature action
192       // to be unchecked
193       abort();
194       return;
195     }
196   }
197   /// Set current feature and remeber old current feature
198   if (myIsEditing) {
199     SessionPtr aMgr = ModelAPI_Session::get();
200     DocumentPtr aDoc = aMgr->activeDocument();
201     // the parameter of current feature should be false, we should use all feature, not only visible
202     // in order to correctly save the previous feature of the nested operation, where the
203     // features can be not visible in the tree. The problem case is Edit sketch entitity(line)
204     // in the Sketch, created in ExtrusionCut operation. The entity disappears by commit.
205     // When sketch entity operation started, the sketch should be cashed here as the current.
206     // Otherwise(the flag is true), the ExtrusionCut is cashed, when commit happens, the sketch
207     // is disabled, sketch entity is disabled as extrusion cut is created earliest then sketch.
208     // As a result the sketch disappears from the viewer. However after commit it is displayed back.
209     myPreviousCurrentFeature = aDoc->currentFeature(false);
210     aDoc->setCurrentFeature(feature(), false);
211   }
212
213   startOperation();
214   emit started();
215
216 }
217
218 void ModuleBase_OperationFeature::abort()
219 {
220   // the viewer update should be blocked in order to avoid the features blinking before they are
221   // hidden
222   std::shared_ptr<Events_Message> aMsg = std::shared_ptr<Events_Message>(
223       new Events_Message(Events_Loop::eventByName(EVENT_UPDATE_VIEWER_BLOCKED)));
224   Events_Loop::loop()->send(aMsg);
225
226   // the widgets of property panel should not process any events come from data mode
227   // after abort clicked. Some signal such as redisplay/create influence on content
228   // of the object browser and viewer context. Therefore it influence to the current
229   // selection and if the active widget listens it, the attribute value is errnoneous
230   // changed.
231   ModuleBase_IPropertyPanel* aPropertyPanel = propertyPanel();
232   if (aPropertyPanel)
233     aPropertyPanel->cleanContent();
234
235   SessionPtr aMgr = ModelAPI_Session::get();
236   if (myIsEditing) {
237     DocumentPtr aDoc = aMgr->activeDocument();
238     bool aIsOp = aMgr->isOperation();
239     if (!aIsOp)
240       aMgr->startOperation();
241     aDoc->setCurrentFeature(myPreviousCurrentFeature, true);
242     if (!aIsOp)
243       aMgr->finishOperation();
244     myPreviousCurrentFeature = FeaturePtr();
245   }
246   abortOperation();
247
248   stopOperation();
249
250   aMgr->abortOperation();
251   emit stopped();
252   // the viewer update should be unblocked in order to avoid the features blinking before they are
253   // hidden
254   aMsg = std::shared_ptr<Events_Message>(
255                 new Events_Message(Events_Loop::eventByName(EVENT_UPDATE_VIEWER_UNBLOCKED)));
256
257   Events_Loop::loop()->send(aMsg);
258
259   emit aborted();
260 }
261
262 bool ModuleBase_OperationFeature::commit()
263 {
264   if (canBeCommitted()) {
265     // the widgets of property panel should not process any events come from data mode
266     // after commit clicked. Some signal such as redisplay/create influence on content
267     // of the object browser and viewer context. Therefore it influence to the current
268     // selection and if the active widget listens it, the attribute value is errnoneous
269     // changed.
270     ModuleBase_IPropertyPanel* aPropertyPanel = propertyPanel();
271     if (aPropertyPanel)
272       aPropertyPanel->cleanContent();
273
274     SessionPtr aMgr = ModelAPI_Session::get();
275     /// Set current feature and remeber old current feature
276     if (myIsEditing) {
277       DocumentPtr aDoc = aMgr->activeDocument();
278       bool aIsOp = aMgr->isOperation();
279       if (!aIsOp)
280         aMgr->startOperation();
281       aDoc->setCurrentFeature(myPreviousCurrentFeature, true);
282       if (!aIsOp)
283         aMgr->finishOperation();
284       myPreviousCurrentFeature = FeaturePtr();
285     }
286     commitOperation();
287     aMgr->finishOperation();
288
289     stopOperation();
290     emit stopped();
291     emit committed();
292
293     afterCommitOperation();
294     return true;
295   }
296   return false;
297 }
298
299 void ModuleBase_OperationFeature::activateByPreselection()
300 {
301   if (myPreSelection.empty())
302     return;
303
304   ModuleBase_ModelWidget* aFilledWgt = 0;
305   ModuleBase_IPropertyPanel* aPropertyPanel = propertyPanel();
306   if (aPropertyPanel) {
307     const QList<ModuleBase_ModelWidget*>& aWidgets = aPropertyPanel->modelWidgets();
308     if (!aWidgets.empty()) {
309       ModuleBase_ModelWidget* aWgt = 0;
310       QList<ModuleBase_ModelWidget*>::const_iterator aWIt;
311       bool isSet = false;
312       // 1. apply the selection to controls
313       for (aWIt = aWidgets.constBegin(); aWIt != aWidgets.constEnd(); ++aWIt) {
314         aWgt = (*aWIt);
315         if (!aWgt->canSetValue())
316           continue;
317         aPropertyPanel->setPreselectionWidget(aWgt);
318         if (!aWgt->setSelection(myPreSelection, true)) {
319           isSet = false;
320           break;
321         } else {
322           isSet = true;
323           aFilledWgt = aWgt;
324         }
325       }
326       aPropertyPanel->setPreselectionWidget(NULL);
327       // in order to redisplay object in the viewer, the update/redisplay signals should be flushed
328       // it is better to perform it not in setSelection of each widget, but do it here,
329       // after the preselection is processed
330       ModuleBase_ModelWidget::updateObject(myFeature);
331
332       // 3. a signal should be emitted before the next widget activation
333       // because, the activation of the next widget will give a focus to the widget. As a result
334       // the value of the widget is initialized. And commit may happens until the value is entered.
335       if (aFilledWgt)
336         emit activatedByPreselection();
337     }
338     // 4. activate the next obligatory widget
339     aPropertyPanel->activateNextWidget(aFilledWgt);
340   }
341
342   clearPreselection();
343 }
344
345 void ModuleBase_OperationFeature::setParentFeature(CompositeFeaturePtr theParent)
346 {
347   myParentFeature = theParent;
348 }
349
350 CompositeFeaturePtr ModuleBase_OperationFeature::parentFeature() const
351 {
352   return myParentFeature;
353 }
354
355 void ModuleBase_OperationFeature::initSelection(ModuleBase_ISelection* theSelection,
356                                          ModuleBase_IViewer* theViewer)
357 {
358   clearPreselection();
359
360   QList<ModuleBase_ViewerPrs> aPreSelected;
361   // Check that the selected result are not results of operation feature
362   FeaturePtr aFeature = feature();
363   if (aFeature) {
364     QList<ModuleBase_ViewerPrs> aSelected = theSelection->getSelected(ModuleBase_ISelection::AllControls);
365
366     std::list<ResultPtr> aResults = aFeature->results();
367     QObjectPtrList aResList;
368     std::list<ResultPtr>::const_iterator aIt;
369     for (aIt = aResults.begin(); aIt != aResults.end(); ++aIt)
370       aResList.append(*aIt);
371
372     foreach (ModuleBase_ViewerPrs aPrs, aSelected) {
373       if ((!aResList.contains(aPrs.object())) && (aPrs.object() != aFeature))
374         aPreSelected.append(aPrs);
375     }
376   } else
377     aPreSelected = theSelection->getSelected(ModuleBase_ISelection::AllControls);
378
379   myPreSelection = aPreSelected;
380 }
381
382 void ModuleBase_OperationFeature::clearPreselection()
383 {
384   myPreSelection.clear();
385 }
386
387 void ModuleBase_OperationFeature::setPropertyPanel(ModuleBase_IPropertyPanel* theProp) 
388 {
389   ModuleBase_Operation::setPropertyPanel(theProp);
390
391   theProp->setEditingMode(isEditOperation());
392
393   if (theProp) {
394     const QList<ModuleBase_ModelWidget*>& aWidgets = theProp->modelWidgets();
395     QList<ModuleBase_ModelWidget*>::const_iterator aWIt;
396     for (aWIt = aWidgets.constBegin(); aWIt != aWidgets.constEnd(); ++aWIt) {
397       ModuleBase_ModelWidget* aWgt = (*aWIt);
398       connect(aWgt, SIGNAL(valuesChanged()), this, SLOT(onValuesChanged()));
399     }
400   }
401
402   // Do not activate widgets by default if the current operation is editing operation
403   // Because we don't know which widget is going to be edited. 
404   if (!isEditOperation()) {
405     // 4. activate the first obligatory widget
406     theProp->activateNextWidget(NULL);
407   }
408   else {
409     // set focus on Ok button in order to operation manager could process Enter press
410     if (theProp)
411       theProp->setFocusOnOkButton();
412   }
413 }