X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FPVGUI%2FPVGUI_Module_widgets.cxx;h=a20a3af46b19fca2fc7a9c807e78068f775bdbd3;hb=651a7397543ef86bbf6c5d187ce185699ce0c1cb;hp=fe50e027bf8471fc57603fb4109f80c4662e378a;hpb=b7e307c703ea8667c7af73f39d02dc66a6e73dd4;p=modules%2Fparavis.git diff --git a/src/PVGUI/PVGUI_Module_widgets.cxx b/src/PVGUI/PVGUI_Module_widgets.cxx index fe50e027..a20a3af4 100644 --- a/src/PVGUI/PVGUI_Module_widgets.cxx +++ b/src/PVGUI/PVGUI_Module_widgets.cxx @@ -1,12 +1,11 @@ // PARAVIS : ParaView wrapper SALOME module // -// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, -// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS +// Copyright (C) 2010-2015 CEA/DEN, EDF R&D // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either -// version 2.1 of the License. +// version 2.1 of the License, or (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -23,135 +22,485 @@ // Author : Margarita KARPUNINA // -#include "PVGUI_Module_impl.h" +#include "PVGUI_Module.h" +#include "PVViewer_ViewManager.h" +#include "PVViewer_GUIElements.h" #include #include +#include // // should ultimately be a LightApp only #include +#include #include #include +#include +#include +#include +#include +#include +#include +#include -#include +#include +#include + +#include #include -#include -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#include + +class ResizeHelper : public pqPVAnimationWidget +{ + // TEMPORARY WORKAROUND AROUND PARAVIEW 3.14 BUG: + // WHEN ANIMATION VIEW IS RESIZED, ITS CONTENTS IS NOT PREPERLY RE-ARRANGED + // CAUSING SOME CONTROLS TO STAY NON-VISIBLE + // THIS BUG IS NATURALLY FIXED BY ADDING + // this->updateGeometries(); + // TO THE + // void pqAnimationWidget::resizeEvent(QResizeEvent* e); + // BUT THIS CANNOT BE DONE DIRECTLY, SINCE CORRESPONDING API IS NOT PUBLIC + // THE ONLY WAY TO DO THIS BY SENDING SHOW EVENT TO THE WIDGET + +public: + ResizeHelper( QWidget* parent ) : pqPVAnimationWidget( parent ) {} +protected: + void resizeEvent(QResizeEvent* e) + { + pqAnimationWidget* w = findChild( "pqAnimationWidget" ); + if ( w ) { + QShowEvent e; + QApplication::sendEvent( w, &e ); + } + pqPVAnimationWidget::resizeEvent( e ); + } +}; /*! \brief Create dock widgets for ParaView widgets such as object inspector, pipeline browser, etc. - ParaView pqMainWIndowCore class is fully responsible for these dock widgets' contents. + ParaView pqMainWindowCore class is fully responsible for these dock widgets' contents. + ==> To update this function, see the reference set up of ParaView in Application/Paraview/ParaviewMainWindow.ui */ void PVGUI_Module::setupDockWidgets() { SUIT_Desktop* desk = application()->desktop(); + PVViewer_GUIElements * guiElements = PVViewer_GUIElements::GetInstance(desk); + + desk->setCorner(Qt::BottomLeftCorner, Qt::LeftDockWidgetArea); + desk->setCorner(Qt::BottomRightCorner, Qt::RightDockWidgetArea); + desk->setTabPosition(Qt::LeftDockWidgetArea, QTabWidget::North); - // See ParaView src/Applications/Client/MainWindow.cxx - QDockWidget* pipelineBrowserDock = new QDockWidget( tr( "Pipeline Browser" ), desk ); + // Pipeline + QDockWidget* pipelineBrowserDock = new QDockWidget( tr( "TTL_PIPELINE_BROWSER" ), desk ); pipelineBrowserDock->setObjectName("pipelineBrowserDock"); pipelineBrowserDock->setAllowedAreas( Qt::LeftDockWidgetArea|Qt::NoDockWidgetArea|Qt::RightDockWidgetArea ); desk->addDockWidget( Qt::LeftDockWidgetArea, pipelineBrowserDock ); - Implementation->Core.setupPipelineBrowser( pipelineBrowserDock ); - pqPipelineBrowser *browser = Implementation->Core.pipelineBrowser(); - Implementation->Core.pipelineMenu().setModels(browser->getModel(), browser->getSelectionModel()); - - QDockWidget* objectInspectorDock = new QDockWidget( tr( "Object Inspector" ), desk ); - objectInspectorDock->setObjectName("objectInspectorDock"); - objectInspectorDock->setAllowedAreas( Qt::LeftDockWidgetArea|Qt::NoDockWidgetArea|Qt::RightDockWidgetArea ); - desk->addDockWidget( Qt::LeftDockWidgetArea, objectInspectorDock ); - pqProxyTabWidget* const proxyTab = Implementation->Core.setupProxyTabWidget( objectInspectorDock ); - connect( proxyTab->getObjectInspector(), SIGNAL( helpRequested(QString) ), - this, SLOT( showHelpForProxy(QString) ) ); - connect( proxyTab->getObjectInspector(), SIGNAL( preaccept() ), - this, SLOT( onPreAccept() ) ); - connect( proxyTab->getObjectInspector(), SIGNAL( postaccept() ), - this, SLOT( onPostAccept() ) ); - - QDockWidget* statisticsViewDock = new QDockWidget( tr( "Statistics View" ), desk ); + pqPipelineBrowserWidget* browser = guiElements->getPipelineBrowserWidget(); + pipelineBrowserDock->setWidget(browser); + myDockWidgets[pipelineBrowserDock] = true; + pipelineBrowserDock->hide(); + + // PROPERTIES, DISPLAY and VIEW: + // See ParaViewMainWindow.cxx - those three panels can be separated or grouped. + pqSettings *settings = pqApplicationCore::instance()->settings(); + + // Properties dock (previously called OBJECT_INSPECTOR) + QDockWidget* propertiesDock = new QDockWidget( tr( "TTL_OBJECT_INSPECTOR" ), desk ); + propertiesDock->setObjectName("propertiesDock"); + propertiesDock->setAllowedAreas( Qt::LeftDockWidgetArea|Qt::RightDockWidgetArea ); + desk->addDockWidget( Qt::LeftDockWidgetArea, propertiesDock ); + + pqPropertiesPanel* propertiesPanel = guiElements->getPropertiesPanel(); + propertiesDock->setWidget(propertiesPanel); + connect( propertiesPanel, SIGNAL( helpRequested(const QString&, const QString&) ), this, SLOT( showHelpForProxy(const QString&, const QString&) ) ); + // hook delete to pqDeleteReaction. + QAction* tempDeleteAction = new QAction(this); + pqDeleteReaction* handler = new pqDeleteReaction(tempDeleteAction); + handler->connect(propertiesPanel, SIGNAL(deleteRequested(pqPipelineSource*)), SLOT(deleteSource(pqPipelineSource*))); + myDockWidgets[propertiesDock] = true; + propertiesDock->hide(); + + // Display dock + QDockWidget* displayPropertiesDock = new QDockWidget( tr( "TTL_DISPLAY" ), desk ); + displayPropertiesDock->setObjectName("displayPropertiesDock"); + displayPropertiesDock->setAllowedAreas( Qt::LeftDockWidgetArea|Qt::RightDockWidgetArea ); + desk->addDockWidget( Qt::LeftDockWidgetArea, displayPropertiesDock ); + + pqPropertiesPanel* displayPropertiesPanel = new pqPropertiesPanel(); + displayPropertiesPanel->setObjectName("displayPropertiesPanel"); + displayPropertiesPanel->setProperty("panelMode", QVariant(2)); // probably to have only the Display part + displayPropertiesDock->setWidget(displayPropertiesPanel); + myDockWidgets[displayPropertiesDock] = false; + displayPropertiesDock->hide(); + + // View dock + QDockWidget* viewPropertiesDock = new QDockWidget( tr( "TTL_VIEW_PANEL" ), desk ); + viewPropertiesDock->setObjectName("viewPropertiesDock"); + viewPropertiesDock->setAllowedAreas( Qt::LeftDockWidgetArea|Qt::RightDockWidgetArea ); + desk->addDockWidget( Qt::LeftDockWidgetArea, viewPropertiesDock ); + + pqPropertiesPanel* viewPropertiesPanel = new pqPropertiesPanel(); + viewPropertiesPanel->setObjectName("viewPropertiesPanel"); + viewPropertiesPanel->setProperty("panelMode", QVariant(4)); // probably to have only the View part + viewPropertiesDock->setWidget(viewPropertiesPanel); + myDockWidgets[viewPropertiesDock] = false; + viewPropertiesDock->hide(); + + // Taken from ParaViewMainWindow.cxx: + int propertiesPanelMode = settings->value( + "GeneralSettings.PropertiesPanelMode", vtkPVGeneralSettings::ALL_IN_ONE).toInt(); + switch (propertiesPanelMode) + { + case vtkPVGeneralSettings::SEPARATE_DISPLAY_PROPERTIES: + viewPropertiesDock->hide(); + propertiesPanel->setPanelMode( + pqPropertiesPanel::SOURCE_PROPERTIES|pqPropertiesPanel::VIEW_PROPERTIES); + break; + + case vtkPVGeneralSettings::SEPARATE_VIEW_PROPERTIES: + displayPropertiesDock->hide(); + propertiesPanel->setPanelMode( + pqPropertiesPanel::SOURCE_PROPERTIES|pqPropertiesPanel::DISPLAY_PROPERTIES); + break; + + case vtkPVGeneralSettings::ALL_SEPARATE: + propertiesPanel->setPanelMode(pqPropertiesPanel::SOURCE_PROPERTIES); + break; + + case vtkPVGeneralSettings::ALL_IN_ONE: + default: + propertiesPanel->setPanelMode( + pqPropertiesPanel::SOURCE_PROPERTIES|pqPropertiesPanel::VIEW_PROPERTIES|pqPropertiesPanel::DISPLAY_PROPERTIES); + viewPropertiesDock->hide(); + displayPropertiesDock->hide(); + break; + } + + // Information dock + QDockWidget* informationDock = new QDockWidget(tr( "TTL_INFORMATION" ), desk); + informationDock->setObjectName("informationDock"); + + QWidget* informationWidgetFrame = new QWidget(informationDock); + informationWidgetFrame->setObjectName("informationWidgetFrame"); + + QVBoxLayout* verticalLayout_2 = new QVBoxLayout(informationWidgetFrame); + verticalLayout_2->setSpacing(0); + verticalLayout_2->setContentsMargins(0, 0, 0, 0); + + QScrollArea* informationScrollArea = new QScrollArea(informationWidgetFrame); + informationScrollArea->setObjectName("informationScrollArea") ; + informationScrollArea->setWidgetResizable(true); + + pqProxyInformationWidget* informationWidget = new pqProxyInformationWidget(); + informationWidget->setObjectName("informationWidget"); + informationWidget->setGeometry(QRect(0, 0, 77, 214)); + informationScrollArea->setWidget(informationWidget); + + verticalLayout_2->addWidget(informationScrollArea); + informationDock->setWidget(informationWidgetFrame); + + myDockWidgets[informationDock] = true; + + desk->tabifyDockWidget(propertiesDock, viewPropertiesDock); + desk->tabifyDockWidget(propertiesDock, displayPropertiesDock); + desk->tabifyDockWidget(propertiesDock, informationDock); + propertiesDock->raise(); + + // Statistic View + QDockWidget* statisticsViewDock = new QDockWidget( tr( "TTL_STATISTICS_VIEW" ), desk ); statisticsViewDock->setObjectName("statisticsViewDock"); - statisticsViewDock->setAllowedAreas( Qt::BottomDockWidgetArea|Qt::LeftDockWidgetArea|Qt::NoDockWidgetArea|Qt::RightDockWidgetArea ); + statisticsViewDock->setAllowedAreas(Qt::BottomDockWidgetArea|Qt::LeftDockWidgetArea| + Qt::NoDockWidgetArea|Qt::RightDockWidgetArea ); desk->addDockWidget( Qt::BottomDockWidgetArea, statisticsViewDock ); - Implementation->Core.setupStatisticsView( statisticsViewDock ); - - QDockWidget* animationPanelDock = new QDockWidget( tr( "Animation Inspector" ), desk ); - animationPanelDock->setObjectName("animationPanelDock"); - desk->addDockWidget( Qt::LeftDockWidgetArea, animationPanelDock ); - pqAnimationPanel* animation_panel = Implementation->Core.setupAnimationPanel( animationPanelDock ); - animation_panel->setCurrentTimeToolbar(toolMgr()->toolBar(createTool( tr("TOOL_CURRENT_TIME_CONTROLS") ))); - - QDockWidget* lookmarkBrowserDock = new QDockWidget( tr( "Lookmark Browser" ), desk ); - lookmarkBrowserDock->setObjectName("lookmarkBrowserDock"); - QSizePolicy sp( QSizePolicy::Preferred, QSizePolicy::Preferred ); - sp.setHorizontalStretch( 0 ); - sp.setVerticalStretch( 0 ); - lookmarkBrowserDock->setSizePolicy( sp ); - lookmarkBrowserDock->setFloating( false ); - desk->addDockWidget( Qt::RightDockWidgetArea, lookmarkBrowserDock ); - Implementation->Core.setupLookmarkBrowser( lookmarkBrowserDock ); - - QDockWidget* lookmarkInspectorDock = new QDockWidget( tr( "Lookmark Inspector" ), desk ); - lookmarkInspectorDock->setObjectName("lookmarkInspectorDock"); - lookmarkInspectorDock->setAllowedAreas( Qt::RightDockWidgetArea ); - desk->addDockWidget( Qt::RightDockWidgetArea, lookmarkInspectorDock ); - Implementation->Core.setupLookmarkInspector( lookmarkInspectorDock ); - - QDockWidget* comparativePanelDock = new QDockWidget( tr( "Comparative View Inspector" ), desk ); + pqDataInformationWidget* aStatWidget = new pqDataInformationWidget(statisticsViewDock); + statisticsViewDock->setWidget(aStatWidget); + myDockWidgets[statisticsViewDock] = false; // hidden by default + + //Animation view + QDockWidget* animationViewDock = new QDockWidget( tr( "TTL_ANIMATION_VIEW" ), desk ); + animationViewDock->setObjectName("animationViewDock"); + desk->addDockWidget( Qt::BottomDockWidgetArea, animationViewDock ); + pqPVAnimationWidget* animation_panel = new ResizeHelper(animationViewDock); // [ABN] was resizeHelper + animationViewDock->setWidget(animation_panel); + myDockWidgets[animationViewDock] = false; // hidden by default + + desk->tabifyDockWidget(animationViewDock, statisticsViewDock); + + // Selection inspector + QDockWidget* selectionDisplayDock = new QDockWidget( tr( "TTL_SELECTION_INSPECTOR" ), desk ); + selectionDisplayDock->setObjectName("selectionInspectorDock"); + selectionDisplayDock->setAllowedAreas( Qt::AllDockWidgetAreas ); + desk->addDockWidget( Qt::LeftDockWidgetArea, selectionDisplayDock ); + pqFindDataSelectionDisplayFrame* aSelInspector = new pqFindDataSelectionDisplayFrame(selectionDisplayDock); + selectionDisplayDock->setWidget(aSelInspector); + myDockWidgets[selectionDisplayDock] = false; // hidden by default + + // Multi-block inspector + QDockWidget* multiBlockInspectorPanelDock = new QDockWidget( tr( "TTL_MUTLI_BLOCK_INSPECTOR" ), desk ); + multiBlockInspectorPanelDock->setObjectName("multiBlockInspectorPanelDock"); + desk->addDockWidget( Qt::LeftDockWidgetArea, multiBlockInspectorPanelDock ); + pqMultiBlockInspectorPanel* mbi_panel = new pqMultiBlockInspectorPanel( multiBlockInspectorPanelDock ); + multiBlockInspectorPanelDock->setWidget(mbi_panel); + myDockWidgets[multiBlockInspectorPanelDock] = false; // hidden by default + + // Comparative View + QDockWidget* comparativePanelDock = new QDockWidget( tr( "TTL_COMPARATIVE_VIEW_INSPECTOR" ), desk ); comparativePanelDock->setObjectName("comparativePanelDock"); desk->addDockWidget( Qt::LeftDockWidgetArea, comparativePanelDock ); - pqComparativeVisPanel* cv_panel = new pqComparativeVisPanel( comparativePanelDock ); + pqComparativeVisPanel* cv_panel = new pqComparativeVisPanel( comparativePanelDock ); comparativePanelDock->setWidget(cv_panel); + myDockWidgets[comparativePanelDock] = false; // hidden by default - QDockWidget* animationViewDock = new QDockWidget( tr( "Animation View" ), desk ); - animationViewDock->setObjectName("animationViewDock"); - desk->addDockWidget( Qt::BottomDockWidgetArea, animationViewDock ); - Implementation->Core.setupAnimationView( animationViewDock ); + // Collaboration view + QDockWidget* collaborationPanelDock = new QDockWidget(tr( "TTL_COLLABORATIVE_DOCK" ), desk); + collaborationPanelDock->setObjectName("collaborationPanelDock"); + pqCollaborationPanel* collaborationPanel = new pqCollaborationPanel(); + collaborationPanel->setObjectName("collaborationPanel"); + collaborationPanelDock->setWidget(collaborationPanel); + desk->addDockWidget(Qt::RightDockWidgetArea, collaborationPanelDock); + myDockWidgets[collaborationPanelDock] = false; // hidden by default + + // Color map editor + QDockWidget* colorMapEditorDock = new QDockWidget( tr( "TTL_COLOR_MAP_EDITOR" ), desk ); + colorMapEditorDock->setObjectName("colorMapEditorDock"); + desk->addDockWidget( Qt::LeftDockWidgetArea, colorMapEditorDock ); + pqColorMapEditor* cmed_panel = new pqColorMapEditor( colorMapEditorDock ); + colorMapEditorDock->setWidget(cmed_panel); + myDockWidgets[colorMapEditorDock] = false; // hidden by default - QDockWidget* selectionInspectorDock = new QDockWidget( tr( "Selection Inspector" ), desk ); - selectionInspectorDock->setObjectName("selectionInspectorDock"); - selectionInspectorDock->setAllowedAreas( Qt::AllDockWidgetAreas ); - desk->addDockWidget( Qt::LeftDockWidgetArea, selectionInspectorDock ); - Implementation->Core.setupSelectionInspector( selectionInspectorDock ); + // Provide access to the color-editor panel for the application. + pqApplicationCore::instance()->registerManager( + "COLOR_EDITOR_PANEL", colorMapEditorDock); + + // Memory inspector dock + QDockWidget* memoryInspectorDock = new QDockWidget(tr( "TTL_MEMORY_INSPECTOR" ), desk); + memoryInspectorDock->setObjectName("memoryInspectorDock"); +#ifndef WIN32 + pqMemoryInspectorPanel* dockWidgetContents = new pqMemoryInspectorPanel(); + dockWidgetContents->setObjectName("dockWidgetContents"); + memoryInspectorDock->setWidget(dockWidgetContents); +#endif + desk->addDockWidget(Qt::RightDockWidgetArea, memoryInspectorDock); + myDockWidgets[memoryInspectorDock] = false; // hidden by default // Setup the statusbar ... - Implementation->Core.setupProgressBar( desk->statusBar() ); + pqProgressManager* progress_manager = + pqApplicationCore::instance()->getProgressManager(); + + // Progress bar/button management + pqProgressWidget* aProgress = new pqProgressWidget(desk->statusBar()); + progress_manager->addNonBlockableObject(aProgress); + progress_manager->addNonBlockableObject(aProgress->getAbortButton()); + + QObject::connect( progress_manager, SIGNAL(enableProgress(bool)), + aProgress, SLOT(enableProgress(bool))); + + QObject::connect( progress_manager, SIGNAL(progress(const QString&, int)), + aProgress, SLOT(setProgress(const QString&, int))); + + QObject::connect( progress_manager, SIGNAL(enableAbort(bool)), + aProgress, SLOT(enableAbort(bool))); + + QObject::connect( aProgress, SIGNAL(abortPressed()), + progress_manager, SLOT(triggerAbort())); + + desk->statusBar()->addPermanentWidget(aProgress); + aProgress->setEnabled(true); // Set up the dock window corners to give the vertical docks more room. - desk->setCorner(Qt::BottomLeftCorner, Qt::LeftDockWidgetArea); - desk->setCorner(Qt::BottomRightCorner, Qt::RightDockWidgetArea); +// desk->setCorner(Qt::BottomLeftCorner, Qt::LeftDockWidgetArea); +// desk->setCorner(Qt::BottomRightCorner, Qt::RightDockWidgetArea); // Setup the default dock configuration ... - lookmarkBrowserDock->hide(); - lookmarkInspectorDock->hide(); statisticsViewDock->hide(); - animationPanelDock->hide(); comparativePanelDock->hide(); animationViewDock->hide(); - selectionInspectorDock->hide(); + multiBlockInspectorPanelDock->hide(); + selectionDisplayDock->hide(); + collaborationPanelDock->hide(); + memoryInspectorDock->hide(); + colorMapEditorDock->hide(); +} + +/*! + \brief Save states of dockable ParaView widgets. +*/ +void PVGUI_Module::saveDockWidgetsState(bool hideWidgets) +{ + SUIT_Desktop* desk = application()->desktop(); + + // VSR: 19/06/2011: do not use Paraview's methods, since it conflicts with SALOME GUI architecture + // ... the following code is commented... + // Save the state of the window ... + // pqApplicationCore::instance()->settings()->saveState(*desk, "MainWindow"); + // + //for (int i = 0; i < myDockWidgets.size(); ++i) + // myDockWidgets.at(i)->setParent(0); + // ... and replaced - manually hide dock windows + + // store dock widgets visibility state and hide'em all + QMapIterator it1( myDockWidgets ); + while( it1.hasNext() ) { + it1.next(); + QDockWidget* dw = qobject_cast( it1.key() ); + myDockWidgets[dw] = dw->isVisible(); + if ( hideWidgets ) { + dw->setVisible( false ); + dw->toggleViewAction()->setVisible( false ); + } + } + // store toolbar breaks state and remove all tollbar breaks + QMapIterator it2( myToolbarBreaks ); + while( it2.hasNext() ) { + it2.next(); + QToolBar* tb = qobject_cast( it2.key() ); + myToolbarBreaks[tb] = desk->toolBarBreak( tb ); + if ( myToolbarBreaks[tb] && hideWidgets ) + desk->removeToolBarBreak( tb ); + } + // store toolbars visibility state and hide'em all + QMapIterator it3( myToolbars ); + while( it3.hasNext() ) { + it3.next(); + QToolBar* tb = qobject_cast( it3.key() ); + myToolbars[tb] = tb->isVisible(); + if ( hideWidgets ) { + tb->setVisible( false ); + tb->toggleViewAction()->setVisible( false ); + } + } } /*! - \brief Create dock widgets context menus. + \brief Restore states of dockable ParaView widgets. */ -void PVGUI_Module::setupDockWidgetsContextMenu() +void PVGUI_Module::restoreDockWidgetsState() { - // Pipeline menu - Implementation->Core.pipelineMenu().setMenuAction( pqPipelineMenu::ChangeInputAction, - action(ChangeInputId) ); - Implementation->Core.pipelineMenu().setMenuAction( pqPipelineMenu::DeleteAction, - action(DeleteId) ); - - // Pipeline Browser menu - pqPipelineBrowser *browser = Implementation->Core.pipelineBrowser(); - pqPipelineBrowserContextMenu *browserMenu = new pqPipelineBrowserContextMenu(browser); - - browserMenu->setMenuAction(action(OpenFileId)); - if ( action(OpenFileId)->text().compare(tr("MEN_OPEN")) == 0 ) - action(OpenFileId)->setText(tr("MEN_OPEN_FILE")); - - browserMenu->setMenuAction(action(ChangeInputId)); - browserMenu->setMenuAction(action(DeleteId)); - browserMenu->setMenuAction(action(CreateCustomFilterId)); + SUIT_Desktop* desk = application()->desktop(); + + // VSR: 19/06/2011: do not use Paraview's methods, since it conflicts with SALOME GUI architecture + // ... the following code is commented... + //for (int i = 0; i < myDockWidgets.size(); ++i) + // myDockWidgets.at(i)->setParent(desk); + // + // Restore the state of the window ... + //pqApplicationCore::instance()->settings()->restoreState("MainWindow", *desk); + // ... and replaced - manually hide dock windows + + // restore dock widgets visibility state + QMapIterator it1( myDockWidgets ); + while( it1.hasNext() ) { + it1.next(); + QDockWidget* dw = qobject_cast( it1.key() ); + dw->setVisible( it1.value() ); + dw->toggleViewAction()->setVisible( true ); + } + + // restore toolbar breaks state + QMapIterator it2( myToolbarBreaks ); + while( it2.hasNext() ) { + it2.next(); + QToolBar* tb = qobject_cast( it2.key() ); + if ( myToolbarBreaks[tb] ) + desk->insertToolBarBreak( tb ); + } + + // restore toolbar visibility state + QMapIterator it3( myToolbars ); + while( it3.hasNext() ) { + it3.next(); + QToolBar* tb = qobject_cast( it3.key() ); + tb->setVisible( it3.value() ); + tb->toggleViewAction()->setVisible( true ); + } +} + + + +/*! + \brief Store visibility of the common dockable windows (OB, PyConsole, ... etc.) +*/ +void PVGUI_Module::storeCommonWindowsState() { + //rnv: Make behaviour of the dockable windows and toolbars coherent with others + // modules: if 'Save position of the windows' or 'Save position of the toolbars' + // in the General SALOME preferences are cheked, then properties of the windows and/or toolbars + // are stored/restored using standard Qt saveState(...) and restoreState(...) methods. + // Otherwise to the windows and toolbars applied default settins stored int the SalomeApp.xml + // configuration file. + // + // But in contrast to others modules ParaVis module default settings hide some dockable + // windows, so to restore it at the moment of the ParaVis de-activation we call + // restoreCommonWindowsState() method, and at the moment of the ParaVis activation we call + // this method. + + //LightApp_Application* anApp = getApp(); + SalomeApp_Application* anApp = getApp(); + if(!anApp) + return; + +// int begin = SalomeApp_Application::WT_ObjectBrowser; +// int end = SalomeApp_Application::WT_NoteBook; + int begin = LightApp_Application::WT_ObjectBrowser; + int end = LightApp_Application::WT_User; + for( int i = begin; i <= end; i++ ) { + QWidget* wg = anApp->getWindow(i); + if(wg) { + QDockWidget* dock = 0; + QWidget* w = wg->parentWidget(); + while ( w && !dock ) { + dock = ::qobject_cast( w ); + w = w->parentWidget(); + } + if(dock){ + if(!myCommonMap.contains(i)){ + myCommonMap.insert(i,dock->isVisible()); + } else { + myCommonMap[i] = dock->isVisible(); + } + } + } + } +} + +/*! + \brief Restore visibility of the common dockable windows (OB, PyConsole, ... etc.) +*/ +void PVGUI_Module::restoreCommonWindowsState() { + SalomeApp_Application* anApp = getApp(); +// LightApp_Application* anApp = getApp(); + if(!anApp) + return; + DockWindowMap::const_iterator it = myCommonMap.begin(); + for( ;it != myCommonMap.end(); it++ ) { + QWidget* wg = anApp->getWindow(it.key()); + if(wg) { + QDockWidget* dock = 0; + QWidget* w = wg->parentWidget(); + while ( w && !dock ) { + dock = ::qobject_cast( w ); + w = w->parentWidget(); + } + if(dock) { + dock->setVisible(it.value()); + } + } + } }