]> SALOME platform Git repositories - modules/shaper.git/blob - src/XGUI/XGUI_Workshop.h
Salome HOME
Issue #1015: The validate icon must be greyed and inactive instead of red and active
[modules/shaper.git] / src / XGUI / XGUI_Workshop.h
1 // Copyright (C) 2014-20xx CEA/DEN, EDF R&D -->
2
3 #ifndef XGUI_WORKSHOP_H
4 #define XGUI_WORKSHOP_H
5
6 #include "XGUI.h"
7 //#include "XGUI_Constants.h"
8 #include <ModuleBase_Definitions.h>
9 #include <ModelAPI_Document.h>
10 #include <ModelAPI_Feature.h>
11
12 #include <ModuleBase_ActionInfo.h>
13
14 #include <QObject>
15 #include <QMap>
16 #include <QKeySequence>
17 #include <QIcon>
18
19 #ifndef HAVE_SALOME
20 class AppElements_MainWindow;
21 class AppElements_Command;
22 class AppElements_Workbench;
23 #endif
24
25 class XGUI_ActionsMgr;
26 class XGUI_ContextMenuMgr;
27 class XGUI_Displayer;
28 class XGUI_ErrorDialog;
29 class XGUI_ErrorMgr;
30 class XGUI_MenuMgr;
31 class XGUI_ModuleConnector;
32 class XGUI_ObjectsBrowser;
33 class XGUI_OperationMgr;
34 class XGUI_PropertyPanel;
35 class XGUI_SalomeConnector;
36 class XGUI_SalomeViewer;
37 class XGUI_SelectionMgr;
38 class XGUI_ViewerProxy;
39 class XGUI_WorkshopListener;
40
41 class ModuleBase_IModule;
42 class ModuleBase_IViewer;
43 class ModuleBase_Operation;
44
45 class QWidget;
46 class QDockWidget;
47 class QMainWindow;
48
49 class QAction;
50 class Config_DataModelReader;
51
52 /**\class XGUI_Workshop
53  * \ingroup GUI
54  * \brief Class which defines a configuration of the application (Workshop) and launches it.
55  */
56 class XGUI_EXPORT XGUI_Workshop : public QObject
57 {
58 Q_OBJECT
59  public:
60   /// Constructor
61   /// \param theConnector a Salome connector object. 
62   /// Used only if the workshop is launched in Salome environment
63   XGUI_Workshop(XGUI_SalomeConnector* theConnector = 0);
64   virtual ~XGUI_Workshop();
65
66   //! Starting of the application
67   void startApplication();
68
69   /// Activates the module controls. Should be called after module creation
70   void activateModule();
71
72   /// Deactivates the module controls. Should be called after module creation
73   void deactivateModule();
74
75 #ifndef HAVE_SALOME
76   //! Returns main window (Desktop) of the application
77   AppElements_MainWindow* mainWindow() const
78   {
79     return myMainWindow;
80   }
81
82   //! Creates and adds a new workbench (menu group) with the given name and returns it
83   AppElements_Workbench* addWorkbench(const QString& theName);
84 #endif
85
86   //! Returns selection manager object
87   XGUI_SelectionMgr* selector() const
88   {
89     return mySelector;
90   }
91
92   //! Returns displayer
93   XGUI_Displayer* displayer() const
94   {
95     return myDisplayer;
96   }
97
98   //! ! Returns operation manager.
99   XGUI_OperationMgr* operationMgr() const
100   {
101     return myOperationMgr;
102   }
103
104   //! ! Returns error manager.
105   XGUI_ErrorMgr* errorMgr() const
106   {
107     return myErrorMgr;
108   }
109
110   //! ! Returns an actions manager
111   XGUI_ActionsMgr* actionsMgr() const
112   {
113     return myActionsMgr;
114   }
115
116   //! ! Returns an actions manager
117   XGUI_MenuMgr* menuMgr() const
118   {
119     return myMenuMgr;
120   }
121
122   //! Returns property panel widget
123   XGUI_PropertyPanel* propertyPanel() const
124   {
125     return myPropertyPanel;
126   }
127
128   //! Returns context menu manager object
129   XGUI_ContextMenuMgr* contextMenuMgr() const
130   {
131     return myContextMenuMgr;
132   }
133
134   //! Returns an object which provides interface to Salome Module (LightApp_Module)
135   XGUI_SalomeConnector* salomeConnector() const
136   {
137     return mySalomeConnector;
138   }
139
140   //! Provides an object which provides interface to Salome Viewer
141   ModuleBase_IViewer* salomeViewer() const;
142
143   //! Returns true if the application works as SALOME module
144   bool isSalomeMode() const
145   {
146     return mySalomeConnector != 0;
147   }
148
149   //! Returns Object browser
150   XGUI_ObjectsBrowser* objectBrowser() const
151   {
152     return myObjectBrowser;
153   }
154
155   /// This method is called by Salome module when selection is changed
156   void salomeViewerSelectionChanged();
157
158   /// Returns viewer which unifies access as to Salome viewer as to standalone viewer
159   XGUI_ViewerProxy* viewer() const
160   {
161     return myViewerProxy;
162   }
163
164   /// Returns the module connector
165   /// \returns the instance of connector
166   XGUI_ModuleConnector* moduleConnector() const
167   {
168     return myModuleConnector;
169   }
170
171   /// Returns a desktop
172   /// \return a desktop instance
173   QMainWindow* desktop() const;
174
175   //! Delete features
176   void deleteObjects();
177
178   //! Searches for selected features unused in other (not selected) features. If one or several
179   //! selected features are found, a warning message proposes to delete them. It contains 
180   //! the list of features to be deleted.
181   void cleanHistory();
182
183   //! Returns true if the selected feature can be moved to the position after the current feature
184   //! \return boolean value
185   bool canMoveFeature();
186
187   //! Move selected features to be after the current feature
188   void moveObjects();
189
190   //! Returns true if the object can be shaded. If the object is a compsolid result, the method
191   //! checks subobjects of the result
192   //! \return boolean value
193   bool canBeShaded(const ObjectPtr& theObject) const;
194
195   //! Returns true if there is at least one selected body/construction/group result
196   //! \return boolean value
197   bool canChangeColor() const;
198
199   //! Change color of the features if it is possible
200   //! The operation is available for construction, body and group results
201   //! theObjects a list of selected objects
202   void changeColor(const QObjectPtrList& theObjects);
203
204   //! Show the given features in 3d Viewer
205   void showObjects(const QObjectPtrList& theList, bool isVisible);
206
207   //! Show the given features in 3d Viewer
208   void showOnlyObjects(const QObjectPtrList& theList);
209
210   /// Set display mode for the given objects
211   /// \param theList a list of displayed objects
212   /// \param theMode a mode to set (see \ref XGUI_Displayer)
213   void setDisplayMode(const QObjectPtrList& theList, int theMode);
214
215   /// Set selection mode in viewer. If theMode=-1 then activate default mode
216   /// \param theMode the selection mode (according to TopAbs_ShapeEnum)
217   void setViewerSelectionMode(int theMode);
218
219   /// Activates current selection mode for the given list of objects
220   void activateObjectsSelection(const QObjectPtrList& theList);
221
222   /// Returns current module
223   ModuleBase_IModule* module() const
224   {
225     return myModule;
226   }
227
228   /// Returns current directory which contains data files
229   QString currentDataDir() const { return myCurrentDir; }
230
231   /// Returns current directory which contains data files
232   void setCurrentDataDir(const QString& theDir) { myCurrentDir = theDir; }
233
234   /**
235   * Save the current document into a directory
236   * \param theName - path to the directory
237   * \param theFileNames - returned file names created in this directory
238   */
239   void saveDocument(const QString& theName, std::list<std::string>& theFileNames);
240
241   /**
242    * If there is an active (uncommitted) operation shows a prompt to abort it
243    * and performs abortion if user agreed. Returns true if
244    * - operation aborted successfully
245    * - there is no active operation
246    */
247   bool abortAllOperations();
248
249   //! Delete features. Delete the referenced features. There can be a question with a list of
250   //! referenced objects.
251   //! \param theFeatures a list of objects to be deleted
252   bool deleteFeatures(const QObjectPtrList& theFeatures);
253
254   /// Deactivates the object, if it is active and the module returns that the activation
255   /// of selection for the object is not possible currently(the current operation uses it)
256   /// \param theObject an object
257   /// \param theUpdateViewer a boolean flag to update viewer immediately
258   void deactivateActiveObject(const ObjectPtr& theObject, const bool theUpdateViewer);
259
260   /// Returns true if the action of the feature is created to contain Accept/Cancel button
261   /// \param theFeature a feature
262   bool isFeatureOfNested(const FeaturePtr& theFeature);
263
264   //! Shows the message in the status bar
265   //! \param theMessage a message
266   void setStatusBarMessage(const QString& theMessage);
267
268   /// Has to be called in order to display objects with visibility status = true
269   void synchronizeViewer();
270
271   /// Has to be called in order to display objects from a cpecifed group with visibility status = true
272   /// \param theDoc the document for objects synchronisation
273   /// \param theGroup the group name
274   /// \param theUpdateViewer update viewer flag
275   void synchronizeGroupInViewer(const DocumentPtr& theDoc, const std::string& theGroup, bool theUpdateViewer);
276
277   /// Update the property panel content by the XML description of the operation and set the panel
278   /// into the operation
279   /// \param theOperation an operation
280   void setPropertyPanel(ModuleBase_Operation* theOperation);
281
282   /// Connects or disconnects to the value changed signal of the property panel widgets
283   /// \param isToConnect a boolean value whether connect or disconnect
284   void connectToPropertyPanel(const bool isToConnect);
285
286   /// Returns defailt selection mode in 3d viewer
287   QIntList viewerSelectionModes() const { return myViewerSelMode; }
288
289   /// Highlights result objects in Object Browser according to
290   /// features found in the given list
291   void highlightResults(const QObjectPtrList& theObjects);
292
293   /// Highlights feature objects in Object Browser according to
294   /// features found in the given list
295   void highlightFeature(const QObjectPtrList& theObjects);
296
297   /// Returns Data Model XML reader which contains information about 
298   /// Data structure configuration
299   const Config_DataModelReader* dataModelXMLReader() const { return myDataModelXMLReader; }
300
301   /// A constant string used for "Move to end" command definition
302   /// It is used for specific processing of Undo/Redo for this command.
303   static QString MOVE_TO_END_COMMAND;
304
305 signals:
306   /// Emitted when selection happens in Salome viewer
307   void salomeViewerSelection();
308
309   /// Emitted when error in application happens
310   void errorOccurred(const QString&);
311
312   //! the signal about the workshop actions states are updated.
313   void commandStatusUpdated();
314
315   //! the application is started
316   void applicationStarted();
317
318   //! Signal to update Undo history list
319   void updateUndoHistory(const QList<ActionInfo>&);
320
321   //! Signal to update Redo history list
322   void updateRedoHistory(const QList<ActionInfo>&);
323
324  public slots:
325    /// Update of commands status
326   void updateCommandStatus();
327
328   /// update history list (undo/redo commands)
329   void updateHistory();
330
331   /// Save current document
332   bool onSave();
333
334   /// Save current document to a file selected by user
335   bool onSaveAs();
336
337   /// Undo last command
338   void onUndo(int times = 1);
339
340   /// Redo previous command
341   void onRedo(int times = 1);
342
343   // Rebuild data tree
344   //void onRebuild();
345
346   /// Validates the operation to change the "Apply" button state.
347   /// \param thePreviousState the previous state of the widget
348   void onWidgetStateChanged(int thePreviousState);
349
350   /// Calls activate of the current widget again. It is possible that selection filters are
351   /// differs in the new state of paged container
352   void onValuesChanged();
353
354   /// Listens the corresponded signal of model widget and updates Apply button state by feature
355   void onWidgetObjectUpdated();
356
357   /// Show property panel
358   void showPropertyPanel();
359
360   /// Hide property panel
361   void hidePropertyPanel();
362
363   /// Show object Browser
364   void showObjectBrowser();
365
366   /// Hide object Browser
367   void hideObjectBrowser();
368
369   /// Close document
370   void closeDocument();
371
372   /// Open document from file
373   void onOpen();
374
375   /// Create a new document
376   void onNew();
377
378 #ifndef HAVE_SALOME
379   /// Exit application
380   void onExit();
381
382   /// Open preferences dialog box
383   void onPreferences();
384 #endif
385
386   /// Activates/deactivates the trihedron in the viewer AIS context
387   void onTrihedronVisibilityChanged(bool theState);
388
389
390  protected:
391   /// Sets the granted operations for the parameter operation. Firstly, it finds the nested features
392   /// and set them into the operation. Secondly, it asks the module about ids of granted operations.
393   /// \param theOperation an operation
394    void setGrantedFeatures(ModuleBase_Operation* theOperation);
395
396 private:
397   /// Display all results
398   //void displayAllResults();
399
400   /// Display results from document
401   /// \param theDoc a document
402   void displayDocumentResults(DocumentPtr theDoc);
403
404   /// Display results from a group
405   void displayGroupResults(DocumentPtr theDoc, std::string theGroup);
406
407  private slots:
408   /// SLOT, that is called after the operation is started. Update workshop state according to
409   /// the started operation, e.g. visualizes the property panel and connect to it.
410   /// \param theOpertion a started operation
411   void onOperationStarted(ModuleBase_Operation* theOperation);
412
413   /// SLOT, that is called after the operation is resumed. Update workshop state according to
414   /// the started operation, e.g. visualizes the property panel and connect to it.
415   /// \param theOpertion a resumed operation
416   virtual void onOperationResumed(ModuleBase_Operation* theOperation);
417
418   /// SLOT, that is called after the operation is stopped. Update workshop state, e.g.
419   /// hides the property panel and update the command status.
420   /// \param theOpertion a stopped operation
421   virtual void onOperationStopped(ModuleBase_Operation* theOperation);
422
423   /// SLOT, that is called after the operation is committed.
424   /// \param theOpertion a committed operation
425   virtual void onOperationCommitted(ModuleBase_Operation* theOperation);
426
427   /// SLOT, that is called after the operation is aborted.
428   /// \param theOpertion an aborted operation
429   void onOperationAborted(ModuleBase_Operation* theOperation);
430
431   /// Slot, which reacts to the context popup menu call
432   /// \param theId the data value of the clicked action
433   /// \param isChecked a state of toggle if the action is checkable
434   void onContextMenuCommand(const QString& theId, bool isChecked);
435
436   /// Set waiting cursor
437   void onStartWaiting();
438
439   /// Called by Ok button clicked in the property panel. Asks the error manager whether
440   /// the operation can be committed and do it if it returns true.
441   void onAcceptActionClicked();
442
443   /// Called by Preview button clicked in the property panel. Sends signal to model to
444   /// compute preview.
445   void onPreviewActionClicked();
446
447  private:
448    /// Init menu
449   void initMenu();
450
451   /// Register validators
452   void registerValidators() const;
453
454   /// Load module from external library
455   /// \param theModule name of the module
456   ModuleBase_IModule* loadModule(const QString& theModule);
457
458   /// Create module
459   bool createModule();
460
461   /// Create object browser widget
462   /// \param theParent a parent of widget
463   QDockWidget* createObjectBrowser(QWidget* theParent);
464
465   /// Create property panel widget
466   /// \param theParent a parent of widget
467   QDockWidget* createPropertyPanel(QWidget* theParent);
468
469   // Creates Dock widgets: Object browser and Property panel
470   void createDockWidgets();
471
472   //! Extends undo/redo toolbutton's with history menu
473   //! \param theObject - in the OpenParts it is a QToolButton by itself,
474   //! in salome mode - QAction that creates a button.
475   //! \param theSignal - void "updateUndoHistory" or "updateRedoHistory" SIGNAL;
476   //! \param theSlot - onUndo(int) or onRedo(int) SLOT
477   void addHistoryMenu(QObject* theObject, const char* theSignal, const char* theSlot);
478
479   //! Creates list of actions (commands) by given history list from session
480   QList<ActionInfo> processHistoryList(const std::list<std::string>&) const;
481
482 private:
483 #ifndef HAVE_SALOME
484   AppElements_MainWindow* myMainWindow;
485 #endif
486
487   ModuleBase_IModule* myModule;
488   XGUI_ErrorMgr* myErrorMgr;
489   XGUI_ObjectsBrowser* myObjectBrowser;
490   XGUI_PropertyPanel* myPropertyPanel;
491   XGUI_SelectionMgr* mySelector;
492   XGUI_Displayer* myDisplayer;
493   XGUI_OperationMgr* myOperationMgr;  ///< manager to manipulate through the operations
494   XGUI_ActionsMgr* myActionsMgr;
495   XGUI_MenuMgr* myMenuMgr; ///< manager to build menu/tool bar using order defined in XML
496   XGUI_SalomeConnector* mySalomeConnector;
497   XGUI_ErrorDialog* myErrorDlg;
498   XGUI_ViewerProxy* myViewerProxy;
499   XGUI_ContextMenuMgr* myContextMenuMgr;
500   XGUI_ModuleConnector* myModuleConnector;
501   XGUI_WorkshopListener* myEventsListener;
502
503   QString myCurrentDir;
504
505   QIntList myViewerSelMode;
506
507   Config_DataModelReader* myDataModelXMLReader;
508 };
509
510 #endif