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
 555   // Recent Files
 556   Implementation->RecentFilesMenu =
 557     new pqRecentFilesMenu( *menuMgr()->findMenu( createMenu( tr( "MEN_RECENT_FILES" ), aPVMnu, -1, 5 ) ),
 558                            getApp()->desktop() );
 559   connect( Implementation->RecentFilesMenu, SIGNAL( serverConnectFailed() ),
 560            &Implementation->Core,           SLOT( makeDefaultConnectionIfNoneExists() ) );
 561
 562   createMenu( separator(), aPVMnu, -1, 5 );
 563
 564   createMenu( LoadStateId, aPVMnu, 15 );
 565   createMenu( SaveStateId, aPVMnu, 15 );
 566   createMenu( separator(), aPVMnu, -1, 15 );
 567
 568   createMenu( SaveDataId, aPVMnu, 25 );
 569   createMenu( SaveScreenshotId, aPVMnu, 25 );
 570   createMenu( ExportId, aPVMnu, 25 );
 571   createMenu( separator(), aPVMnu, -1, 25 );
 572
 573   createMenu( SaveAnimationId, aPVMnu, 35 );
 574   createMenu( SaveGeometryId, aPVMnu, 35 );
 575   createMenu( separator(), aPVMnu, -1, 35 );
 576
 577   createMenu( ConnectId, aPVMnu, 45 );
 578   createMenu( DisconnectId, aPVMnu, 45 );
 579   createMenu( separator(), aPVMnu, -1, 45 );
 580
 581   // --- Menu "Edit"
 582   aPVMnu = createMenu( tr( "MEN_DESK_EDIT" ), -1, -1 );
 583
 584   createMenu( UndoId, aPVMnu );
 585   createMenu( RedoId, aPVMnu );
 586   createMenu( separator(), aPVMnu );
 587
 588   createMenu( CameraUndoId, aPVMnu );
 589   createMenu( CameraRedoId, aPVMnu );
 590   createMenu( separator(), aPVMnu );
 591
 592   createMenu( ChangeInputId, aPVMnu );
 593   createMenu( DeleteId, aPVMnu );
 594   createMenu( DeleteAllId, aPVMnu );
 595   createMenu( separator(), aPVMnu );
 596
 597   createMenu( InteractId, aPVMnu );
 598   createMenu( SelectCellsOnId, aPVMnu );
 599   createMenu( SelectPointsOnId, aPVMnu );
 600   createMenu( SelectCellsThroughId, aPVMnu );
 601   createMenu( SelectPointsThroughId, aPVMnu );
 602   createMenu( SelectBlockId, aPVMnu );
 603   createMenu( separator(), aPVMnu );
 604
 605   createMenu( SettingsId, aPVMnu );
 606   createMenu( ViewSettingsId, aPVMnu );
 607   createMenu( separator(), aPVMnu );
 608
 609   // --- Menu "View"
 610   aPVMnu = createMenu( tr( "MEN_DESK_VIEW" ), -1, -1 );
 611
 612   int aCameraMnu = createMenu( tr( "MEN_CAMERA" ), aPVMnu );
 613   createMenu( ResetCameraId, aCameraMnu );
 614   createMenu( PositiveXId, aCameraMnu );
 615   createMenu( NegativeXId, aCameraMnu );
 616   createMenu( PositiveYId, aCameraMnu );
 617   createMenu( NegativeYId, aCameraMnu );
 618   createMenu( PositiveZId, aCameraMnu );
 619   createMenu( NegativeZId, aCameraMnu );
 620   createMenu( separator(), aPVMnu );
 621
 622   createMenu( ShowCenterId, aPVMnu );
 623   createMenu( ResetCenterId, aPVMnu );
 624   createMenu( PickCenterId, aPVMnu );
 625   createMenu( ShowColorLegendId, aPVMnu );
 626   createMenu( separator(), aPVMnu );
 627
 628   // --- Menu "Sources"
 629
 630   // Install ParaView managers for "Sources" menu
 631   QMenu* aRes = 0;
 632   aPVMnu = createMenu( tr( "MEN_DESK_SOURCES" ), -1, -1, 60 );
 633   if ( (aRes = getMenu( aPVMnu )) ) {
 634     Implementation->Core.setSourceMenu( aRes );
 635     connect( &Implementation->Core, SIGNAL( enableSourceCreate(bool) ),
 636              aRes,                  SLOT( setEnabled(bool) ) );
 637   }
 638
 639   // --- Menu "Filters"
 640
 641   // Install ParaView managers for "Filters" menu
 642   aPVMnu = createMenu( tr( "MEN_DESK_FILTERS" ), -1, -1, 70 );
 643   if ( (aRes = getMenu( aPVMnu )) ) {
 644     Implementation->Core.setFilterMenu( aRes );
 645     connect( &Implementation->Core, SIGNAL( enableFilterCreate(bool) ),
 646              aRes,                  SLOT( setEnabled(bool) ) );
 647   }
 648
 649   // --- Menu "Animation"
 650   int anAnimationMnu = createMenu( tr( "MEN_DESK_ANIMATION" ), -1, -1, 80 );
 651
 652   createMenu( FirstFrameId, anAnimationMnu );
 653   createMenu( PreviousFrameId, anAnimationMnu );
 654   createMenu( PlayId, anAnimationMnu );
 655   createMenu( NextFrameId, anAnimationMnu );
 656   createMenu( LastFrameId, anAnimationMnu );
 657   createMenu( LoopId, anAnimationMnu );
 658
 659   // --- Menu "Tools"
 660
 661   int aToolsMnu = createMenu( tr( "MEN_DESK_TOOLS" ), -1, -1, 90 );
 662
 663   createMenu( CreateCustomFilterId, aToolsMnu );
 664   createMenu( ManageCustomFiltersId, aToolsMnu );
 665   createMenu( CreateLookmarkId, aToolsMnu );
 666   createMenu( ManageLinksId, aToolsMnu );
 667   createMenu( AddCameraLinkId, aToolsMnu );
 668   createMenu( ManagePluginsExtensionsId, aToolsMnu );
 669   createMenu( separator(), aToolsMnu );
 670
 671   createMenu( DumpWidgetNamesId, aToolsMnu );
 672   createMenu( RecordTestId, aToolsMnu );
 673   createMenu( RecordTestScreenshotId, aToolsMnu );
 674   createMenu( PlayTestId, aToolsMnu );
 675   createMenu( MaxWindowSizeId, aToolsMnu );
 676   createMenu( separator(), aToolsMnu );
 677
 678   createMenu( TimerLogId, aToolsMnu );
 679   createMenu( OutputWindowId, aToolsMnu );
 680   createMenu( separator(), aToolsMnu );
 681
 682   createMenu( PythonShellId, aToolsMnu );
 683
 684   // --- Menu "Help"
 685
 686   int aHelpMnu = createMenu( tr( "MEN_DESK_HELP" ), -1, -1 );
 687
 688   createMenu( AboutParaViewId, aHelpMnu );
 689   // ParaView Help
 690   // It's needed to install module docs into <module>_ROOT_DIR/share/doc/salome/gui/<module>
 691   // createMenu( ParaViewHelpId, aHelpMnu );
 692   createMenu( EnableTooltipsId, aHelpMnu );
 693   createMenu( separator(), aHelpMnu );
 694
 695 }
 696
 697 /*!
 698   \brief Create toolbars for ParaView GUI operations
 699   duplicating toolbars in pqMainWindow ParaView class
 700 */
 701 void PVGUI_Module::pvCreateToolBars()
 702 {
 703   SUIT_Desktop* desk = application()->desktop();
 704   SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
 705
 706   QPixmap aPixmap;
 707   QtxAction* aQtxAction;
 708
 709   // --- Toolbar "Main Controls"
 710
 711   int aToolId = createTool( tr("TOOL_MAIN_CONTROLS") );
 712
 713   createTool( OpenFileId, aToolId );
 714   createTool( SaveDataId, aToolId );
 715   createTool( separator(), aToolId );
 716   createTool( ConnectId, aToolId );
 717   createTool( DisconnectId, aToolId );
 718   //createTool( separator(), aToolId );
 719   //createTool( ParaViewHelpId, aToolId );
 720
 721   // --- Toolbar "Selection Controls"
 722
 723   mySelectionControlsTb = createTool( tr("TOOL_SELECTION_CONTROLS") );
 724
 725   createTool( InteractId, mySelectionControlsTb );
 726   createTool( SelectCellsOnId, mySelectionControlsTb );
 727   createTool( SelectPointsOnId, mySelectionControlsTb );
 728   createTool( SelectCellsThroughId, mySelectionControlsTb );
 729   createTool( SelectPointsThroughId, mySelectionControlsTb );
 730   createTool( SelectBlockId, mySelectionControlsTb );
 731
 732   // --- Toolbar "Undo/Redo Controls"
 733
 734   aToolId = createTool( tr("TOOL_UNDOREDO_CONTROLS") );
 735
 736   createTool( UndoId, aToolId );
 737   createTool( RedoId, aToolId );
 738
 739   // --- Toolbar "VCR Controls"
 740
 741   aToolId = createTool( tr("TOOL_VCR_CONTROLS") );
 742
 743   createTool( FirstFrameId, aToolId );
 744   createTool( PreviousFrameId, aToolId );
 745   createTool( PlayId, aToolId );
 746   createTool( NextFrameId, aToolId );
 747   createTool( LastFrameId, aToolId );
 748   createTool( LoopId, aToolId );
 749
 750   pqProgressManager* progress_manager = pqApplicationCore::instance()->getProgressManager();
 751   progress_manager->addNonBlockableObject( toolMgr()->toolBar( aToolId ) );
 752
 753   // --- Toolbar "Active Variable Controls"
 754
 755   aToolId = createTool( tr("TOOL_ACTIVE_VARIABLE_CONTROLS") );
 756   QToolBar* aTB = toolMgr()->toolBar( aToolId );
 757
 758   createTool( ShowColorLegendId, aToolId );
 759
 760   // To set up the color map tool buttons.
 761   pqColorScaleToolbar* colorScale = Implementation->Core.getColorScaleEditorManager();
 762
 763   // Edit Color Map
 764   aPixmap = resMgr->loadPixmap( "ParaView", tr("ICON_EDIT_COLOR_MAP"), false );
 765   aQtxAction = new QtxAction( tr("TOP_EDIT_COLOR_MAP"), QIcon(aPixmap),
 766                               tr("MEN_EDIT_COLOR_MAP"), 0, desk );
 767   aQtxAction->setStatusTip( tr( "PRP_APP_EDIT_COLOR_MAP" ) );
 768   registerAction( EditColorMapId, aQtxAction );
 769   connect( &Implementation->Core, SIGNAL( enableVariableToolbar(bool) ),
 770            aQtxAction,            SLOT( setEnabled(bool) ) );
 771   colorScale->setColorAction( aQtxAction ); /// !!!
 772   createTool( EditColorMapId, aToolId );
 773
 774   // Reset Range
 775   aPixmap = resMgr->loadPixmap( "ParaView", tr("ICON_RESET_RANGE"), false );
 776   aQtxAction = new QtxAction( tr("TOP_RESET_RANGE"), QIcon(aPixmap),
 777                               tr("MEN_RESET_RANGE"), 0, desk );
 778   aQtxAction->setStatusTip( tr( "PRP_APP_RESET_RANGE" ) );
 779   registerAction( ResetRangeId, aQtxAction );
 780   connect( &Implementation->Core, SIGNAL( enableVariableToolbar(bool) ),
 781            aQtxAction,            SLOT( setEnabled(bool) ) );
 782   colorScale->setRescaleAction( aQtxAction ); /// !!!
 783   createTool( ResetRangeId, aToolId );
 784
 785   Implementation->Core.setupVariableToolbar(aTB);
 786   QList<QAction*> anActns = aTB->actions();
 787   for (int i = 0; i < anActns.size(); ++i)
 788     if ( anActns.at(i) != action(ShowColorLegendId) ) {
 789       createTool( anActns.at(i), aToolId );
 790       connect( &Implementation->Core, SIGNAL( enableVariableToolbar(bool) ),
 791                anActns.at(i),         SLOT( setEnabled(bool) ) );
 792     }
 793
 794   // --- Toolbar "Representation"
 795
 796   aTB = toolMgr()->toolBar( createTool( tr("TOOL_REPRESENTATION") ) );
 797   Implementation->Core.setupRepresentationToolbar(aTB);
 798   anActns = aTB->actions();
 799   for (int i = 0; i < anActns.size(); ++i)
 800     connect( &Implementation->Core, SIGNAL( enableVariableToolbar(bool) ),
 801              anActns.at(i),         SLOT( setEnabled(bool) ) );
 802
 803   // --- Toolbar "Camera Controls"
 804
 805   aToolId = createTool( tr("TOOL_CAMERA_CONTROLS") );
 806
 807   createTool( ResetCameraId, aToolId );
 808   createTool( PositiveXId, aToolId );
 809   createTool( NegativeXId, aToolId );
 810   createTool( PositiveYId, aToolId );
 811   createTool( NegativeYId, aToolId );
 812   createTool( PositiveZId, aToolId );
 813   createTool( NegativeZId, aToolId );
 814
 815   // --- Toolbar "Center Axes Controls"
 816
 817   aToolId = createTool( tr("TOOL_CENTER_AXES_CONTROLS") );
 818
 819   createTool( ShowCenterId, aToolId );
 820   createTool( ResetCenterId, aToolId );
 821   createTool( PickCenterId, aToolId );
 822
 823   // --- Toolbar "Common Filters"
 824
 825   aTB = toolMgr()->toolBar( createTool( tr("TOOL_COMMON_FILTERS") ) );
 826   Implementation->Core.setupCommonFiltersToolbar(aTB);
 827   //QList<QAction*> anActns = aTB->actions();
 828   //for (int i = 0; i < anActns.size(); ++i)
 829   //  createTool(anActns.at(i),aToolId); /// !!!
 830
 831   // --- Toolbar "Lookmarks"
 832
 833   aTB = toolMgr()->toolBar(createTool( tr("TOOL_LOOKMARKS") ));
 834   aTB->setContextMenuPolicy(Qt::CustomContextMenu);
 835   aTB->setOrientation(Qt::Vertical);
 836   Implementation->Core.setupLookmarkToolbar(aTB);
 837 }
 838
 839 /*!
 840   \brief Returns QMenu by its id.
 841 */
 842 QMenu* PVGUI_Module::getMenu( const int id )
 843 {
 844   QMenu* res = 0;
 845   LightApp_Application* anApp = getApp();
 846   SUIT_Desktop* desk = anApp->desktop();
 847   if ( desk ){
 848     QtxActionMenuMgr* menuMgr = desk->menuMgr();
 849     res = menuMgr->findMenu( id );
 850   }
 851   return res;
 852 }