src/PVGUI/PVGUI_Module_actions.cxx

   1 // PARAVIS : ParaView wrapper SALOME module
   2 //
   3 // Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 // This library is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU Lesser General Public
   8 // License as published by the Free Software Foundation; either
   9 // version 2.1 of the License.
  10 //
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 // Lesser General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU Lesser General Public
  17 // License along with this library; if not, write to the Free Software
  18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22 // File   : PVGUI_Module_MenuActions.cxx
  23 // Author : Margarita KARPUNINA
  24 //
  25
  26 #include "PVGUI_Module_impl.h"
  27
  28 #include <QtxAction.h>
  29 #include <QtxActionMenuMgr.h>
  30 #include <QtxActionToolMgr.h>
  31 #include <SUIT_Desktop.h>
  32 #include <SUIT_ResourceMgr.h>
  33 #include <SUIT_Session.h>
  34 #include <LightApp_Application.h>
  35
  36 #include <QAction>
  37 #include <QMenu>
  38 #include <QToolBar>
  39
  40 #include <pqApplicationCore.h>
  41 #include <pqColorScaleToolbar.h>
  42 #include <pqMainWindowCore.h>
  43 #include <pqObjectInspectorDriver.h>
  44 #include <pqPipelineBrowser.h>
  45 #include <pqProgressManager.h>
  46 #include <pqRubberBandHelper.h>
  47 #include <pqScalarBarVisibilityAdaptor.h>
  48 #include <pqUndoStack.h>
  49 #include <pqVCRController.h>
  50
  51 /*!
  52   \brief Create actions for ParaView GUI operations
  53   duplicating menus and toolbars in MainWindow class of
  54   the standard ParaView GUI client application.
  55 */
  56 void PVGUI_Module::pvCreateActions()
  57 {
  58   SUIT_Desktop* desk = application()->desktop();
  59   SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
  60
  61   QPixmap aPixmap;
  62   QAction* anAction;
  63   QtxAction* aQtxAction;
  64
  65   // --- Menu "File"
  66
  67   // Open File
  68   aPixmap = resMgr->loadPixmap( "ParaView", tr("ICON_OPEN_FILE"), false );
  69   createAction( OpenFileId, tr("TOP_OPEN_FILE"), QIcon(aPixmap),
  70                 tr("MEN_OPEN"), tr("STB_OPEN_FILE"),
  71                 0, desk, false, &Implementation->Core, SLOT( onFileOpen() ) );
  72
  73   // Load State
  74   anAction = createAction( LoadStateId, tr("TOP_LOAD_STATE"), QIcon(),
  75                            tr("MEN_LOAD_STATE"), tr("STB_LOAD_STATE"),
  76                            0, desk, false, &Implementation->Core, SLOT( onFileLoadServerState() ) );
  77   connect( &Implementation->Core, SIGNAL( enableFileLoadServerState(bool) ),
  78            anAction,              SLOT( setEnabled(bool) ) );
  79
  80   // Save State
  81   anAction = createAction( SaveStateId, tr("TOP_SAVE_STATE"), QIcon(),
  82                            tr("MEN_SAVE_STATE"), tr("STB_SAVE_STATE"),
  83                            0, desk, false, &Implementation->Core, SLOT( onFileSaveServerState() ) );
  84   connect( &Implementation->Core, SIGNAL( enableFileSaveServerState(bool) ),
  85            anAction,              SLOT( setEnabled(bool) ) );
  86
  87   // Save Data
  88   aPixmap = resMgr->loadPixmap( "ParaView", tr("ICON_SAVE_DATA"), false );
  89   anAction = createAction( SaveDataId, tr("TOP_SAVE_DATA"), QIcon(aPixmap),
  90                            tr("MEN_SAVE_DATA"), tr("STB_SAVE_DATA"),
  91                            0, desk, false, &Implementation->Core, SLOT( onFileSaveData() ) );
  92   connect( &Implementation->Core, SIGNAL( enableFileSaveData(bool) ),
  93            anAction,              SLOT( setEnabled(bool) ) );
  94
  95   // Save Screenshot
  96   aPixmap = resMgr->loadPixmap( "ParaView", tr("ICON_SAVE_SCREENSHOT"), false );
  97   anAction = createAction( SaveScreenshotId, tr("TOP_SAVE_SCREENSHOT"), QIcon(aPixmap),
  98                            tr("MEN_SAVE_SCREENSHOT"), tr("STB_SAVE_SCREENSHOT"),
  99                            0, desk, false, &Implementation->Core, SLOT( onFileSaveScreenshot() ) );
 100   connect( &Implementation->Core, SIGNAL( enableFileSaveScreenshot(bool) ),
 101            anAction,              SLOT( setEnabled(bool) ) );
 102
 103   // Export
 104   anAction = createAction( ExportId, tr("TOP_EXPORT"), QIcon(),
 105                            tr("MEN_EXPORT"), tr("STB_EXPORT"),
 106                            0, desk, false, &Implementation->Core, SLOT( onFileExport() ) );
 107   connect( &Implementation->Core, SIGNAL( enableExport(bool) ),
 108            anAction,              SLOT( setEnabled(bool) ) );
 109
 110   // Save Animation
 111   aPixmap = resMgr->loadPixmap( "ParaView", tr("ICON_SAVE_ANIMATION"), false );
 112   anAction = createAction( SaveAnimationId, tr("TOP_SAVE_ANIMATION"), QIcon(aPixmap),
 113                            tr("MEN_SAVE_ANIMATION"), tr("STB_SAVE_ANIMATION"),
 114                            0, desk, false, &Implementation->Core, SLOT( onFileSaveAnimation() ) );
 115   connect( &Implementation->Core, SIGNAL( enableFileSaveAnimation(bool) ),
 116            anAction,              SLOT( setEnabled(bool) ) );
 117
 118   // Save Geometry
 119   aPixmap = resMgr->loadPixmap( "ParaView", tr("ICON_SAVE_GEOMETRY"), false );
 120   anAction = createAction( SaveGeometryId, tr("TOP_SAVE_GEOMETRY"), QIcon(aPixmap),
 121                            tr("MEN_SAVE_GEOMETRY"), tr("STB_SAVE_GEOMETRY"),
 122                            0, desk, false, &Implementation->Core, SLOT( onSaveGeometry() ) );
 123   connect( &Implementation->Core, SIGNAL( enableFileSaveGeometry(bool) ),
 124            anAction,              SLOT( setEnabled(bool) ) );
 125
 126   // Connect
 127   aPixmap = resMgr->loadPixmap( "ParaView", tr("ICON_CONNECT"), false );
 128   anAction = createAction( ConnectId, tr("TOP_CONNECT"), QIcon(aPixmap),
 129                            tr("MEN_CONNECT"), tr("STB_CONNECT"),
 130                            0, desk, false, &Implementation->Core, SLOT( onServerConnect() ) );
 131   connect( &Implementation->Core, SIGNAL( enableServerConnect(bool) ),
 132            anAction,              SLOT( setEnabled(bool) ) );
 133
 134   // Disconnect
 135   aPixmap = resMgr->loadPixmap( "ParaView", tr("ICON_DISCONNECT"), false );
 136   anAction = createAction( DisconnectId, tr("TOP_DISCONNECT"), QIcon(aPixmap),
 137                            tr("MEN_DISCONNECT"), tr("STB_DISCONNECT"),
 138                            0, desk, false, &Implementation->Core, SLOT( onServerDisconnect() ) );
 139   connect( &Implementation->Core, SIGNAL( enableServerDisconnect(bool) ),
 140            anAction,              SLOT( setEnabled(bool) ) );
 141
 142   // --- Menu "Edit"
 143
 144   pqUndoStack* undoStack = Implementation->Core.getApplicationUndoStack();
 145
 146   // Undo
 147   aPixmap = resMgr->loadPixmap( "ParaView", tr("ICON_UNDO"), false );
 148   anAction = createAction( UndoId, tr("TOP_UNDO"), QIcon(aPixmap),
 149                            tr("MEN_UNDO"), tr("STB_UNDO"), Qt::CTRL+Qt::Key_Z,
 150                            desk, false, undoStack, SLOT( undo() ) );
 151   connect( undoStack, SIGNAL( canUndoChanged(bool) ),
 152            anAction,  SLOT( setEnabled(bool) ) );
 153   connect( undoStack, SIGNAL( undoLabelChanged(const QString&) ),
 154            this,      SLOT( onUndoLabel(const QString&) ) );
 155   anAction->setEnabled( undoStack->canUndo() );
 156   onUndoLabel(undoStack->undoLabel());
 157
 158   // Redo
 159   aPixmap = resMgr->loadPixmap( "ParaView", tr("ICON_REDO"), false );
 160   anAction = createAction( RedoId, tr("TOP_REDO"), QIcon(aPixmap),
 161                            tr("MEN_REDO"), tr("STB_REDO"), Qt::CTRL+Qt::Key_Y,
 162                            desk, false, undoStack, SLOT( redo() ) );
 163   connect( undoStack, SIGNAL( canRedoChanged(bool) ),
 164            anAction,  SLOT( setEnabled(bool) ) );
 165   connect( undoStack, SIGNAL( redoLabelChanged(const QString&) ),
 166            this,      SLOT( onRedoLabel(const QString&) ) );
 167   anAction->setEnabled( undoStack->canRedo() );
 168   onRedoLabel(undoStack->redoLabel());
 169
 170   // Camera Undo
 171   aPixmap = resMgr->loadPixmap( "ParaView", tr("ICON_CAMERA_UNDO"), false );
 172   anAction = createAction( CameraUndoId, tr("TOP_CAMERA_UNDO"), QIcon(aPixmap),
 173                            tr("MEN_CAMERA_UNDO"), tr("STB_CAMERA_UNDO"), Qt::CTRL+Qt::Key_C+Qt::Key_B,
 174                            desk, false, &Implementation->Core, SLOT( onEditCameraUndo() ) );
 175   connect( &Implementation->Core, SIGNAL( enableCameraUndo(bool) ),
 176            anAction,              SLOT( setEnabled(bool) ) );
 177   connect( &Implementation->Core, SIGNAL( cameraUndoLabel(const QString&) ),
 178            this,                  SLOT( onCameraUndoLabel(const QString&) ) );
 179
 180   // Camera Redo
 181   aPixmap = resMgr->loadPixmap( "ParaView", tr("ICON_CAMERA_REDO"), false );
 182   anAction = createAction( CameraRedoId, tr("TOP_CAMERA_REDO"), QIcon(aPixmap),
 183                            tr("MEN_CAMERA_REDO"), tr("STB_CAMERA_REDO"), Qt::CTRL+Qt::Key_C+Qt::Key_F,
 184                            desk, false, &Implementation->Core, SLOT( onEditCameraRedo() ) );
 185   connect( &Implementation->Core, SIGNAL( enableCameraRedo(bool) ),
 186            anAction,              SLOT( setEnabled(bool) ) );
 187   connect( &Implementation->Core, SIGNAL( cameraRedoLabel(const QString&) ),
 188            this,                  SLOT( onCameraRedoLabel(const QString&) ) );
 189
 190   pqPipelineBrowser* browser = Implementation->Core.pipelineBrowser();
 191
 192   // Change Input
 193   createAction( ChangeInputId, tr("TOP_CHANGE_INPUT"), QIcon(),
 194                 tr("MEN_CHANGE_INPUT"), tr("STB_CHANGE_INPUT"),
 195                 0, desk, false, browser, SLOT( changeInput() ) );
 196
 197   // Delete
 198   createAction( DeleteId, tr("TOP_DELETE"), QIcon(),
 199                 tr("MEN_DELETE"), tr("STB_DELETE"),
 200                 0, desk, false, browser, SLOT( deleteSelected() ) );
 201
 202   // Delet All
 203   createAction( DeleteAllId, tr("TOP_DELETE_ALL"), QIcon(),
 204                 tr("MEN_DELETE_ALL"), tr("STB_DELETE_ALL"),
 205                 0, desk, false, this, SLOT( onDeleteAll() ) );
 206
 207   // Interact
 208   aPixmap = resMgr->loadPixmap( "ParaView", tr("ICON_INTERACT"), false );
 209   anAction = createAction( InteractId, tr("TOP_INTERACT"), QIcon(aPixmap),
 210                            tr("MEN_INTERACT"), tr("STB_INTERACT"), 0, desk, true,
 211                            Implementation->Core.renderViewSelectionHelper(), SLOT( endSelection() ) );
 212   anAction->setChecked( true ); ///!!!
 213   connect( Implementation->Core.renderViewSelectionHelper(), SIGNAL( interactionModeChanged(bool) ),
 214            anAction,                                         SLOT( setChecked(bool) ) );
 215
 216   // Select Cells On
 217   aPixmap = resMgr->loadPixmap( "ParaView", tr("ICON_SELECT_CELLS_ON"), false );
 218   anAction = createAction( SelectCellsOnId, tr("TOP_SELECT_CELLS_ON"), QIcon(aPixmap),
 219                            tr("MEN_SELECT_CELLS_ON"), tr("STB_SELECT_CELLS_ON"), Qt::Key_S, desk, true,
 220                            Implementation->Core.renderViewSelectionHelper(), SLOT( beginSurfaceSelection() ) );
 221   connect( Implementation->Core.renderViewSelectionHelper(), SIGNAL( enableSurfaceSelection(bool) ),
 222            anAction,                                         SLOT( setEnabled(bool) ) );
 223
 224   // Select Points On
 225   aPixmap = resMgr->loadPixmap( "ParaView", tr("ICON_SELECT_POINTS_ON"), false );
 226   anAction = createAction( SelectPointsOnId, tr("TOP_SELECT_POINTS_ON"), QIcon(aPixmap),
 227                            tr("MEN_SELECT_POINTS_ON"), tr("STB_SELECT_POINTS_ON"), 0, desk, true,
 228                            Implementation->Core.renderViewSelectionHelper(), SLOT( beginSurfacePointsSelection() ) );
 229   connect( Implementation->Core.renderViewSelectionHelper(), SIGNAL( enableSurfacePointsSelection(bool) ),
 230            anAction,                                         SLOT( setEnabled(bool) ) );
 231
 232   // Select Cells Through
 233   aPixmap = resMgr->loadPixmap( "ParaView", tr("ICON_SELECT_CELLS_THROUGH"), false );
 234   anAction = createAction( SelectCellsThroughId, tr("TOP_SELECT_CELLS_THROUGH"), QIcon(aPixmap),
 235                            tr("MEN_SELECT_CELLS_THROUGH"), tr("STB_SELECT_CELLS_THROUGH"), 0, desk, true,
 236                            Implementation->Core.renderViewSelectionHelper(), SLOT( beginFrustumSelection() ) );
 237   connect( Implementation->Core.renderViewSelectionHelper(), SIGNAL( enableFrustumSelection(bool) ),
 238            anAction,                                         SLOT( setEnabled(bool) ) );
 239
 240   // Select Points Through
 241   aPixmap = resMgr->loadPixmap( "ParaView", tr("ICON_SELECT_POINTS_THROUGH"), false );
 242   anAction = createAction( SelectPointsThroughId, tr("TOP_SELECT_POINTS_THROUGH"), QIcon(aPixmap),
 243                            tr("MEN_SELECT_POINTS_THROUGH"), tr("STB_SELECT_POINTS_THROUGH"), 0, desk, true,
 244                            Implementation->Core.renderViewSelectionHelper(), SLOT( beginFrustumPointsSelection() ) );
 245   connect( Implementation->Core.renderViewSelectionHelper(), SIGNAL( enableFrustumPointSelection(bool) ),
 246            anAction,                                         SLOT( setEnabled(bool) ) );
 247
 248   // Select Block
 249   aPixmap = resMgr->loadPixmap( "ParaView", tr("ICON_SELECT_BLOCK"), false );
 250   anAction = createAction( SelectBlockId, tr("TOP_SELECT_BLOCK"), QIcon(aPixmap),
 251                            tr("MEN_SELECT_BLOCK"), tr("STB_SELECT_BLOCK"), Qt::Key_B, desk, true,
 252                            Implementation->Core.renderViewSelectionHelper(), SLOT( beginBlockSelection() ) );
 253   connect( Implementation->Core.renderViewSelectionHelper(), SIGNAL( enableBlockSelection(bool) ),
 254            anAction,                                         SLOT( setEnabled(bool) ) );
 255
 256   // Create action group for exclusively selected modes
 257   QActionGroup* aModeGroup = new QActionGroup( desk );
 258   aModeGroup->addAction( action(InteractId) );
 259   aModeGroup->addAction( action(SelectCellsOnId) );
 260   aModeGroup->addAction( action(SelectPointsOnId) );
 261   aModeGroup->addAction( action(SelectCellsThroughId) );
 262   aModeGroup->addAction( action(SelectPointsThroughId) );
 263   aModeGroup->addAction( action(SelectBlockId) );
 264
 265   connect( Implementation->Core.renderViewSelectionHelper(), SIGNAL( selectionModeChanged(int) ),
 266            this,                                             SLOT( onSelectionModeChanged(int) ) );
 267   // When a selection is marked, we revert to interaction mode.
 268   connect( Implementation->Core.renderViewSelectionHelper(), SIGNAL( selectionFinished(int, int, int, int) ),
 269            Implementation->Core.renderViewSelectionHelper(), SLOT( endSelection() ) );
 270
 271   // Setting
 272   createAction( SettingsId, tr("TOP_SETTINGS"), QIcon(),
 273                 tr("MEN_SETTINGS"), tr("STB_SETTINGS"),
 274                 0, desk, false, &Implementation->Core, SLOT( onEditSettings() ) );
 275
 276   // View Settings
 277   createAction( ViewSettingsId, tr("TOP_VIEW_SETTINGS"), QIcon(),
 278                 tr("MEN_VIEW_SETTINGS"), tr("STB_VIEW_SETTINGS"),
 279                 0, desk, false, &Implementation->Core, SLOT( onEditViewSettings() ) );
 280
 281   // --- Menu "View"
 282
 283   // Camera submenu -> Reset
 284   aPixmap = resMgr->loadPixmap( "ParaView", tr("ICON_RESET_CAMERA"), false );
 285   anAction = createAction( ResetCameraId, tr("TOP_RESET_CAMERA"), QIcon(aPixmap),
 286                            tr("MEN_RESET_CAMERA"), tr("STB_RESET_CAMERA"),
 287                            0, desk, false, &Implementation->Core, SLOT( resetCamera() ) );
 288   connect( &Implementation->Core, SIGNAL( enableFileSaveScreenshot(bool) ),
 289            anAction,              SLOT( setEnabled(bool) ) );
 290
 291   // Camera submenu -> +X
 292   aPixmap = resMgr->loadPixmap( "ParaView", tr("ICON_+X"), false );
 293   anAction = createAction( PositiveXId, tr("TOP_+X"), QIcon(aPixmap),
 294                            tr("MEN_+X"), tr("STB_+X"),
 295                            0, desk, false, &Implementation->Core, SLOT( resetViewDirectionPosX() ) );
 296   connect( &Implementation->Core, SIGNAL( enableFileSaveScreenshot(bool) ),
 297            anAction,              SLOT( setEnabled(bool) ) );
 298
 299   // Camera submenu -> -X
 300   aPixmap = resMgr->loadPixmap( "ParaView", tr("ICON_-X"), false );
 301   anAction = createAction( NegativeXId, tr("TOP_-X"), QIcon(aPixmap),
 302                            tr("MEN_-X"), tr("STB_-X"),
 303                            0, desk, false, &Implementation->Core, SLOT( resetViewDirectionNegX() ) );
 304   connect( &Implementation->Core, SIGNAL( enableFileSaveScreenshot(bool) ),
 305            anAction,              SLOT( setEnabled(bool) ) );
 306
 307   // Camera submenu -> +Y
 308   aPixmap = resMgr->loadPixmap( "ParaView", tr("ICON_+Y"), false );
 309   anAction = createAction( PositiveYId, tr("TOP_+Y"), QIcon(aPixmap),
 310                            tr("MEN_+Y"), tr("STB_+Y"),
 311                            0, desk, false, &Implementation->Core, SLOT( resetViewDirectionPosY() ) );
 312   connect( &Implementation->Core, SIGNAL( enableFileSaveScreenshot(bool) ),
 313            anAction,              SLOT( setEnabled(bool) ) );
 314
 315   // Camera submenu -> -Y
 316   aPixmap = resMgr->loadPixmap( "ParaView", tr("ICON_-Y"), false );
 317   anAction = createAction( NegativeYId, tr("TOP_-Y"), QIcon(aPixmap),
 318                            tr("MEN_-Y"), tr("STB_-Y"),
 319                            0, desk, false, &Implementation->Core, SLOT( resetViewDirectionNegY() ) );
 320   connect( &Implementation->Core, SIGNAL( enableFileSaveScreenshot(bool) ),
 321            anAction,              SLOT( setEnabled(bool) ) );
 322
 323   // Camera submenu -> +Z
 324   aPixmap = resMgr->loadPixmap( "ParaView", tr("ICON_+Z"), false );
 325   anAction = createAction( PositiveZId, tr("TOP_+Z"), QIcon(aPixmap),
 326                            tr("MEN_+Z"), tr("STB_+Z"),
 327                            0, desk, false, &Implementation->Core, SLOT( resetViewDirectionPosZ() ) );
 328   connect( &Implementation->Core, SIGNAL( enableFileSaveScreenshot(bool) ),
 329            anAction,              SLOT( setEnabled(bool) ) );
 330
 331   // Camera submenu -> -Z
 332   aPixmap = resMgr->loadPixmap( "ParaView", tr("ICON_-Z"), false );
 333   anAction = createAction( NegativeZId, tr("TOP_-Z"), QIcon(aPixmap),
 334                            tr("MEN_-Z"), tr("STB_-Z"),
 335                            0, desk, false, &Implementation->Core, SLOT( resetViewDirectionNegZ() ) );
 336   connect( &Implementation->Core, SIGNAL( enableFileSaveScreenshot(bool) ),
 337            anAction,              SLOT( setEnabled(bool) ) );
 338
 339   // Show Center
 340   aPixmap = resMgr->loadPixmap( "ParaView", tr("ICON_SHOW_CENTER"), false );
 341   aQtxAction = new QtxAction( tr("TOP_SHOW_CENTER"), QIcon(aPixmap),
 342                               tr("MEN_SHOW_CENTER"), 0, desk );
 343   aQtxAction->setStatusTip( tr( "PRP_APP_SHOW_CENTER" ) );
 344   aQtxAction->setCheckable( true );
 345   registerAction( ShowCenterId, aQtxAction );
 346   connect( aQtxAction,            SIGNAL( toggled(bool) ),
 347            &Implementation->Core, SLOT( setCenterAxesVisibility(bool) ) );
 348   connect( &Implementation->Core, SIGNAL( enableShowCenterAxis(bool) ),
 349            this,                  SLOT( onShowCenterAxisChanged(bool) ), Qt::QueuedConnection );
 350
 351   // Reset Center
 352   aPixmap = resMgr->loadPixmap( "ParaView", tr("ICON_RESET_CENTER"), false );
 353   anAction = createAction( ResetCenterId, tr("TOP_RESET_CENTER"), QIcon(aPixmap),
 354                            tr("MEN_RESET_CENTER"), tr("STB_RESET_CENTER"), 0, desk, false,
 355                            &Implementation->Core, SLOT( resetCenterOfRotationToCenterOfCurrentData() ) );
 356   connect( &Implementation->Core, SIGNAL( enableResetCenter(bool) ),
 357            anAction,              SLOT( setEnabled(bool) ) );
 358
 359   // Pick Center
 360   aPixmap = resMgr->loadPixmap( "ParaView", tr("ICON_PICK_CENTER"), false );
 361   aQtxAction = new QtxAction( tr("TOP_PICK_CENTER"), QIcon(aPixmap),
 362                               tr("MEN_PICK_CENTER"), 0, desk );
 363   aQtxAction->setStatusTip( tr( "PRP_APP_PICK_CENTER" ) );
 364   aQtxAction->setCheckable( true );
 365   registerAction( PickCenterId, aQtxAction );
 366   connect( aQtxAction,            SIGNAL( toggled(bool) ),
 367            &Implementation->Core, SLOT( pickCenterOfRotation(bool) ) );
 368   connect( &Implementation->Core, SIGNAL( enablePickCenter(bool) ),
 369            aQtxAction,            SLOT( setEnabled(bool) ) );
 370   connect( &Implementation->Core, SIGNAL( pickingCenter(bool) ),
 371            aQtxAction,            SLOT( setChecked(bool) ) );
 372
 373   // Show Color Legend
 374   aPixmap = resMgr->loadPixmap( "ParaView", tr("ICON_SHOW_COLOR_LEGEND"), false );
 375   aQtxAction = new QtxAction( tr("TOP_SHOW_COLOR_LEGEND"), QIcon(aPixmap),
 376                               tr("MEN_SHOW_COLOR_LEGEND"), 0, desk );
 377   aQtxAction->setStatusTip( tr( "PRP_APP_SHOW_COLOR_LEGEND" ) );
 378   aQtxAction->setCheckable( true );
 379   aQtxAction->setEnabled(false);
 380   registerAction( ShowColorLegendId, aQtxAction );
 381   pqScalarBarVisibilityAdaptor* sbva = new pqScalarBarVisibilityAdaptor( aQtxAction );
 382   connect( Implementation->Core.getObjectInspectorDriver(),
 383            SIGNAL( representationChanged(pqDataRepresentation*, pqView*) ),
 384            sbva,
 385            SLOT( setActiveRepresentation(pqDataRepresentation*) ) );
 386
 387   // --- Menu "Sources" and "Filters"
 388   // As ParaView is responsible for updating "Sources" and "Filters" menus,
 389   // actions for these menus are created inside the pqMainWindowCore.
 390   // So, the creation of corresponding QMenu object is in the PVGUI_Module::pvCreateMenus().
 391
 392   // --- Menu "Animation"
 393
 394   pqVCRController* vcrcontroller = &Implementation->Core.VCRController();
 395
 396   // First Frame
 397   aPixmap = resMgr->loadPixmap( "ParaView", tr("ICON_FIRST_FRAME"), false );
 398   anAction = createAction( FirstFrameId, tr("TOP_FIRST_FRAME"), QIcon(aPixmap),
 399                            tr("MEN_FIRST_FRAME"), tr("STB_FIRST_FRAME"),
 400                            0, desk, false, vcrcontroller, SLOT( onFirstFrame() ) );
 401   connect( vcrcontroller, SIGNAL( enabled(bool) ), anAction, SLOT( setEnabled(bool) ) );
 402
 403   // Previous Frame
 404   aPixmap = resMgr->loadPixmap( "ParaView", tr("ICON_PREVIOUS_FRAME"), false );
 405   anAction = createAction( PreviousFrameId, tr("TOP_PREVIOUS_FRAME"), QIcon(aPixmap),
 406                            tr("MEN_PREVIOUS_FRAME"), tr("STB_PREVIOUS_FRAME"),
 407                            0, desk, false, vcrcontroller, SLOT( onPreviousFrame() ) );
 408   connect( vcrcontroller, SIGNAL( enabled(bool) ), anAction, SLOT( setEnabled(bool) ) );
 409
 410   // Play
 411   aPixmap = resMgr->loadPixmap( "ParaView", tr("ICON_PLAY"), false );
 412   anAction = createAction( PlayId, tr("TOP_PLAY"), QIcon(aPixmap),
 413                            tr("MEN_PLAY"), tr("STB_PLAY"),
 414                            0, desk, false, vcrcontroller, SLOT( onPlay() ) );
 415   connect( vcrcontroller, SIGNAL( enabled(bool) ), anAction, SLOT( setEnabled(bool) ) );
 416
 417   // Next Frame
 418   aPixmap = resMgr->loadPixmap( "ParaView", tr("ICON_NEXT_FRAME"), false );
 419   anAction = createAction( NextFrameId, tr("TOP_NEXT_FRAME"), QIcon(aPixmap),
 420                            tr("MEN_NEXT_FRAME"), tr("STB_NEXT_FRAME"),
 421                            0, desk, false, vcrcontroller, SLOT( onNextFrame() ) );
 422   connect( vcrcontroller, SIGNAL( enabled(bool) ), anAction, SLOT( setEnabled(bool) ) );
 423
 424   // Last Frame
 425   aPixmap = resMgr->loadPixmap( "ParaView", tr("ICON_LAST_FRAME"), false );
 426   anAction = createAction( LastFrameId, tr("TOP_LAST_FRAME"), QIcon(aPixmap),
 427                            tr("MEN_LAST_FRAME"), tr("STB_LAST_FRAME"),
 428                            0, desk, false, vcrcontroller, SLOT( onLastFrame() ) );
 429   connect( vcrcontroller, SIGNAL( enabled(bool) ), anAction, SLOT( setEnabled(bool) ) );
 430
 431   // Loop
 432   aPixmap = resMgr->loadPixmap( "ParaView", tr("ICON_LOOP"), false );
 433   aQtxAction = new QtxAction( tr("TOP_LOOP"), QIcon(aPixmap),
 434                               tr("MEN_LOOP"), 0, desk );
 435   aQtxAction->setStatusTip( tr( "PRP_APP_LOOP" ) );
 436   aQtxAction->setCheckable(true);
 437   registerAction( LoopId, aQtxAction );
 438   connect( aQtxAction,    SIGNAL( toggled(bool) ), vcrcontroller, SLOT( onLoop(bool) ) );
 439   connect( vcrcontroller, SIGNAL( enabled(bool) ), aQtxAction,    SLOT( setEnabled(bool) ) );
 440   connect( vcrcontroller, SIGNAL( loop(bool) ),    aQtxAction,    SLOT( setChecked(bool) ) );
 441
 442   connect( vcrcontroller, SIGNAL( playing(bool) ), this, SLOT( onPlaying(bool) ) );
 443   connect( vcrcontroller, SIGNAL( timeRanges(double, double) ),
 444            this,          SLOT( setTimeRanges(double, double) ) );
 445
 446   // --- Menu "Tools"
 447
 448   // Create Custom Filter
 449   createAction( CreateCustomFilterId, tr("TOP_CREATE_CUSTOM_FILTER"), QIcon(),
 450                 tr("MEN_CREATE_CUSTOM_FILTER"), tr("STB_CREATE_CUSTOM_FILTER"),
 451                 0, desk, false, &Implementation->Core, SLOT( onToolsCreateCustomFilter() ) );
 452
 453   // Manage Custom Filters
 454   createAction( ManageCustomFiltersId, tr("TOP_MANAGE_CUSTOM_FILTERS"), QIcon(),
 455                 tr("MEN_MANAGE_CUSTOM_FILTERS"), tr("STB_MANAGE_CUSTOM_FILTERS"),
 456                 0, desk, false, &Implementation->Core, SLOT( onToolsManageCustomFilters() ) );
 457
 458   // Create Lookmark
 459   createAction( CreateLookmarkId, tr("TOP_CREATE_LOOKMARK"), QIcon(),
 460                 tr("MEN_CREATE_LOOKMARK"), tr("STB_CREATE_LOOKMARK"),
 461                 0, desk, false, &Implementation->Core, SLOT( onToolsCreateLookmark() ) );
 462
 463   // Manage Links
 464   createAction( ManageLinksId, tr("TOP_MANAGE_LINKS"), QIcon(),
 465                 tr("MEN_MANAGE_LINKS"), tr("STB_MANAGE_LINKS"),
 466                 0, desk, false, &Implementation->Core, SLOT( onToolsManageLinks() ) );
 467
 468   // Add Camera Link
 469   createAction( AddCameraLinkId, tr("TOP_ADD_CAMERA_LINK"), QIcon(),
 470                 tr("MEN_ADD_CAMERA_LINK"), tr("STB_ADD_CAMERA_LINK"),
 471                 0, desk, false, this, SLOT( onAddCameraLink() ) );
 472
 473   // Manage Plugins/Extensions
 474   createAction( ManagePluginsExtensionsId, tr( "TOP_MANAGE_PLUGINS" ), QIcon(),
 475                 tr( "MEN_MANAGE_PLUGINS" ), tr( "STB_MANAGE_PLUGINS" ),
 476                 0, desk, false, &Implementation->Core, SLOT( onManagePlugins() ) );
 477
 478   // Dump Widget Names
 479   createAction( DumpWidgetNamesId, tr( "TOP_DUMP_WIDGET_NAMES" ), QIcon(),
 480                 tr( "MEN_DUMP_WIDGET_NAMES" ), tr( "STB_DUMP_WIDGET_NAMES" ),
 481                 0, desk, false, &Implementation->Core, SLOT( onToolsDumpWidgetNames() ) );
 482
 483   // Record Test
 484   createAction( RecordTestId, tr( "TOP_RECORD_TEST" ), QIcon(),
 485                 tr( "MEN_RECORD_TEST" ), tr( "STB_RECORD_TEST" ),
 486                 0, desk, false, &Implementation->Core, SLOT( onToolsRecordTest() ) );
 487
 488   // Record Test Screenshot
 489   createAction( RecordTestScreenshotId, tr( "TOP_RECORD_TEST_SCREENSHOT" ), QIcon(),
 490                 tr( "MEN_RECORD_TEST_SCREENSHOT" ), tr( "STB_RECORD_TEST_SCREENSHOT" ),
 491                 0, desk, false, &Implementation->Core, SLOT( onToolsRecordTestScreenshot() ) );
 492
 493   // Play Test
 494   createAction( PlayTestId, tr( "TOP_PLAY_TEST" ), QIcon(),
 495                 tr( "MEN_PLAY_TEST" ), tr( "STB_PLAY_TEST" ),
 496                 0, desk, false, &Implementation->Core, SLOT( onToolsPlayTest() ) );
 497
 498   // Max Window Size
 499   aQtxAction = new QtxAction( tr("TOP_MAX_WINDOW_SIZE"), QIcon(),
 500                               tr("MEN_MAX_WINDOW_SIZE"), 0, desk );
 501   aQtxAction->setStatusTip( tr( "PRP_APP_MAX_WINDOW_SIZE" ) );
 502   aQtxAction->setCheckable(true);
 503   registerAction( MaxWindowSizeId, aQtxAction );
 504   connect( aQtxAction, SIGNAL( toggled(bool) ), &Implementation->Core, SLOT( enableTestingRenderWindowSize(bool) ) );
 505
 506   // Timer Log
 507   createAction( TimerLogId, tr( "TOP_TIMER_LOG" ), QIcon(),
 508                 tr( "MEN_TIMER_LOG" ), tr( "STB_TIMER_LOG" ),
 509                 0, desk, false, &Implementation->Core, SLOT( onToolsTimerLog() ) );
 510
 511   // Output Window
 512   createAction( OutputWindowId, tr( "TOP_OUTPUT_WINDOW" ), QIcon(),
 513                 tr( "MEN_OUTPUT_WINDOW" ), tr( "STB_OUTPUT_WINDOW" ),
 514                 0, desk, false, &Implementation->Core, SLOT( onToolsOutputWindow() ) );
 515
 516   // Python Shell
 517   createAction( PythonShellId, tr( "TOP_PYTHON_SHELL" ), QIcon(),
 518                 tr( "MEN_PYTHON_SHELL" ), tr( "STB_PYTHON_SHELL" ),
 519                 0, desk, false, &Implementation->Core, SLOT( onToolsPythonShell() ) );
 520
 521   // --- Menu "Help"
 522
 523   // About
 524   createAction( AboutParaViewId, tr( "TOP_ABOUT" ), QIcon(),
 525                 tr( "MEN_ABOUT" ), tr( "STB_ABOUT" ),
 526                 0, desk, false, this, SLOT( onHelpAbout() ) );
 527
 528   // ParaView Help
 529   // TODO...
 530
 531   // Enable Tooltips
 532   aQtxAction = new QtxAction( tr("TOP_ENABLE_TOOLTIPS"), QIcon(),
 533                               tr("MEN_ENABLE_TOOLTIPS"), 0, desk );
 534   aQtxAction->setStatusTip( tr( "PRP_APP_ENABLE_TOOLTIPS" ) );
 535   aQtxAction->setCheckable(true);
 536   aQtxAction->setChecked(true);
 537   registerAction( EnableTooltipsId, aQtxAction );
 538 }
 539
 540 /*!
 541   \brief Create menus for ParaView GUI operations
 542   duplicating menus in pqMainWindow ParaView class
 543
 544   In particular, ParaView is responsible for updating "Sources" and "Filters" menus.
 545   For this, specific menu managers created by pqMainWindowCore class are used, and PVGUI_Module
 546   is responsible for creation of corresponding QMenu objects only.
 547 */
 548 void PVGUI_Module::pvCreateMenus()
 549 {
 550   // --- Menu "File"
 551   int aPVMnu = createMenu( tr( "MEN_DESK_FILE" ), -1, -1 );
 552
 553   createMenu( OpenFileId, aPVMnu, 5 );
 554   createMenu( separator(), aPVMnu, -1, 5 );
 555
 556   createMenu( LoadStateId, aPVMnu, 15 );
 557   createMenu( SaveStateId, aPVMnu, 15 );
 558   createMenu( separator(), aPVMnu, -1, 15 );
 559
 560   createMenu( SaveDataId, aPVMnu, 25 );
 561   createMenu( SaveScreenshotId, aPVMnu, 25 );
 562   createMenu( ExportId, aPVMnu, 25 );
 563   createMenu( separator(), aPVMnu, -1, 25 );
 564
 565   createMenu( SaveAnimationId, aPVMnu, 35 );
 566   createMenu( SaveGeometryId, aPVMnu, 35 );
 567   createMenu( separator(), aPVMnu, -1, 35 );
 568
 569   createMenu( ConnectId, aPVMnu, 45 );
 570   createMenu( DisconnectId, aPVMnu, 45 );
 571   createMenu( separator(), aPVMnu, -1, 45 );
 572
 573   // --- Menu "Edit"
 574   aPVMnu = createMenu( tr( "MEN_DESK_EDIT" ), -1, -1 );
 575
 576   createMenu( UndoId, aPVMnu );
 577   createMenu( RedoId, aPVMnu );
 578   createMenu( separator(), aPVMnu );
 579
 580   createMenu( CameraUndoId, aPVMnu );
 581   createMenu( CameraRedoId, aPVMnu );
 582   createMenu( separator(), aPVMnu );
 583
 584   createMenu( ChangeInputId, aPVMnu );
 585   createMenu( DeleteId, aPVMnu );
 586   createMenu( DeleteAllId, aPVMnu );
 587   createMenu( separator(), aPVMnu );
 588
 589   createMenu( InteractId, aPVMnu );
 590   createMenu( SelectCellsOnId, aPVMnu );
 591   createMenu( SelectPointsOnId, aPVMnu );
 592   createMenu( SelectCellsThroughId, aPVMnu );
 593   createMenu( SelectPointsThroughId, aPVMnu );
 594   createMenu( SelectBlockId, aPVMnu );
 595   createMenu( separator(), aPVMnu );
 596
 597   createMenu( SettingsId, aPVMnu );
 598   createMenu( ViewSettingsId, aPVMnu );
 599   createMenu( separator(), aPVMnu );
 600
 601   // --- Menu "View"
 602   aPVMnu = createMenu( tr( "MEN_DESK_VIEW" ), -1, -1 );
 603
 604   int aCameraMnu = createMenu( tr( "MEN_CAMERA" ), aPVMnu );
 605   createMenu( ResetCameraId, aCameraMnu );
 606   createMenu( PositiveXId, aCameraMnu );
 607   createMenu( NegativeXId, aCameraMnu );
 608   createMenu( PositiveYId, aCameraMnu );
 609   createMenu( NegativeYId, aCameraMnu );
 610   createMenu( PositiveZId, aCameraMnu );
 611   createMenu( NegativeZId, aCameraMnu );
 612   createMenu( separator(), aPVMnu );
 613
 614   createMenu( ShowCenterId, aPVMnu );
 615   createMenu( ResetCenterId, aPVMnu );
 616   createMenu( PickCenterId, aPVMnu );
 617   createMenu( ShowColorLegendId, aPVMnu );
 618   createMenu( separator(), aPVMnu );
 619
 620   // --- Menu "Sources"
 621
 622   // Install ParaView managers for "Sources" menu
 623   QMenu* aRes = 0;
 624   aPVMnu = createMenu( tr( "MEN_DESK_SOURCES" ), -1, -1, 60 );
 625   if ( (aRes = getMenu( aPVMnu )) ) {
 626     Implementation->Core.setSourceMenu( aRes );
 627     connect( &Implementation->Core, SIGNAL( enableSourceCreate(bool) ),
 628              aRes,                  SLOT( setEnabled(bool) ) );
 629   }
 630
 631   // --- Menu "Filters"
 632
 633   // Install ParaView managers for "Filters" menu
 634   aPVMnu = createMenu( tr( "MEN_DESK_FILTERS" ), -1, -1, 70 );
 635   if ( (aRes = getMenu( aPVMnu )) ) {
 636     Implementation->Core.setFilterMenu( aRes );
 637     connect( &Implementation->Core, SIGNAL( enableFilterCreate(bool) ),
 638              aRes,                  SLOT( setEnabled(bool) ) );
 639   }
 640
 641   // --- Menu "Animation"
 642   int anAnimationMnu = createMenu( tr( "MEN_DESK_ANIMATION" ), -1, -1, 80 );
 643
 644   createMenu( FirstFrameId, anAnimationMnu );
 645   createMenu( PreviousFrameId, anAnimationMnu );
 646   createMenu( PlayId, anAnimationMnu );
 647   createMenu( NextFrameId, anAnimationMnu );
 648   createMenu( LastFrameId, anAnimationMnu );
 649   createMenu( LoopId, anAnimationMnu );
 650
 651   // --- Menu "Tools"
 652
 653   int aToolsMnu = createMenu( tr( "MEN_DESK_TOOLS" ), -1, -1, 90 );
 654
 655   createMenu( CreateCustomFilterId, aToolsMnu );
 656   createMenu( ManageCustomFiltersId, aToolsMnu );
 657   createMenu( CreateLookmarkId, aToolsMnu );
 658   createMenu( ManageLinksId, aToolsMnu );
 659   createMenu( AddCameraLinkId, aToolsMnu );
 660   createMenu( ManagePluginsExtensionsId, aToolsMnu );
 661   createMenu( separator(), aToolsMnu );
 662
 663   createMenu( DumpWidgetNamesId, aToolsMnu );
 664   createMenu( RecordTestId, aToolsMnu );
 665   createMenu( RecordTestScreenshotId, aToolsMnu );
 666   createMenu( PlayTestId, aToolsMnu );
 667   createMenu( MaxWindowSizeId, aToolsMnu );
 668   createMenu( separator(), aToolsMnu );
 669
 670   createMenu( TimerLogId, aToolsMnu );
 671   createMenu( OutputWindowId, aToolsMnu );
 672   createMenu( separator(), aToolsMnu );
 673
 674   createMenu( PythonShellId, aToolsMnu );
 675
 676   // --- Menu "Help"
 677
 678   int aHelpMnu = createMenu( tr( "MEN_DESK_HELP" ), -1, -1 );
 679
 680   createMenu( AboutParaViewId, aHelpMnu );
 681   // ParaView Help
 682   // It's needed to install module docs into <module>_ROOT_DIR/share/doc/salome/gui/<module>
 683   // createMenu( ParaViewHelpId, aHelpMnu );
 684   createMenu( EnableTooltipsId, aHelpMnu );
 685   createMenu( separator(), aHelpMnu );
 686
 687 }
 688
 689 /*!
 690   \brief Create toolbars for ParaView GUI operations
 691   duplicating toolbars in pqMainWindow ParaView class
 692 */
 693 void PVGUI_Module::pvCreateToolBars()
 694 {
 695   SUIT_Desktop* desk = application()->desktop();
 696   SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
 697
 698   QPixmap aPixmap;
 699   QtxAction* aQtxAction;
 700
 701   // --- Toolbar "Main Controls"
 702
 703   int aToolId = createTool( tr("TOOL_MAIN_CONTROLS") );
 704
 705   createTool( OpenFileId, aToolId );
 706   createTool( SaveDataId, aToolId );
 707   createTool( separator(), aToolId );
 708   createTool( ConnectId, aToolId );
 709   createTool( DisconnectId, aToolId );
 710   //createTool( separator(), aToolId );
 711   //createTool( ParaViewHelpId, aToolId );
 712
 713   // --- Toolbar "Selection Controls"
 714
 715   mySelectionControlsTb = createTool( tr("TOOL_SELECTION_CONTROLS") );
 716
 717   createTool( InteractId, mySelectionControlsTb );
 718   createTool( SelectCellsOnId, mySelectionControlsTb );
 719   createTool( SelectPointsOnId, mySelectionControlsTb );
 720   createTool( SelectCellsThroughId, mySelectionControlsTb );
 721   createTool( SelectPointsThroughId, mySelectionControlsTb );
 722   createTool( SelectBlockId, mySelectionControlsTb );
 723
 724   // --- Toolbar "Undo/Redo Controls"
 725
 726   aToolId = createTool( tr("TOOL_UNDOREDO_CONTROLS") );
 727
 728   createTool( UndoId, aToolId );
 729   createTool( RedoId, aToolId );
 730
 731   // --- Toolbar "VCR Controls"
 732
 733   aToolId = createTool( tr("TOOL_VCR_CONTROLS") );
 734
 735   createTool( FirstFrameId, aToolId );
 736   createTool( PreviousFrameId, aToolId );
 737   createTool( PlayId, aToolId );
 738   createTool( NextFrameId, aToolId );
 739   createTool( LastFrameId, aToolId );
 740   createTool( LoopId, aToolId );
 741
 742   pqProgressManager* progress_manager = pqApplicationCore::instance()->getProgressManager();
 743   progress_manager->addNonBlockableObject( toolMgr()->toolBar( aToolId ) );
 744
 745   // --- Toolbar "Active Variable Controls"
 746
 747   aToolId = createTool( tr("TOOL_ACTIVE_VARIABLE_CONTROLS") );
 748   QToolBar* aTB = toolMgr()->toolBar( aToolId );
 749
 750   createTool( ShowColorLegendId, aToolId );
 751
 752   // To set up the color map tool buttons.
 753   pqColorScaleToolbar* colorScale = Implementation->Core.getColorScaleEditorManager();
 754
 755   // Edit Color Map
 756   aPixmap = resMgr->loadPixmap( "ParaView", tr("ICON_EDIT_COLOR_MAP"), false );
 757   aQtxAction = new QtxAction( tr("TOP_EDIT_COLOR_MAP"), QIcon(aPixmap),
 758                               tr("MEN_EDIT_COLOR_MAP"), 0, desk );
 759   aQtxAction->setStatusTip( tr( "PRP_APP_EDIT_COLOR_MAP" ) );
 760   registerAction( EditColorMapId, aQtxAction );
 761   connect( &Implementation->Core, SIGNAL( enableVariableToolbar(bool) ),
 762            aQtxAction,            SLOT( setEnabled(bool) ) );
 763   colorScale->setColorAction( aQtxAction ); /// !!!
 764   createTool( EditColorMapId, aToolId );
 765
 766   // Reset Range
 767   aPixmap = resMgr->loadPixmap( "ParaView", tr("ICON_RESET_RANGE"), false );
 768   aQtxAction = new QtxAction( tr("TOP_RESET_RANGE"), QIcon(aPixmap),
 769                               tr("MEN_RESET_RANGE"), 0, desk );
 770   aQtxAction->setStatusTip( tr( "PRP_APP_RESET_RANGE" ) );
 771   registerAction( ResetRangeId, aQtxAction );
 772   connect( &Implementation->Core, SIGNAL( enableVariableToolbar(bool) ),
 773            aQtxAction,            SLOT( setEnabled(bool) ) );
 774   colorScale->setRescaleAction( aQtxAction ); /// !!!
 775   createTool( ResetRangeId, aToolId );
 776
 777   Implementation->Core.setupVariableToolbar(aTB);
 778   QList<QAction*> anActns = aTB->actions();
 779   for (int i = 0; i < anActns.size(); ++i)
 780     if ( anActns.at(i) != action(ShowColorLegendId) ) {
 781       createTool( anActns.at(i), aToolId );
 782       connect( &Implementation->Core, SIGNAL( enableVariableToolbar(bool) ),
 783                anActns.at(i),         SLOT( setEnabled(bool) ) );
 784     }
 785
 786   // --- Toolbar "Representation"
 787
 788   aTB = toolMgr()->toolBar( createTool( tr("TOOL_REPRESENTATION") ) );
 789   Implementation->Core.setupRepresentationToolbar(aTB);
 790   anActns = aTB->actions();
 791   for (int i = 0; i < anActns.size(); ++i)
 792     connect( &Implementation->Core, SIGNAL( enableVariableToolbar(bool) ),
 793              anActns.at(i),         SLOT( setEnabled(bool) ) );
 794
 795   // --- Toolbar "Camera Controls"
 796
 797   aToolId = createTool( tr("TOOL_CAMERA_CONTROLS") );
 798
 799   createTool( ResetCameraId, aToolId );
 800   createTool( PositiveXId, aToolId );
 801   createTool( NegativeXId, aToolId );
 802   createTool( PositiveYId, aToolId );
 803   createTool( NegativeYId, aToolId );
 804   createTool( PositiveZId, aToolId );
 805   createTool( NegativeZId, aToolId );
 806
 807   // --- Toolbar "Center Axes Controls"
 808
 809   aToolId = createTool( tr("TOOL_CENTER_AXES_CONTROLS") );
 810
 811   createTool( ShowCenterId, aToolId );
 812   createTool( ResetCenterId, aToolId );
 813   createTool( PickCenterId, aToolId );
 814
 815   // --- Toolbar "Common Filters"
 816
 817   aTB = toolMgr()->toolBar( createTool( tr("TOOL_COMMON_FILTERS") ) );
 818   Implementation->Core.setupCommonFiltersToolbar(aTB);
 819   //QList<QAction*> anActns = aTB->actions();
 820   //for (int i = 0; i < anActns.size(); ++i)
 821   //  createTool(anActns.at(i),aToolId); /// !!!
 822
 823   // --- Toolbar "Lookmarks"
 824
 825   aTB = toolMgr()->toolBar(createTool( tr("TOOL_LOOKMARKS") ));
 826   aTB->setContextMenuPolicy(Qt::CustomContextMenu);
 827   aTB->setOrientation(Qt::Vertical);
 828   Implementation->Core.setupLookmarkToolbar(aTB);
 829 }
 830
 831 /*!
 832   \brief Returns QMenu by its id.
 833 */
 834 QMenu* PVGUI_Module::getMenu( const int id )
 835 {
 836   QMenu* res = 0;
 837   LightApp_Application* anApp = getApp();
 838   SUIT_Desktop* desk = anApp->desktop();
 839   if ( desk ){
 840     QtxActionMenuMgr* menuMgr = desk->menuMgr();
 841     res = menuMgr->findMenu( id );
 842   }
 843   return res;
 844 }