1 // Copyright (C) 2014-2019 CEA/DEN, EDF R&D
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.
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.
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
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
20 #ifndef XGUI_OperationMgr_H
21 #define XGUI_OperationMgr_H
25 #include <ModuleBase_Operation.h>
26 #include "ModelAPI_Feature.h"
30 #include <QStringList>
35 class ModuleBase_IWorkshop;
37 class XGUI_ShortCutListener;
39 /**\class XGUI_OperationMgr
41 * \brief Operation manager. Servers to manipulate to the workshop operations. Contains a stack
42 * of started operations. In simple case, if only one operation is started, the stack contains
43 * one operation. It is possible for some kind of operations to start them above already
44 * started one. In that case, the previous active operation becomes suspended, a new one - active.
45 * The new operation is added to the top of the stack. Then it is finished, it is removed from
46 * the stack and the previous operation is activated.
48 class XGUI_EXPORT XGUI_OperationMgr : public QObject
52 /// Enumeration of kind of message that is used when trying to stop the active operation
55 XGUI_AbortOperationMessage, ///< warns and give possibility to abort current operation
56 XGUI_InformationMessage ///< ask to apply the current operation before performing something
61 /// \param theParent the parent
62 /// \param theWorkshop a reference to workshop
63 XGUI_OperationMgr(QObject* theParent, ModuleBase_IWorkshop* theWorkshop);
66 virtual ~XGUI_OperationMgr();
68 /// Switch on short cut listener
70 /// Switch off short cut listener
73 /// Set reference to workshop
74 /// \param theWorkshop reference to workshop
75 void setWorkshop(ModuleBase_IWorkshop* theWorkshop)
76 { myWorkshop = theWorkshop; };
79 ModuleBase_IWorkshop* workshop() const { return myWorkshop; }
81 /// Returns the current operation or NULL
82 /// \return the current operation
83 ModuleBase_Operation* currentOperation() const;
85 /// Check if the given operation is active operation.
86 /// Also, returns false is ther is no active operation.
87 bool isCurrentOperation(ModuleBase_Operation* theOperation);
89 /// Returns true is operation manager has at least one non-null operation.
90 bool hasOperation() const;
92 /// Returns true is operation manager has an operation with given Id.
93 bool hasOperation(const QString& theId) const;
95 /// Returns true if the operation can be aborted. If the operation is modified,
96 /// the warning message box is shown.
97 /// \param theOperation an operation which is checked on stop
98 /// \param theMessageKind a kind of message in warning message box
99 bool canStopOperation(ModuleBase_Operation* theOperation,
100 const XGUI_MessageKind& theMessageKind = XGUI_AbortOperationMessage);
102 /// Find and return operation by its Id.
103 ModuleBase_Operation* findOperation(const QString& theId) const;
105 /// Returns number of operations in the stack
106 int operationsCount() const;
108 /// Returns list of all operations IDs
109 QStringList operationList() const;
111 /// Returns previous (parent) operation if given operation started.
112 /// else, or if there is no parent - returns NULL
113 ModuleBase_Operation* previousOperation(ModuleBase_Operation* theOperation) const;
115 /// Returns an active widget of the current operation.
116 /// \return widget or NULL
117 ModuleBase_ModelWidget* activeWidget() const;
119 /// Start the operation and append it to the stack of operations
120 /// \param theOperation the started operation
121 /// \return the state whether the current operation is started
122 bool startOperation(ModuleBase_Operation* theOperation);
124 /// Returns whether the operation can be started. Check if there is already started operation and
125 /// the granted parameter of the launched operation
126 /// \param theId id of the operation which is going to start
127 /// \param isCommitted boolean value if the operation was committed otherwise it was aborted
128 bool canStartOperation(const QString& theId, bool& isCommitted);
130 /// If Apply is enabled and operation has modification, it is applyed, otherwise aborted
131 /// \param theOperation the started operation
132 /// \param isCommitted boolean value if the operation was committed otherwise it was aborted
133 void stopOperation(ModuleBase_Operation* theOperation, bool& isCommitted);
135 /// Aborts the parameter operation if it is current, else abort operations from the stack
136 /// of operations until the operation is found. All operations upper the parameter one are
138 /// \param theOperation an aborted operation
139 void abortOperation(ModuleBase_Operation* theOperation);
141 /// Abort all operations
142 /// \param theMessageKind kind of shown warning message
143 bool abortAllOperations(const XGUI_MessageKind& theMessageKind = XGUI_AbortOperationMessage);
145 /// Commits the current operation.
146 bool commitOperation();
148 /// Returns true if SHIFT is pressed
149 /// \param thePressed new boolean state
150 void setSHIFTPressed(const bool thePressed) { mySHIFTPressed = thePressed; }
152 /// Returns true if SHIFT is pressed
153 /// \return boolean value
154 bool hasSHIFTPressed() const { return mySHIFTPressed; }
157 /// Slot that aborts the current operation.
158 void onAbortOperation();
159 /// Slot that aborts all operations. It shows aborting message
160 void onAbortAllOperation();
161 /// Slot that validates the current operation using the validateOperation method.
162 void onValidateOperation();
163 /// Commit all operations
164 bool commitAllOperations();
167 /// Signal about an operation is stopped. It is emitted after the stop() of operation is done.
168 /// \param theOperation a stopped operation
169 void operationStopped(ModuleBase_Operation* theOperation);
171 /// Signal about an operation is resumed. It is emitted after the resume() of operation is done.
172 void operationResumed(ModuleBase_Operation* theOperation);
174 /// Emitted when current operation is Committed
175 void operationCommitted(ModuleBase_Operation* theOperation);
177 /// Emitted when current operation is aborted
178 void operationAborted(ModuleBase_Operation* theOperation);
180 /// Signal is emitted after the key released click.
181 void keyEnterReleased();
183 public: // TEMPORARY, it should be protected and be performed automatically
184 /// Emits nestedStateChange for operations with an information about validity of the operation
185 /// \param theOperation the sent operation. If it is NULL, all operations in the stack are sent.
186 void updateApplyOfOperations(ModuleBase_Operation* theOperation = 0);
188 protected: // TEMPORARY
189 /// Sets the current operation or NULL
190 /// \param theOperation the started operation
191 void resumeOperation(ModuleBase_Operation* theOperation);
193 /// Returns whether the parameter operation is granted in relation to the previous operation
194 /// in a stack of started operations. It is used in canStopOperation to avoid warning message
195 /// when granted operation is aborted, e.g. SketchLine in Sketch
196 /// \param theId id of the operation which is checked
197 /// \return boolean result
198 bool isGrantedOperation(const QString& theId);
200 /// Sets the feature as a current in the document
201 /// \param theFeature a feature
202 void setCurrentFeature(const FeaturePtr& theFeature);
205 /// SLOT, that is called by the key in the property panel is clicked.
206 /// \param theObject a sender of the event
207 /// \param theEvent the mouse event
208 bool onKeyReleased(QObject *theObject, QKeyEvent* theEvent);
210 /// SLOT, that is called by the key in the property panel is clicked.
211 /// \param theObject a sender of the event
212 /// \param theEvent the mouse event
213 bool onKeyPressed(QObject *theObject, QKeyEvent* theEvent);
215 /// The functionaly, that should be done by delete click
216 /// Fistly the active widget processes it, then workshop. If no one does not
217 /// process it, do nothing
218 /// \param theObject a sender of the event
219 bool onProcessDelete(QObject* theObject);
222 /// The functionaly, that should be done by enter click
223 /// Fistly the active widget processes it, then module. If no one does not
224 /// process it, the current operation is committed
225 /// \param theObject a sender of the event
226 bool onProcessEnter(QObject *theObject);
228 /// Slot that is called by an operation stop. Removes the stopped operation form the stack.
229 /// If there is a suspended operation, restart it.
230 void onOperationStopped();
232 /// Slot called before operation started. Stores the previous current feature, set the feature
233 /// of the operation as a current in the document. The previous current feature should be restored
234 /// by the operation abort/commit
235 void onBeforeOperationStarted();
237 /// Slot called after operation started
238 void onOperationStarted();
240 /// Slot called before operation aborted. Restore the previous current operation
241 void onBeforeOperationAborted();
243 /// Slot called after operation aborted
244 void onOperationAborted();
246 /// Slot called before operation committed. Restore the previous current operation
247 void onBeforeOperationCommitted();
249 /// Slot called after operation committed
250 void onOperationCommitted();
252 /// Slot called on operation resume
253 void onOperationResumed();
256 /// Checks if the object is a parent or a child under
257 /// \param theObject an investivated object
258 /// \param theParent a candidate to be a parent
259 static bool isChildObject(const QObject* theObject, const QObject* theParent);
261 /// Creates question message box with OK/Cancel buttons, where Cancel is default button,
262 /// Escape is Null button
263 /// \param theMessage text of the message
264 /// \return message box
265 static QMessageBox* createMessageBox(const QString& theMessage);
267 /// Creates information message box with OK button,
268 /// Escape is Null button
269 /// \param theMessage text of the message
270 /// \return message box
271 static QMessageBox* createInformationBox(const QString& theMessage);
274 typedef QList<ModuleBase_Operation*> Operations; ///< definition for a list of operations
275 Operations myOperations; ///< a stack of started operations. The active operation is on top,
276 // others are suspended and started by the active is finished
279 ModuleBase_IWorkshop* myWorkshop;
280 QMessageBox* myActiveMessageBox;
281 XGUI_ShortCutListener* myShortCutListener;