]> SALOME platform Git repositories - modules/shaper.git/blob - src/XGUI/XGUI_OperationMgr.h
Salome HOME
A correction to check modified value in extrusion cut/sketch/etc operations.
[modules/shaper.git] / src / XGUI / XGUI_OperationMgr.h
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 #ifndef XGUI_OperationMgr_H
8 #define XGUI_OperationMgr_H
9
10 #include "XGUI.h"
11
12 #include <ModuleBase_Operation.h>
13 #include "ModelAPI_Feature.h"
14
15 #include <QList>
16 #include <QObject>
17 #include <QStringList>
18
19 class QKeyEvent;
20
21 class ModuleBase_IWorkshop;
22 class XGUI_Workshop;
23
24 /**\class XGUI_OperationMgr
25  * \ingroup GUI
26  * \brief Operation manager. Servers to manipulate to the workshop operations. Contains a stack
27  * of started operations. In simple case, if only one operation is started, the stack contains
28  * one operation. It is possible for some kind of operations to start them above already
29  * started one. In that case, the previous active operation becomes suspended, a new one - active.
30  * The new operation is added to the top of the stack. Then it is finished, it is removed from
31  * the stack and the previous operation is activated.
32  */
33 class XGUI_EXPORT XGUI_OperationMgr : public QObject
34 {
35 Q_OBJECT
36  public:
37   /// Constructor
38   /// \param theParent the parent
39   /// \param theWorkshop a reference to workshop
40   XGUI_OperationMgr(QObject* theParent, ModuleBase_IWorkshop* theWorkshop);
41
42   /// Destructor
43   virtual ~XGUI_OperationMgr();
44
45   /// Set reference to workshop
46   /// \param theWorkshop reference to workshop
47   void setWorkshop(ModuleBase_IWorkshop* theWorkshop)
48   { myWorkshop = theWorkshop; };
49
50   /// Returns the current operation or NULL
51   /// \return the current operation
52   ModuleBase_Operation* currentOperation() const;
53
54   /// Check if the given operation is active operation.
55   /// Also, returns false is ther is no active operation.
56   bool isCurrentOperation(ModuleBase_Operation* theOperation);
57
58   /// Returns true is operation manager has at least one non-null operation.
59   bool hasOperation() const;
60
61   /// Returns true is operation manager has an operation with given Id.
62   bool hasOperation(const QString& theId) const;
63
64   /// Returns true if the operation can be aborted. If the operation is modified,
65   /// the warning message box is shown.
66   /// \param theOperation an operation which is checked on stop
67   bool canStopOperation(ModuleBase_Operation* theOperation);
68
69   /// Find and return operation by its Id.
70   ModuleBase_Operation* findOperation(const QString& theId) const;
71
72   /// Returns number of operations in the stack
73   int operationsCount() const;
74
75   /// Returns list of all operations IDs
76   QStringList operationList() const;
77
78   /// Returns previous (parent) operation if given operation started.
79   /// else, or if there is no parent - returns NULL
80   ModuleBase_Operation* previousOperation(ModuleBase_Operation* theOperation) const;
81
82   /// Redefinition of virtual function
83   virtual bool eventFilter(QObject *theObject, QEvent *theEvent);
84
85   /// Start the operation and append it to the stack of operations
86   /// \param theOperation the started operation
87   /// \return the state whether the current operation is started
88   bool startOperation(ModuleBase_Operation* theOperation);
89
90   /// Returns whether the operation can be started. Check if there is already started operation and
91   /// the granted parameter of the launched operation
92   /// \param theId id of the operation which is going to start
93   bool canStartOperation(const QString& theId);
94
95   /// Aborts the parameter operation if it is current, else abort operations from the stack
96   /// of operations until the operation is found. All operations upper the parameter one are
97   /// not aborted.
98   /// \param theOperation an aborted operation
99   void abortOperation(ModuleBase_Operation* theOperation);
100
101   /// Returns enable apply state 
102   /// \return theEnabled a boolean value
103   bool isApplyEnabled() const;
104
105   /// Returns valid state of the parent operation. If the current operation is the last one
106   /// it returns the valid state of the operation
107   /// \return boolean value
108   bool isParentOperationValid() const;
109
110 public slots:
111   /// Slot that commits the current operation.
112   void onCommitOperation();
113   /// Slot that aborts the current operation.
114   void onAbortOperation();
115   /// Slot that validates the current operation using the validateOperation method.
116   void onValidateOperation();
117   /// Commit all operations
118   bool commitAllOperations();
119   /// Abort all operations
120   bool abortAllOperations();
121
122 signals:
123   /// Signal about an operation is started. It is emitted after the start() of operation is done.
124   void operationStarted(ModuleBase_Operation* theOperation);
125
126   /// Signal about an operation is stopped. It is emitted after the stop() of operation is done.
127   /// \param theOperation a stopped operation
128   void operationStopped(ModuleBase_Operation* theOperation);
129
130   /// Signal about an operation is resumed. It is emitted after the resume() of operation is done.
131   void operationResumed(ModuleBase_Operation* theOperation);
132
133   /// Emitted when current operation is Committed
134   void operationCommitted(ModuleBase_Operation* theOperation);
135
136   /// Emitted when current operation is aborted
137   void operationAborted(ModuleBase_Operation* theOperation);
138
139   /// Signal is emitted after the current operation is filled with existing preselection.
140   void operationActivatedByPreselection();
141
142   /// Signal is emitted after the key released click.
143   void keyEnterReleased();
144
145  protected:
146   /// Sets apply state to the value and emit signal about this state is changed
147   /// \param theEnabled the state value
148   void setApplyEnabled(const bool theEnabled);
149
150 public: // TEMPORARY, it should be protected and be performed automatically
151   /// Emits nestedStateChange for operations with an information about validity of the operation
152   /// \param theOperation the sent operation. If it is NULL, all operations in the stack are sent.
153   void updateApplyOfOperations(ModuleBase_Operation* theOperation = 0);
154
155   /// Commits the current operatin if it is valid
156   bool commitOperation();
157
158 protected: // TEMPORARY
159   /// Sets the current operation or NULL
160   /// \param theOperation the started operation
161   void resumeOperation(ModuleBase_Operation* theOperation);
162
163   /// Returns whether the parameter operation is granted in relation to the previous operation
164   /// in a stack of started operations. It is used in canStopOperation to avoid warning message
165   /// when granted operation is aborted, e.g. SketchLine in Sketch
166   /// \param theId id of the operation which is checked
167   /// \return boolean result
168   bool isGrantedOperation(const QString& theId);
169
170   /// Sets the feature as a current in the document
171   /// \param theFeature a feature
172   void setCurrentFeature(const FeaturePtr& theFeature);
173
174  public slots:
175   /// SLOT, that is called by the key in the property panel is clicked.
176   /// \param theEvent the mouse event
177   bool onKeyReleased(QKeyEvent* theEvent);
178
179   protected slots:
180   /// Slot that is called by an operation stop. Removes the stopped operation form the stack.
181   /// If there is a suspended operation, restart it.
182   void onOperationStopped();
183
184   /// Slot called before operation started. Stores the previous current feature, set the feature
185   /// of the operation as a current in the document. The previous current feature should be restored
186   /// by the operation abort/commit
187   void onBeforeOperationStarted();
188
189   /// Slot called after operation started
190   void onOperationStarted();
191
192   /// Slot called before operation aborted. Restore the previous current operation
193   void onBeforeOperationAborted();
194
195   /// Slot called after operation aborted
196   void onOperationAborted();
197
198   /// Slot called before operation committed. Restore the previous current operation
199   void onBeforeOperationCommitted();
200
201   /// Slot called after operation committed
202   void onOperationCommitted();
203
204   /// Slot called on operation resume
205   void onOperationResumed();
206
207 private:
208   XGUI_Workshop* workshop() const;
209
210  private:
211   typedef QList<ModuleBase_Operation*> Operations;  ///< definition for a list of operations
212   Operations myOperations;  ///< a stack of started operations. The active operation is on top,
213                             // others are suspended and started by the active is finished
214
215   /// Current workshop
216   ModuleBase_IWorkshop* myWorkshop;
217
218   /// Lock/Unlock access to Ok button in property panel
219   bool myIsApplyEnabled;
220 };
221
222 #endif