]> SALOME platform Git repositories - modules/shaper.git/blob - src/XGUI/XGUI_OperationMgr.cpp
Salome HOME
85892d74b037a2c269a69028b060feadd5e1eaee
[modules/shaper.git] / src / XGUI / XGUI_OperationMgr.cpp
1 // Copyright (C) 2014-20xx CEA/DEN, EDF R&D -->
2
3 // File:        XGUI_OperationMgr.h
4 // Created:     20 Apr 2014
5 // Author:      Natalia ERMOLAEVA
6
7 #include "XGUI_OperationMgr.h"
8
9 #include "ModuleBase_Operation.h"
10 #include "ModuleBase_IWorkshop.h"
11 #include "ModuleBase_IModule.h"
12
13 #include "ModelAPI_CompositeFeature.h"
14 #include "ModelAPI_Session.h"
15
16 #include <QMessageBox>
17 #include <QApplication>
18 #include <QKeyEvent>
19
20 XGUI_OperationMgr::XGUI_OperationMgr(QObject* theParent,
21                                      ModuleBase_IWorkshop* theWorkshop)
22 : QObject(theParent), myIsValidationLock(false), myIsApplyEnabled(false),
23   myWorkshop(theWorkshop)
24 {
25 }
26
27 XGUI_OperationMgr::~XGUI_OperationMgr()
28 {
29 }
30
31 ModuleBase_Operation* XGUI_OperationMgr::currentOperation() const
32 {
33   return myOperations.count() > 0 ? myOperations.last() : 0;
34 }
35
36 bool XGUI_OperationMgr::isCurrentOperation(ModuleBase_Operation* theOperation)
37 {
38   if(!hasOperation())
39     return false;
40   return currentOperation() == theOperation;
41 }
42
43 bool XGUI_OperationMgr::hasOperation() const
44 {
45   return !myOperations.isEmpty() && (myOperations.last() != NULL);
46 }
47
48 bool XGUI_OperationMgr::hasOperation(const QString& theId) const
49 {
50   foreach(ModuleBase_Operation* aOp, myOperations) {
51     if (aOp->id() == theId)
52       return true;
53   }
54   return false;
55 }
56
57 ModuleBase_Operation* XGUI_OperationMgr::findOperation(const QString& theId) const
58 {
59   foreach(ModuleBase_Operation* aOp, myOperations) {
60     if (aOp->id() == theId)
61       return aOp;
62   }
63   return 0;
64 }
65
66
67 int XGUI_OperationMgr::operationsCount() const
68 {
69   return myOperations.count();
70 }
71
72 QStringList XGUI_OperationMgr::operationList() const
73 {
74   QStringList result;
75   foreach(ModuleBase_Operation* eachOperation, myOperations) {
76     FeaturePtr aFeature = eachOperation->feature();
77     if(aFeature) {
78       result << QString::fromStdString(aFeature->getKind());
79     }
80   }
81   return result;
82 }
83
84 ModuleBase_Operation* XGUI_OperationMgr::previousOperation(ModuleBase_Operation* theOperation) const
85 {
86   int idx = myOperations.lastIndexOf(theOperation);
87   if(idx == -1 || idx == 0) {
88     return NULL;
89   }
90   return myOperations.at(idx - 1);
91 }
92
93 bool XGUI_OperationMgr::eventFilter(QObject *theObject, QEvent *theEvent)
94 {
95   if (theEvent->type() == QEvent::KeyRelease) {
96     QKeyEvent* aKeyEvent = dynamic_cast<QKeyEvent*>(theEvent);
97     if(aKeyEvent) {
98       return onKeyReleased(aKeyEvent);
99     }
100   }
101   return QObject::eventFilter(theObject, theEvent);
102 }
103
104 bool XGUI_OperationMgr::startOperation(ModuleBase_Operation* theOperation)
105 {
106   if (hasOperation())
107     currentOperation()->postpone();
108   myOperations.append(theOperation);
109
110   connect(theOperation, SIGNAL(started()), SLOT(onOperationStarted()));
111   connect(theOperation, SIGNAL(aborted()), SLOT(onOperationAborted()));
112   connect(theOperation, SIGNAL(committed()), SLOT(onOperationCommitted()));
113   connect(theOperation, SIGNAL(stopped()), SLOT(onOperationStopped()));
114   connect(theOperation, SIGNAL(resumed()), SLOT(onOperationResumed()));
115   connect(theOperation, SIGNAL(triggered(bool)), SLOT(onOperationTriggered(bool)));
116   connect(theOperation, SIGNAL(activatedByPreselection()),
117           SIGNAL(operationActivatedByPreselection()));
118
119   theOperation->start();
120   onValidateOperation();
121   return true;
122 }
123
124 bool XGUI_OperationMgr::abortAllOperations()
125 {
126   if(!hasOperation()) {
127     return true;
128   } else if (operationsCount() == 1) {
129     onAbortOperation();
130     return true;
131   }
132   QString aMessage = tr("All active operations will be aborted.");
133   int anAnswer = QMessageBox::question(qApp->activeWindow(),
134                                        tr("Abort operation"),
135                                        aMessage,
136                                        QMessageBox::Ok | QMessageBox::Cancel,
137                                        QMessageBox::Cancel);
138   bool result = anAnswer == QMessageBox::Ok;
139   while(result && hasOperation()) {
140     currentOperation()->abort();
141   }
142   return result;
143 }
144
145 bool XGUI_OperationMgr::commitAllOperations()
146 {
147   bool isCompositeCommitted = false;
148   while (hasOperation()) {
149     ModuleBase_Operation* anOperation = currentOperation();
150     if (isApplyEnabled()) {
151       onCommitOperation();
152     } else {
153       anOperation->abort();
154     }
155     FeaturePtr aFeature = anOperation->feature();
156     CompositeFeaturePtr aComposite = 
157         std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(aFeature);
158     isCompositeCommitted = aComposite.get();
159     if (isCompositeCommitted)
160       break;
161   }
162   return true;
163 }
164
165 void XGUI_OperationMgr::onValidateOperation()
166 {
167   if (!hasOperation())
168     return;
169   ModuleBase_Operation* anOperation = currentOperation();
170   if(anOperation) {
171     bool aCanCommit = myWorkshop->module()->canCommitOperation();
172     setApplyEnabled(!myIsValidationLock && aCanCommit && anOperation->isValid());
173   }
174 }
175
176 void XGUI_OperationMgr::setLockValidating(bool toLock)
177 {
178   myIsValidationLock = toLock;
179   onValidateOperation();
180 }
181
182 void XGUI_OperationMgr::setApplyEnabled(const bool theEnabled)
183 {
184   myIsApplyEnabled = theEnabled;
185   emit validationStateChanged(theEnabled);
186 }
187
188 bool XGUI_OperationMgr::isApplyEnabled() const
189 {
190   return myIsApplyEnabled;
191 }
192
193 bool XGUI_OperationMgr::isParentOperationValid() const
194 {
195   bool isValid = false;
196   // the enable state of the parent operation of the nested one is defined by the rules that
197   // firstly there are nested operations and secondly the parent operation is valid
198   ModuleBase_Operation* aPrevOp = 0;
199   Operations::const_iterator anIt = myOperations.end();
200   if (anIt != myOperations.begin()) { // there are items in the operations list
201     --anIt;
202     aPrevOp = *anIt; // the last top operation, the operation which is started
203     if (anIt != myOperations.begin()) { // find the operation where the started operation is nested
204       --anIt;
205       aPrevOp = *anIt;
206     }
207   }
208   return aPrevOp && aPrevOp->isValid();
209 }
210
211 bool XGUI_OperationMgr::canStopOperation()
212 {
213   ModuleBase_Operation* anOperation = currentOperation();
214   if(operationsCount() > 1) //in case of nested (sketch) operation no confirmation needed
215     return true;
216   if (anOperation && anOperation->isModified()) {
217     QString aMessage = tr("%1 operation will be aborted.").arg(anOperation->id());
218     int anAnswer = QMessageBox::question(qApp->activeWindow(),
219                                          tr("Abort operation"),
220                                          aMessage,
221                                          QMessageBox::Ok | QMessageBox::Cancel,
222                                          QMessageBox::Cancel);
223     return anAnswer == QMessageBox::Ok;
224   }
225   return true;
226 }
227
228 bool XGUI_OperationMgr::commitOperation()
229 {
230   if (hasOperation() && currentOperation()->isValid()) {
231     onCommitOperation();
232     return true;
233   }
234   return false;
235 }
236
237 void XGUI_OperationMgr::resumeOperation(ModuleBase_Operation* theOperation)
238 {
239   theOperation->resume();
240 }
241
242 bool XGUI_OperationMgr::canStartOperation(QString theId)
243 {
244   bool aCanStart = true;
245   ModuleBase_Operation* aCurrentOp = currentOperation();
246   if (aCurrentOp) {
247     if (!aCurrentOp->isGranted(theId)) {
248       if (canStopOperation()) {
249         if (myIsApplyEnabled)
250           aCurrentOp->commit();
251         else
252           aCurrentOp->abort();
253       } else {
254         aCanStart = false;
255       }
256     }
257   }
258   return aCanStart;
259 }
260
261
262 void XGUI_OperationMgr::onCommitOperation()
263 {
264   ModuleBase_Operation* anOperation = currentOperation();
265   if (anOperation)
266     anOperation->commit();
267 }
268
269 void XGUI_OperationMgr::onAbortOperation()
270 {
271   if (hasOperation() && canStopOperation()) {
272     currentOperation()->abort();
273   }
274 }
275
276 void XGUI_OperationMgr::onOperationStarted()
277 {
278   ModuleBase_Operation* aSenderOperation = dynamic_cast<ModuleBase_Operation*>(sender());
279   
280   bool aParentValid = isParentOperationValid();
281   // in order to apply is enabled only if there are modifications in the model
282   // e.g. sketch can be applyed only if at least one nested element modification is finished
283   bool aCanUndo = ModelAPI_Session::get()->canUndo();
284   emit nestedStateChanged(aParentValid && aCanUndo);
285
286   emit operationStarted(aSenderOperation);
287 }
288
289 void XGUI_OperationMgr::onOperationAborted()
290 {
291   ModuleBase_Operation* aSenderOperation = dynamic_cast<ModuleBase_Operation*>(sender());
292   emit operationAborted(aSenderOperation);
293 }
294
295 void XGUI_OperationMgr::onOperationCommitted()
296 {
297   ModuleBase_Operation* aSenderOperation = dynamic_cast<ModuleBase_Operation*>(sender());
298   // in order to apply is enabled only if there are modifications in the model
299   // e.g. sketch can be applyed only if at least one nested element create is finished
300   bool aCanUndo = ModelAPI_Session::get()->canUndo();
301   emit nestedStateChanged(myOperations.count() >= 1 && aCanUndo);
302   emit operationCommitted(aSenderOperation);
303 }
304
305 void XGUI_OperationMgr::onOperationResumed()
306 {
307   ModuleBase_Operation* aSenderOperation = dynamic_cast<ModuleBase_Operation*>(sender());
308   emit operationResumed(aSenderOperation);
309 }
310
311 void XGUI_OperationMgr::onOperationStopped()
312 {
313   ModuleBase_Operation* aSenderOperation = dynamic_cast<ModuleBase_Operation*>(sender());
314   ModuleBase_Operation* aCurrentOperation = currentOperation();
315   if (!aSenderOperation || !aCurrentOperation || aSenderOperation != aCurrentOperation)
316     return;
317
318   myOperations.removeAll(aCurrentOperation);
319   aCurrentOperation->deleteLater();
320
321   emit operationStopped(aCurrentOperation);
322
323   // get last operation which can be resumed
324   ModuleBase_Operation* aResultOp = 0;
325   QListIterator<ModuleBase_Operation*> anIt(myOperations);
326   anIt.toBack();
327   while (anIt.hasPrevious()) {
328     ModuleBase_Operation* anOp = anIt.previous();
329     if (anOp) {
330       aResultOp = anOp;
331       break;
332     }
333   }
334   if (aResultOp) {
335     bool isModified = aCurrentOperation->isModified();
336     aResultOp->setIsModified(isModified);
337     resumeOperation(aResultOp);
338     onValidateOperation();
339   }
340 }
341
342 void XGUI_OperationMgr::onOperationTriggered(bool theState)
343 {
344   ModuleBase_Operation* aSenderOperation = dynamic_cast<ModuleBase_Operation*>(sender());
345   if (aSenderOperation && !theState) {
346     ModuleBase_Operation* aCurrentOperation = currentOperation();
347     if (aSenderOperation == aCurrentOperation)
348       aCurrentOperation->abort();
349     else {
350       // it is possible to trigger upper operation(e.g. sketch, current is sketch line)
351       // all operation from the current to triggered should also be aborted
352       while(hasOperation()) {
353         ModuleBase_Operation* aCurrentOperation = currentOperation();
354         aCurrentOperation->abort();
355         if(aSenderOperation == aCurrentOperation)
356           break;
357       }
358     }
359   }
360 }
361
362 bool XGUI_OperationMgr::onKeyReleased(QKeyEvent* theEvent)
363 {
364   // Let the manager decide what to do with the given key combination.
365   ModuleBase_Operation* anOperation = currentOperation();
366   bool isAccepted = true;
367   switch (theEvent->key()) {
368     case Qt::Key_Return:
369     case Qt::Key_Enter: {
370       emit keyEnterReleased();
371       commitOperation();
372     }
373     break;
374     default:
375       isAccepted = false;
376       break;
377   }
378   //if(anOperation) {
379   //  anOperation->keyReleased(theEvent->key());
380   //}
381   return isAccepted;
382 }
383