]> SALOME platform Git repositories - modules/shaper.git/blob - src/XGUI/XGUI_ContextMenuMgr.cpp
Salome HOME
Merge remote-tracking branch 'origin/DISPLAY_FIELD_STEP'
[modules/shaper.git] / src / XGUI / XGUI_ContextMenuMgr.cpp
1 // Copyright (C) 2014-2019  CEA/DEN, EDF R&D
2 //
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.
7 //
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.
12 //
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
16 //
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
18 //
19
20 #include "XGUI_ContextMenuMgr.h"
21 #include "XGUI_Workshop.h"
22 #include "XGUI_ObjectsBrowser.h"
23 #include "XGUI_SelectionMgr.h"
24 #include "XGUI_Displayer.h"
25 #include "XGUI_ViewerProxy.h"
26 #include "XGUI_SalomeConnector.h"
27 #include "XGUI_Selection.h"
28 #include "XGUI_SelectionActivate.h"
29 #include "XGUI_DataModel.h"
30 #include "XGUI_OperationMgr.h"
31 #include "XGUI_Tools.h"
32 #include "XGUI_ActionsMgr.h"
33
34 #ifndef HAVE_SALOME
35 #include <AppElements_MainWindow.h>
36 #endif
37
38 //#include "PartSetPlugin_Part.h"
39
40 #include <ModelAPI_Data.h>
41 #include <ModelAPI_AttributeDocRef.h>
42 #include <ModelAPI_Object.h>
43 #include <ModelAPI_Session.h>
44 #include <ModelAPI_ResultGroup.h>
45 #include <ModelAPI_ResultParameter.h>
46 #include <ModelAPI_ResultConstruction.h>
47 #include <ModelAPI_ResultBody.h>
48 #include <ModelAPI_Tools.h>
49 #include <ModelAPI_ResultField.h>
50 #include <ModelAPI_Folder.h>
51 #include <ModelAPI_AttributeReference.h>
52 #include <ModelAPI_ResultField.h>
53
54 #include <Config_DataModelReader.h>
55
56 #include <ModuleBase_IModule.h>
57 #include <ModuleBase_Tools.h>
58 #include <ModuleBase_OperationAction.h>
59 #include <ModuleBase_ViewerPrs.h>
60
61 #include <QAction>
62 #include <QActionGroup>
63 #include <QContextMenuEvent>
64 #include <QMenu>
65 #include <QMdiArea>
66 #include <QMainWindow>
67 #include <QModelIndex>
68
69 XGUI_ContextMenuMgr::XGUI_ContextMenuMgr(XGUI_Workshop* theParent)
70     : QObject(theParent),
71       myWorkshop(theParent),
72       mySeparator1(0), mySeparator2(0), mySeparator3(0)
73 {
74 }
75
76 XGUI_ContextMenuMgr::~XGUI_ContextMenuMgr()
77 {
78 }
79
80 void XGUI_ContextMenuMgr::createActions()
81 {
82 #ifdef HAVE_SALOME
83   QMainWindow* aDesktop = myWorkshop->salomeConnector()->desktop();
84 #else
85   QMainWindow* aDesktop = myWorkshop->mainWindow();
86 #endif
87
88   QAction* aAction = ModuleBase_Tools::createAction(QIcon(":pictures/delete.png"), tr("Delete"),
89                                                     aDesktop);
90   aDesktop->addAction(aAction);
91
92   addAction("DELETE_CMD", aAction);
93   aAction->setShortcutContext(Qt::ApplicationShortcut);
94
95   aAction = ModuleBase_Tools::createAction(QIcon(":pictures/rename_edit.png"), tr("Rename"),
96                                            aDesktop, this, SLOT(onRename()));
97   addAction("RENAME_CMD", aAction);
98
99   aAction = ModuleBase_Tools::createAction(QIcon(":pictures/move.png"),
100                                            XGUI_Workshop::MOVE_TO_END_COMMAND, this);
101   addAction("MOVE_CMD", aAction);
102
103   aAction = ModuleBase_Tools::createAction(QIcon(":pictures/clean_history.png"),
104                                            tr("Clean history"), aDesktop);
105   addAction("CLEAN_HISTORY_CMD", aAction);
106
107   aAction = ModuleBase_Tools::createAction(QIcon(":pictures/color.png"), tr("Color..."), aDesktop);
108   addAction("COLOR_CMD", aAction);
109
110   aAction = ModuleBase_Tools::createAction(QIcon(""), tr("Deflection..."), aDesktop);
111   addAction("DEFLECTION_CMD", aAction);
112
113   aAction = ModuleBase_Tools::createAction(QIcon(":pictures/transparency.png"),
114                                            tr("Transparency..."), aDesktop);
115   addAction("TRANSPARENCY_CMD", aAction);
116
117   aAction = ModuleBase_Tools::createAction(QIcon(":pictures/eye_pencil.png"), tr("Show"), aDesktop);
118   addAction("SHOW_CMD", aAction);
119
120   aAction = ModuleBase_Tools::createAction(QIcon(":pictures/eye_pencil.png"), tr("Show only"),
121                                            aDesktop);
122   addAction("SHOW_ONLY_CMD", aAction);
123
124   aAction = ModuleBase_Tools::createAction(QIcon(":pictures/eye_pencil_closed.png"), tr("Hide"),
125                                            aDesktop);
126   addAction("HIDE_CMD", aAction);
127
128   aAction = ModuleBase_Tools::createAction(QIcon(":pictures/eye_pencil_closed.png"), tr("Hide all"),
129                                            aDesktop);
130   addAction("HIDEALL_CMD", aAction);
131
132   aAction = ModuleBase_Tools::createAction(QIcon(":pictures/shading.png"), tr("Shading"), aDesktop);
133   addAction("SHADING_CMD", aAction);
134
135   aAction = ModuleBase_Tools::createAction(QIcon(":pictures/wireframe.png"), tr("Wireframe"),
136                                            aDesktop);
137   addAction("WIREFRAME_CMD", aAction);
138
139   mySeparator1 = ModuleBase_Tools::createAction(QIcon(), "", aDesktop);
140   mySeparator1->setSeparator(true);
141
142   mySeparator2 = ModuleBase_Tools::createAction(QIcon(), "", aDesktop);
143   mySeparator2->setSeparator(true);
144
145   mySeparator3 = ModuleBase_Tools::createAction(QIcon(), "", aDesktop);
146   mySeparator3->setSeparator(true);
147
148   aAction = ModuleBase_Tools::createAction(QIcon(":pictures/vertex.png"), tr("Vertices"), aDesktop,
149                                            this, SLOT(onShapeSelection(bool)));
150   aAction->setCheckable(true);
151   addAction("SELECT_VERTEX_CMD", aAction);
152
153   aAction = ModuleBase_Tools::createAction(QIcon(":pictures/edge.png"), tr("Edges"), aDesktop,
154                                            this, SLOT(onShapeSelection(bool)));
155   aAction->setCheckable(true);
156   addAction("SELECT_EDGE_CMD", aAction);
157
158   aAction = ModuleBase_Tools::createAction(QIcon(":pictures/face.png"), tr("Faces"), aDesktop,
159                                            this, SLOT(onShapeSelection(bool)));
160   aAction->setCheckable(true);
161   addAction("SELECT_FACE_CMD", aAction);
162
163   aAction = ModuleBase_Tools::createAction(QIcon(":pictures/result.png"), tr("Results"), aDesktop,
164                                            this, SLOT(onResultSelection(bool)));
165   aAction->setCheckable(true);
166   addAction("SELECT_RESULT_CMD", aAction);
167
168   aAction->setChecked(true);
169
170   aAction = ModuleBase_Tools::createAction(QIcon(":pictures/find_result.png"),
171                                            tr("Select results"), aDesktop);
172   addAction("SHOW_RESULTS_CMD", aAction);
173
174   aAction = ModuleBase_Tools::createAction(QIcon(":pictures/find_result.png"),
175                                            tr("Select parent feature"), aDesktop);
176   addAction("SHOW_FEATURE_CMD", aAction);
177
178 #ifdef TINSPECTOR
179   aAction = ModuleBase_Tools::createAction(QIcon(), tr("TInspector"), aDesktop);
180   addAction("TINSPECTOR_VIEW", aAction);
181 #endif
182
183   // Features folders actions
184   aAction = ModuleBase_Tools::createAction(QIcon(":pictures/create_folder.png"),
185                                            tr("Insert a folder before"), aDesktop);
186   addAction("INSERT_FOLDER_CMD", aAction);
187
188   aAction = ModuleBase_Tools::createAction(QIcon(":pictures/insert_folder_before.png"),
189                                            tr("Move into the previous folder"), aDesktop);
190   addAction("ADD_TO_FOLDER_BEFORE_CMD", aAction);
191
192   aAction = ModuleBase_Tools::createAction(QIcon(":pictures/insert_folder_after.png"),
193                                            tr("Move into the next folder"), aDesktop);
194   addAction("ADD_TO_FOLDER_AFTER_CMD", aAction);
195
196   aAction = ModuleBase_Tools::createAction(QIcon(":pictures/move_out_before.png"),
197                                            tr("Move out before the folder"), aDesktop);
198   addAction("ADD_OUT_FOLDER_BEFORE_CMD", aAction);
199
200   aAction = ModuleBase_Tools::createAction(QIcon(":pictures/move_out_after.png"),
201                                            tr("Move out after the folder"), aDesktop);
202   addAction("ADD_OUT_FOLDER_AFTER_CMD", aAction);
203
204   aAction = ModuleBase_Tools::createAction(QIcon(":pictures/normal-view-inversed.png"),
205                                            tr("Set view by inverted normal to face"), aDesktop);
206   addAction("SET_VIEW_INVERTEDNORMAL_CMD", aAction);
207
208   aAction = ModuleBase_Tools::createAction(QIcon(":pictures/normal-view.png"),
209                                            tr("Set view by normal to face"), aDesktop);
210   addAction("SET_VIEW_NORMAL_CMD", aAction);
211
212   buildObjBrowserMenu();
213   buildViewerMenu();
214 }
215
216 void XGUI_ContextMenuMgr::addAction(const QString& theId, QAction* theAction)
217 {
218   if (myActions.contains(theId))
219     qCritical("A command with Id = '%s' already defined!", qPrintable(theId));
220   theAction->setData(theId);
221   connect(theAction, SIGNAL(triggered(bool)), this, SLOT(onAction(bool)));
222   myActions[theId] = theAction;
223 }
224
225 QAction* XGUI_ContextMenuMgr::action(const QString& theId) const
226 {
227   if (myActions.contains(theId))
228     return myActions[theId];
229   return 0;
230 }
231
232 QAction* XGUI_ContextMenuMgr::actionByName(const QString& theName) const
233 {
234   foreach(QAction* eachAction, myActions) {
235     if (eachAction->text() == theName) {
236       return eachAction;
237     }
238   }
239   return NULL;
240 }
241
242 QStringList XGUI_ContextMenuMgr::actionIds() const
243 {
244   return myActions.keys();
245 }
246
247 void XGUI_ContextMenuMgr::onAction(bool isChecked)
248 {
249   QAction* aAction = static_cast<QAction*>(sender());
250   emit actionTriggered(aAction->data().toString(), isChecked);
251 }
252
253 void XGUI_ContextMenuMgr::updateCommandsStatus()
254 {
255 }
256
257 void XGUI_ContextMenuMgr::onContextMenuRequest(QContextMenuEvent* theEvent)
258 {
259   QMenu* aMenu = new QMenu();
260   if (sender() == myWorkshop->objectBrowser()) {
261     updateObjectBrowserMenu();
262     addObjBrowserMenu(aMenu);
263   } else if (sender() == myWorkshop->viewer()) {
264     updateViewerMenu();
265     addViewerMenu(aMenu);
266   }
267
268   if (aMenu && (aMenu->actions().size() > 0)) {
269     // it is possible that some objects should do something before and after the popup menu exec
270     // e.g. a sketch manager changes an internal flag on this signals in order to do not hide
271     // a created entity
272     emit beforeContextMenu();
273     aMenu->exec(theEvent->globalPos());
274     emit afterContextMenu();
275     delete aMenu;
276   }
277 }
278
279 void XGUI_ContextMenuMgr::updateObjectBrowserMenu()
280 {
281   foreach(QAction* aAction, myActions)
282     aAction->setEnabled(false);
283
284   XGUI_SelectionMgr* aSelMgr = myWorkshop->selector();
285   QObjectPtrList aObjects = aSelMgr->selection()->selectedObjects();
286   int aSelected = aObjects.size();
287   if (aSelected > 0) {
288     SessionPtr aMgr = ModelAPI_Session::get();
289     XGUI_Displayer* aDisplayer = myWorkshop->displayer();
290     bool hasResult = false;
291     bool hasFeature = false;
292     bool hasParameter = false;
293     bool hasCompositeOwner = false;
294     bool hasResultInHistory = false;
295     bool hasFolder = false;
296     ModuleBase_Tools::checkObjects(aObjects, hasResult, hasFeature, hasParameter,
297                                    hasCompositeOwner, hasResultInHistory, hasFolder);
298     //Process Feature
299     if (aSelected == 1) { // single selection
300       ObjectPtr aObject = aObjects.first();
301       if (aObject) {
302         if (hasResult && myWorkshop->canBeShaded(aObject)) {
303           XGUI_Displayer::DisplayMode aMode = aDisplayer->displayMode(aObject);
304           if (aMode != XGUI_Displayer::NoMode) {
305             action("WIREFRAME_CMD")->setEnabled(aMode == XGUI_Displayer::Shading);
306             action("SHADING_CMD")->setEnabled(aMode == XGUI_Displayer::Wireframe);
307           } else {
308             action("WIREFRAME_CMD")->setEnabled(true);
309             action("SHADING_CMD")->setEnabled(true);
310           }
311         }
312         if (!hasFeature) {
313           bool aHasSubResults = ModelAPI_Tools::hasSubResults(
314                                             std::dynamic_pointer_cast<ModelAPI_Result>(aObject));
315           if (aHasSubResults) {
316             action("HIDE_CMD")->setEnabled(true);
317             action("SHOW_CMD")->setEnabled(true);
318           }
319           else {
320             if (aObject->isDisplayed()) {
321               action("HIDE_CMD")->setEnabled(true);
322             } else if (hasResult && (!hasParameter)) {
323               action("SHOW_CMD")->setEnabled(true);
324             }
325           }
326           if (!(hasParameter || hasFeature))
327             action("SHOW_ONLY_CMD")->setEnabled(true);
328         }
329         else if (hasFeature && myWorkshop->canMoveFeature())
330           action("MOVE_CMD")->setEnabled(true);
331
332         if( aMgr->activeDocument() == aObject->document() )
333         {
334           action("RENAME_CMD")->setEnabled(true);
335           action("DELETE_CMD")->setEnabled(!hasCompositeOwner);
336           action("CLEAN_HISTORY_CMD")->setEnabled(!hasCompositeOwner &&
337                                                   (hasFeature || hasParameter));
338         }
339       }
340       // end single selection
341     } else { // multi-selection
342       // parameter is commented because the actions are not in the list of result parameter actions
343       if (hasResult /*&& (!hasParameter)*/) {
344         action("SHOW_CMD")->setEnabled(true);
345         action("HIDE_CMD")->setEnabled(true);
346         action("SHOW_ONLY_CMD")->setEnabled(true);
347         action("SHADING_CMD")->setEnabled(true);
348         action("WIREFRAME_CMD")->setEnabled(true);
349       }
350     } // end multi-selection
351
352     // Check folder management commands state if only features are selected
353     if ((!hasResult) && hasFeature && (!hasParameter) && (!hasCompositeOwner) &&
354       (!hasResultInHistory) && (!hasFolder)) {
355       std::list<FeaturePtr> aFeatures = aSelMgr->getSelectedFeatures();
356       if (aFeatures.size() > 0) { // Check that features do not include Parts
357         QModelIndexList aIndexes = aSelMgr->selection()->selectedIndexes();
358         QModelIndex aFirstIdx = aIndexes.first();
359         QModelIndex aLastIdx = aIndexes.last();
360         QModelIndex aParentIdx = aFirstIdx.parent();
361
362         // if all selected are from the same level
363         bool isSameParent = true;
364         foreach(QModelIndex aIdx, aIndexes) {
365           if (aIdx.parent() != aParentIdx) {
366             isSameParent = false;
367             break;
368           }
369         }
370         if (isSameParent) {
371           // Check is selection continuous
372           XGUI_DataModel* aModel = myWorkshop->objectBrowser()->dataModel();
373           DocumentPtr aDoc = aMgr->activeDocument();
374           std::list<FeaturePtr> aFeatures = aSelMgr->getSelectedFeatures();
375
376           bool isContinuos = true;
377           if (aSelected > 1) {
378             int aId = -1;
379             foreach(FeaturePtr aF, aFeatures) {
380               if (aId == -1)
381                 aId = aDoc->index(aF);
382               else {
383                 aId++;
384                 if (aId != aDoc->index(aF)) {
385                   isContinuos = false;
386                   break;
387                 }
388               }
389             }
390           }
391           if (isContinuos) {
392             ObjectPtr aDataObj = aModel->object(aParentIdx);
393
394             ObjectPtr aPrevObj;
395             if (aFirstIdx.row() > 0) {
396               QModelIndex aPrevIdx = aFirstIdx.sibling(aFirstIdx.row() - 1, 0);
397               aPrevObj = aModel->object(aPrevIdx);
398             }
399
400             ObjectPtr aNextObj;
401             if (aLastIdx.row() < (aModel->rowCount(aParentIdx) - 1)) {
402               QModelIndex aNextIdx = aFirstIdx.sibling(aLastIdx.row() + 1, 0);
403               aNextObj = aModel->object(aNextIdx);
404             }
405
406             bool isPrevFolder = (aPrevObj.get() &&
407               (aPrevObj->groupName() == ModelAPI_Folder::group()));
408             bool isNextFolder = (aNextObj.get() &&
409               (aNextObj->groupName() == ModelAPI_Folder::group()));
410             bool isInFolder = (aDataObj.get() &&
411               (aDataObj->groupName() == ModelAPI_Folder::group()));
412             bool isOutsideFolder = !isInFolder;
413
414             bool hasFirst = false;
415             bool hasLast = false;
416             if (isInFolder) {
417               FolderPtr aFolder = std::dynamic_pointer_cast<ModelAPI_Folder>(aDataObj);
418               FeaturePtr aFirstFeatureInFolder;
419               AttributeReferencePtr aFirstFeatAttr =
420                   aFolder->data()->reference(ModelAPI_Folder::FIRST_FEATURE_ID());
421               if (aFirstFeatAttr)
422                 aFirstFeatureInFolder = ModelAPI_Feature::feature(aFirstFeatAttr->value());
423               hasFirst = (aFirstFeatureInFolder == aFeatures.front());
424
425               FeaturePtr aLastFeatureInFolder;
426               AttributeReferencePtr aLastFeatAttr =
427                   aFolder->data()->reference(ModelAPI_Folder::LAST_FEATURE_ID());
428               if (aLastFeatAttr)
429                 aLastFeatureInFolder = ModelAPI_Feature::feature(aLastFeatAttr->value());
430               hasLast = (aLastFeatureInFolder == aFeatures.back());
431             }
432             action("INSERT_FOLDER_CMD")->setEnabled(isOutsideFolder);
433             action("ADD_TO_FOLDER_BEFORE_CMD")->setEnabled(isOutsideFolder && isPrevFolder);
434             action("ADD_TO_FOLDER_AFTER_CMD")->setEnabled(isOutsideFolder && isNextFolder);
435             action("ADD_OUT_FOLDER_BEFORE_CMD")->setEnabled(isInFolder && hasFirst);
436             action("ADD_OUT_FOLDER_AFTER_CMD")->setEnabled(isInFolder && hasLast);
437           }
438         }
439       }
440     } // end folder management commands
441
442     bool allActive = true;
443     foreach( ObjectPtr aObject, aObjects )
444       if( aMgr->activeDocument() != aObject->document() )  {
445         allActive = false;
446         break;
447       }
448     if (!hasCompositeOwner && allActive ) {
449       if (hasResult || hasFeature || hasParameter) // #2924 results can be erased
450         action("DELETE_CMD")->setEnabled(true);
451     }
452     if (!hasCompositeOwner && allActive && (hasFeature|| hasParameter))
453       action("CLEAN_HISTORY_CMD")->setEnabled(true);
454
455     action("SHOW_RESULTS_CMD")->setEnabled(hasFeature);
456     action("SHOW_FEATURE_CMD")->setEnabled(hasResult && hasResultInHistory);
457   } // end selection processing
458
459   // Show/Hide command has to be disabled for objects from non active document
460   bool aDeactivate = false;
461   foreach (ObjectPtr aObj, aObjects) {
462     if (!aObj->document()->isActive()) {
463       if ((aObj->document() != ModelAPI_Session::get()->moduleDocument()) ||
464            aObj->groupName() == ModelAPI_ResultPart::group()) {
465         aDeactivate = true;
466         break;
467       }
468     }
469   }
470   if (aDeactivate) {
471     // If at leas a one object can not be edited then Show/Hide has to be disabled
472     action("SHOW_CMD")->setEnabled(false);
473     action("HIDE_CMD")->setEnabled(false);
474     action("SHOW_ONLY_CMD")->setEnabled(false);
475   }
476
477   action("COLOR_CMD")->setEnabled(myWorkshop->canChangeProperty("COLOR_CMD"));
478   action("DEFLECTION_CMD")->setEnabled(myWorkshop->canChangeProperty("DEFLECTION_CMD"));
479   action("TRANSPARENCY_CMD")->setEnabled(myWorkshop->canChangeProperty("TRANSPARENCY_CMD"));
480   #ifdef _DEBUG
481     #ifdef TINSPECTOR
482       action("TINSPECTOR_VIEW")->setEnabled(true);
483     #endif
484   #endif
485
486
487   ModuleBase_IModule* aModule = myWorkshop->module();
488   if (aModule)
489     aModule->updateObjectBrowserMenu(myActions);
490 }
491
492 void XGUI_ContextMenuMgr::updateViewerMenu()
493 {
494   foreach(QAction* aAction, myActions)
495     aAction->setEnabled(false);
496
497   XGUI_SelectionMgr* aSelMgr = myWorkshop->selector();
498   XGUI_Displayer* aDisplayer = myWorkshop->displayer();
499   QList<ModuleBase_ViewerPrsPtr> aPrsList =
500     aSelMgr->selection()->getSelected(ModuleBase_ISelection::Viewer);
501   if (aPrsList.size() > 0) {
502     bool isVisible = false;
503     bool isShading = false;
504     bool canBeShaded = false;
505     bool hasPlanar = false;
506     ObjectPtr aObject;
507     foreach(ModuleBase_ViewerPrsPtr aPrs, aPrsList) {
508       aObject = aPrs->object();
509       GeomShapePtr aShape = aPrs->shape();
510       if (aObject->isDisplayed()) {
511         isVisible = true;
512         canBeShaded = myWorkshop->displayer()->canBeShaded(aObject);
513         isShading =
514           (myWorkshop->displayer()->displayMode(aObject) == XGUI_Displayer::Shading);
515       }
516       if (aShape.get()) {
517         if (aShape->isPlanar()) {
518           hasPlanar = true;
519         }
520       }
521     }
522     if (isVisible) {
523       if (canBeShaded) {
524         XGUI_Displayer::DisplayMode aMode = aDisplayer->displayMode(aObject);
525         if (aMode != XGUI_Displayer::NoMode) {
526           action("WIREFRAME_CMD")->setEnabled(aMode == XGUI_Displayer::Shading);
527           action("SHADING_CMD")->setEnabled(aMode == XGUI_Displayer::Wireframe);
528         } else {
529           action("WIREFRAME_CMD")->setEnabled(true);
530           action("SHADING_CMD")->setEnabled(true);
531         }
532       }
533       action("SHOW_ONLY_CMD")->setEnabled(true);
534       action("HIDE_CMD")->setEnabled(true);
535     } else
536       action("SHOW_CMD")->setEnabled(true);
537
538     action("SET_VIEW_NORMAL_CMD")->setEnabled(hasPlanar);
539     action("SET_VIEW_INVERTEDNORMAL_CMD")->setEnabled(hasPlanar);
540   }
541   //issue #2159 Hide all incomplete behavior
542 #ifdef HAVE_SALOME
543     action("HIDEALL_CMD")->setEnabled(true);
544 #else
545   if (myWorkshop->displayer()->objectsCount() > 0)
546     action("HIDEALL_CMD")->setEnabled(true);
547 #endif
548
549   // Update selection menu
550   QIntList aModes = myWorkshop->selectionActivate()->activeSelectionModes();
551   action("SELECT_VERTEX_CMD")->setEnabled(true);
552   action("SELECT_EDGE_CMD")->setEnabled(true);
553   action("SELECT_FACE_CMD")->setEnabled(true);
554   action("SELECT_RESULT_CMD")->setEnabled(true);
555
556   action("SELECT_RESULT_CMD")->setChecked(false);
557   action("SELECT_VERTEX_CMD")->setChecked(false);
558   action("SELECT_EDGE_CMD")->setChecked(false);
559   action("SELECT_FACE_CMD")->setChecked(false);
560   action("SELECT_RESULT_CMD")->setChecked(false);
561   if (aModes.count() == 0) {
562     action("SELECT_RESULT_CMD")->setChecked(true);
563   } else {
564     foreach(int aMode, aModes) {
565       switch (aMode) {
566       case TopAbs_VERTEX:
567         action("SELECT_VERTEX_CMD")->setChecked(true);
568         break;
569       case TopAbs_EDGE:
570         action("SELECT_EDGE_CMD")->setChecked(true);
571         break;
572       case TopAbs_FACE:
573         action("SELECT_FACE_CMD")->setChecked(true);
574         break;
575       default:
576         action("SELECT_RESULT_CMD")->setChecked(true);
577       }
578     }
579   }
580
581   ModuleBase_IModule* aModule = myWorkshop->module();
582   if (aModule)
583     aModule->updateViewerMenu(myActions);
584
585   if (myWorkshop->canChangeProperty("COLOR_CMD"))
586     action("COLOR_CMD")->setEnabled(true);
587
588   if (myWorkshop->canChangeProperty("DEFLECTION_CMD"))
589     action("DEFLECTION_CMD")->setEnabled(true);
590
591   if (myWorkshop->canChangeProperty("TRANSPARENCY_CMD"))
592     action("TRANSPARENCY_CMD")->setEnabled(true);
593
594   action("DELETE_CMD")->setEnabled(true);
595 }
596
597 void XGUI_ContextMenuMgr::connectObjectBrowser()
598 {
599   connect(myWorkshop->objectBrowser(), SIGNAL(contextMenuRequested(QContextMenuEvent*)), this,
600           SLOT(onContextMenuRequest(QContextMenuEvent*)));
601 }
602
603 void XGUI_ContextMenuMgr::connectViewer()
604 {
605   connect(myWorkshop->viewer(), SIGNAL(contextMenuRequested(QContextMenuEvent*)), this,
606           SLOT(onContextMenuRequest(QContextMenuEvent*)));
607 }
608
609
610 void XGUI_ContextMenuMgr::buildObjBrowserMenu()
611 {
612   QAction* aSeparator = ModuleBase_Tools::createAction(QIcon(), "", myWorkshop->desktop());
613   aSeparator->setSeparator(true);
614
615   QActionsList aList;
616
617   // Result construction menu
618   aList.append(action("SHOW_CMD"));
619   aList.append(action("HIDE_CMD"));
620   aList.append(action("SHOW_ONLY_CMD"));
621   aList.append(mySeparator1);
622   aList.append(action("RENAME_CMD"));
623   aList.append(action("COLOR_CMD"));
624   aList.append(action("DEFLECTION_CMD"));
625   aList.append(action("TRANSPARENCY_CMD"));
626   aList.append(action("SHOW_FEATURE_CMD"));
627   aList.append(mySeparator2);
628   aList.append(action("DELETE_CMD"));
629   myObjBrowserMenus[ModelAPI_ResultConstruction::group()] = aList;
630
631   //-------------------------------------
632   // Result body menu
633   aList.clear();
634   aList.append(action("WIREFRAME_CMD"));
635   aList.append(action("SHADING_CMD"));
636   aList.append(mySeparator1); // this separator is not shown as this action is added after show only
637   // qt list container contains only one instance of the same action
638   aList.append(action("SHOW_CMD"));
639   aList.append(action("HIDE_CMD"));
640   aList.append(action("SHOW_ONLY_CMD"));
641   aList.append(mySeparator2);
642   aList.append(action("RENAME_CMD"));
643   aList.append(action("COLOR_CMD"));
644   aList.append(action("DEFLECTION_CMD"));
645   aList.append(action("TRANSPARENCY_CMD"));
646   aList.append(action("SHOW_FEATURE_CMD"));
647   aList.append(mySeparator3);
648   aList.append(action("DELETE_CMD"));
649   myObjBrowserMenus[ModelAPI_ResultBody::group()] = aList;
650   // Group menu
651   myObjBrowserMenus[ModelAPI_ResultGroup::group()] = aList;
652   myObjBrowserMenus[ModelAPI_ResultField::group()] = aList;
653   // Result part menu
654   myObjBrowserMenus[ModelAPI_ResultPart::group()] = aList;
655   //-------------------------------------
656   // Feature menu
657   aList.clear();
658   aList.append(action("RENAME_CMD"));
659   aList.append(action("SHOW_RESULTS_CMD"));
660   aList.append(action("MOVE_CMD"));
661   aList.append(mySeparator1);
662   aList.append(action("INSERT_FOLDER_CMD"));
663   aList.append(action("ADD_TO_FOLDER_BEFORE_CMD"));
664   aList.append(action("ADD_TO_FOLDER_AFTER_CMD"));
665   aList.append(mySeparator2);
666   aList.append(action("ADD_OUT_FOLDER_BEFORE_CMD"));
667   aList.append(action("ADD_OUT_FOLDER_AFTER_CMD"));
668   aList.append(mySeparator3);
669   aList.append(action("CLEAN_HISTORY_CMD"));
670   aList.append(action("DELETE_CMD"));
671   myObjBrowserMenus[ModelAPI_Feature::group()] = aList;
672
673   aList.clear();
674   aList.append(action("RENAME_CMD"));
675   aList.append(mySeparator1);
676   aList.append(action("CLEAN_HISTORY_CMD"));
677   aList.append(action("DELETE_CMD"));
678   myObjBrowserMenus[ModelAPI_ResultParameter::group()] = aList;
679   //-------------------------------------
680
681   aList.clear();
682   aList.append(action("RENAME_CMD"));
683   aList.append(action("DELETE_CMD"));
684   myObjBrowserMenus[ModelAPI_Folder::group()] = aList;
685
686   //---------------------------------------
687   // Step objects menu
688   aList.clear();
689   aList.append(action("SHOW_CMD"));
690   aList.append(action("HIDE_CMD"));
691   aList.append(action("SHOW_ONLY_CMD"));
692   myObjBrowserMenus[ModelAPI_ResultField::ModelAPI_FieldStep::group()] = aList;
693 }
694
695 void XGUI_ContextMenuMgr::buildViewerMenu()
696 {
697   QActionsList aList;
698   // Result construction menu
699   aList.append(action("COLOR_CMD"));
700   aList.append(action("DEFLECTION_CMD"));
701   aList.append(action("TRANSPARENCY_CMD"));
702   aList.append(mySeparator3);
703   aList.append(action("SET_VIEW_NORMAL_CMD"));
704   aList.append(action("SET_VIEW_INVERTEDNORMAL_CMD"));
705   aList.append(mySeparator1);
706   aList.append(action("SHOW_ONLY_CMD"));
707   aList.append(action("HIDE_CMD"));
708   myViewerMenu[ModelAPI_ResultConstruction::group()] = aList;
709   // Result part menu
710   myViewerMenu[ModelAPI_ResultPart::group()] = aList;
711   //-------------------------------------
712   // Result body menu
713   aList.clear();
714   aList.append(action("WIREFRAME_CMD"));
715   aList.append(action("SHADING_CMD"));
716   aList.append(mySeparator2);
717   aList.append(action("COLOR_CMD"));
718   aList.append(action("DEFLECTION_CMD"));
719   aList.append(action("TRANSPARENCY_CMD"));
720   aList.append(mySeparator3);
721   aList.append(action("SET_VIEW_NORMAL_CMD"));
722   aList.append(action("SET_VIEW_INVERTEDNORMAL_CMD"));
723   aList.append(mySeparator1);
724   aList.append(action("SHOW_ONLY_CMD"));
725   aList.append(action("HIDE_CMD"));
726   myViewerMenu[ModelAPI_ResultBody::group()] = aList;
727   // Group menu
728   myViewerMenu[ModelAPI_ResultGroup::group()] = aList;
729   myViewerMenu[ModelAPI_ResultField::group()] = aList;
730   //-------------------------------------
731   // Step objects menu
732   aList.clear();
733   aList.append(action("HIDE_CMD"));
734   myViewerMenu[ModelAPI_ResultField::ModelAPI_FieldStep::group()] = aList;
735 }
736
737
738 void XGUI_ContextMenuMgr::addObjBrowserMenu(QMenu* theMenu) const
739 {
740   ModuleBase_IModule* aModule = myWorkshop->module();
741   if (aModule) {
742     theMenu->addSeparator();
743     aModule->addObjectBrowserMenu(theMenu);
744   }
745
746   XGUI_SelectionMgr* aSelMgr = myWorkshop->selector();
747   QObjectPtrList aObjects = aSelMgr->selection()->selectedObjects();
748   int aSelected = aObjects.size();
749   QActionsList aActions;
750   if (aSelected == 1) {
751     ObjectPtr aObject = aObjects.first();
752     std::string aName = aObject->groupName();
753     if (myObjBrowserMenus.contains(aName))
754       aActions = myObjBrowserMenus[aName];
755   } else if (aSelected > 1) {
756       aActions.append(action("WIREFRAME_CMD"));
757       aActions.append(action("SHADING_CMD"));
758       aActions.append(mySeparator1);
759       aActions.append(action("SHOW_CMD"));
760       aActions.append(action("HIDE_CMD"));
761       aActions.append(action("SHOW_ONLY_CMD"));
762       aActions.append(mySeparator2);
763       aActions.append(action("ADD_TO_FOLDER_BEFORE_CMD"));
764       aActions.append(action("ADD_TO_FOLDER_AFTER_CMD"));
765       aActions.append(action("ADD_OUT_FOLDER_BEFORE_CMD"));
766       aActions.append(action("ADD_OUT_FOLDER_AFTER_CMD"));
767       aActions.append(mySeparator3);
768       //aActions.append(action("MOVE_CMD"));
769       aActions.append(action("COLOR_CMD"));
770       aActions.append(action("DEFLECTION_CMD"));
771       aActions.append(action("TRANSPARENCY_CMD"));
772       aActions.append(action("CLEAN_HISTORY_CMD"));
773       aActions.append(action("DELETE_CMD"));
774   }
775 #ifdef _DEBUG
776   if (aSelected == 0) {
777     #ifdef TINSPECTOR
778     aActions.append(action("TINSPECTOR_VIEW"));
779     #endif
780   }
781 #endif
782   theMenu->addActions(aActions);
783   addFeatures(theMenu);
784
785   // It is commented out because Object Browser does not have actions
786   //theMenu->addSeparator();
787   //theMenu->addActions(myWorkshop->objectBrowser()->actions());
788 }
789
790 void XGUI_ContextMenuMgr::addViewerMenu(QMenu* theMenu) const
791 {
792   XGUI_SelectionMgr* aSelMgr = myWorkshop->selector();
793   QList<ModuleBase_ViewerPrsPtr> aPrsList =
794     aSelMgr->selection()->getSelected(ModuleBase_ISelection::Viewer);
795   int aSelected = aPrsList.size();
796   QActionsList aActions;
797
798   // Create selection menu
799   XGUI_OperationMgr* aOpMgr = myWorkshop->operationMgr();
800   if (!aOpMgr->hasOperation() &&
801       myWorkshop->selectionActivate()->activeSelectionPlace() == XGUI_SelectionActivate::Workshop) {
802     QMenu* aSelMenu = new QMenu(tr("Selection mode"), theMenu);
803     aSelMenu->addAction(action("SELECT_VERTEX_CMD"));
804     aSelMenu->addAction(action("SELECT_EDGE_CMD"));
805     aSelMenu->addAction(action("SELECT_FACE_CMD"));
806     //IMP: an attempt to use result selection with other selection modes
807     //aSelMenu->addSeparator();
808     aSelMenu->addAction(action("SELECT_RESULT_CMD"));
809     theMenu->addMenu(aSelMenu);
810     theMenu->addSeparator();
811   }
812   if (aSelected == 1) {
813     ObjectPtr aObject = aPrsList.first()->object();
814     if (aObject.get() != NULL) {
815       std::string aName = aObject->groupName();
816       if (myViewerMenu.contains(aName))
817         aActions = myViewerMenu[aName];
818     }
819   } else if (aSelected > 1) {
820     aActions.append(action("COLOR_CMD"));
821     aActions.append(action("DEFLECTION_CMD"));
822     aActions.append(action("TRANSPARENCY_CMD"));
823     aActions.append(mySeparator1);
824     aActions.append(action("SHOW_ONLY_CMD"));
825     aActions.append(action("HIDE_CMD"));
826   }
827   // hide all is shown always even if selection in the viewer is empty
828   aActions.append(action("HIDEALL_CMD"));
829   theMenu->addActions(aActions);
830
831   QMap<int, QAction*> aMenuActions;
832   ModuleBase_IModule* aModule = myWorkshop->module();
833   if (aModule) {
834     if (aModule->addViewerMenu(myActions, theMenu, aMenuActions))
835       theMenu->addSeparator();
836   }
837
838   // insert the module menu items on specific positions in the popup menu: some actions should be
839   // in the begin of the list, Delete action should be the last by #1343 issue
840   QList<QAction*> anActions = theMenu->actions();
841   int anActionsSize = anActions.size();
842   QAction* aFirstAction = anActions[0];
843   QMap<int, QAction*>::const_iterator anIt = aMenuActions.begin(), aLast = aMenuActions.end();
844   for (; anIt != aLast; anIt++) {
845     if (anIt.key() > anActionsSize)
846       theMenu->addAction(anIt.value());
847     else
848       theMenu->insertAction(aFirstAction, *anIt);
849   }
850
851 #ifndef HAVE_SALOME
852   theMenu->addSeparator();
853   QMdiArea* aMDI = myWorkshop->mainWindow()->mdiArea();
854   if (aMDI->actions().size() > 0) {
855     QMenu* aSubMenu = theMenu->addMenu(tr("Windows"));
856     aSubMenu->addActions(aMDI->actions());
857   }
858 #endif
859 }
860
861 QStringList XGUI_ContextMenuMgr::actionObjectGroups(const QString& theName)
862 {
863   QStringList aGroups;
864
865   QMap<std::string, QActionsList>::const_iterator anIt = myObjBrowserMenus.begin(),
866                                                   aLast = myObjBrowserMenus.end();
867   for (; anIt != aLast; anIt++) {
868     QString aGroupName(anIt.key().c_str());
869     if (aGroups.contains(aGroupName))
870       continue;
871     QActionsList anActions = anIt.value();
872     QActionsList::const_iterator anAIt = anActions.begin(), anALast = anActions.end();
873     bool aFound = false;
874     for (; anAIt != anALast && !aFound; anAIt++)
875       aFound = (*anAIt)->data().toString() == theName;
876     if (aFound)
877       aGroups.append(aGroupName);
878   }
879   return aGroups;
880 }
881
882 void XGUI_ContextMenuMgr::onRename()
883 {
884   QObjectPtrList anObjects = myWorkshop->selector()->selection()->selectedObjects();
885   if (!myWorkshop->abortAllOperations())
886     return;
887   // restore selection in case if dialog box was shown
888   myWorkshop->objectBrowser()->setObjectsSelected(anObjects);
889   myWorkshop->objectBrowser()->onEditItem();
890 }
891
892 void XGUI_ContextMenuMgr::addFeatures(QMenu* theMenu) const
893 {
894   SessionPtr aMgr = ModelAPI_Session::get();
895   DocumentPtr aActiveDoc = aMgr->activeDocument();
896
897   XGUI_SelectionMgr* aSelMgr = myWorkshop->selector();
898   XGUI_ActionsMgr* aActionMgr = myWorkshop->actionsMgr();
899   const Config_DataModelReader* aDataModelXML = myWorkshop->dataModelXMLReader();
900   QModelIndexList aSelectedIndexes = aSelMgr->selection()->selectedIndexes();
901
902   QString aName;
903   int aLen = 0;
904   bool aIsRoot = false;
905   foreach(QModelIndex aIdx, aSelectedIndexes) {
906     // Process only first column
907     if (aIdx.column() == 1) {
908       aIsRoot = !aIdx.parent().isValid();
909       // Exit if the selected index belongs to non active document
910       if (aIsRoot && (aActiveDoc != aMgr->moduleDocument()))
911         return;
912       if ((!aIsRoot) && (aIdx.internalPointer() != aActiveDoc.get()))
913         return;
914
915       // Get name of the selected index
916       aName = aIdx.data().toString();
917       aLen = aName.indexOf('(');
918       if (aLen != -1) {
919         aName = aName.left(--aLen);
920       }
921       std::string aFeaturesStr = aIsRoot?
922         aDataModelXML->rootFolderFeatures(aName.toStdString()) :
923         aDataModelXML->subFolderFeatures(aName.toStdString());
924         if (aFeaturesStr.length() > 0) {
925           QStringList aFeturesList =
926             QString(aFeaturesStr.c_str()).split(",", QString::SkipEmptyParts);
927           foreach(QString aFea, aFeturesList) {
928             QAction* aAction = aActionMgr->action(aFea);
929             if (aAction)
930               theMenu->addAction(aAction);
931           }
932         }
933     }
934   }
935 }
936
937 #define UNCHECK_ACTION(NAME) \
938 { QAction* aAction = action(NAME); \
939 bool isBlock = aAction->signalsBlocked(); \
940 aAction->blockSignals(true); \
941 aAction->setChecked(false); \
942   aAction->blockSignals(isBlock); }
943
944
945 void XGUI_ContextMenuMgr::onResultSelection(bool theChecked)
946 {
947   UNCHECK_ACTION("SELECT_VERTEX_CMD");
948   UNCHECK_ACTION("SELECT_EDGE_CMD");
949   UNCHECK_ACTION("SELECT_FACE_CMD");
950 }
951
952 void XGUI_ContextMenuMgr::onShapeSelection(bool theChecked)
953 {
954   UNCHECK_ACTION("SHOW_RESULTS_CMD");
955 }