///////////////////////////////////////////////////////////////////////////////// // // Copyright (C) 2011- Statoil ASA // Copyright (C) 2013- Ceetron Solutions AS // Copyright (C) 2011-2012 Ceetron AS // // ResInsight is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY // WARRANTY; without even the implied warranty of MERCHANTABILITY or // FITNESS FOR A PARTICULAR PURPOSE. // // See the GNU General Public License at // for more details. // ///////////////////////////////////////////////////////////////////////////////// #include "RiuMainWindow.h" #include "RiaBaseDefs.h" #include "RiaGuiApplication.h" #include "RiaPreferences.h" #include "RiaPreferencesSystem.h" #include "RiaRegressionTest.h" #include "RiaRegressionTestRunner.h" #include "Rim2dIntersectionView.h" #include "Rim3dView.h" #include "RimCellEdgeColors.h" #include "RimCommandObject.h" #include "RimEclipseCase.h" #include "RimEclipseContourMapView.h" #include "RimEclipseFaultColors.h" #include "RimEclipsePropertyFilter.h" #include "RimEclipseResultDefinition.h" #include "RimEclipseView.h" #include "RimExtrudedCurveIntersection.h" #include "RimFaultInViewCollection.h" #include "RimGeoMechCase.h" #include "RimGeoMechView.h" #include "RimProject.h" #include "RimSimWellInViewCollection.h" #include "RimViewLinker.h" #include "RimViewLinkerCollection.h" #include "RimViewWindow.h" #include "RiuDockWidgetTools.h" #include "RiuMdiSubWindow.h" #include "RiuMessagePanel.h" #include "RiuMohrsCirclePlot.h" #include "RiuProcessMonitor.h" #include "RiuProjectPropertyView.h" #include "RiuPropertyViewTabWidget.h" #include "RiuPvtPlotPanel.h" #include "RiuRelativePermeabilityPlotPanel.h" #include "RiuResultInfoPanel.h" #include "RiuResultQwtPlot.h" #include "RiuToolTipMenu.h" #include "RiuTreeViewEventFilter.h" #include "RiuViewer.h" #include "cafAnimationToolBar.h" #include "cafCmdExecCommandManager.h" #include "cafCmdFeatureManager.h" #include "cafMemoryInspector.h" #include "cafPdmUiPropertyView.h" #include "cafPdmUiPropertyViewDialog.h" #include "cafPdmUiTreeView.h" #include "cafSelectionManager.h" #include "cafUtils.h" #include "ExportCommands/RicSnapshotAllViewsToFileFeature.h" #include "MeasurementCommands/RicToggleMeasurementModeFeature.h" #include "SummaryPlotCommands/RicEditSummaryPlotFeature.h" #include "SummaryPlotCommands/RicShowSummaryCurveCalculatorFeature.h" #include "cvfTimer.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include //================================================================================================== /// /// \class RiuMainWindow /// /// Contains our main window /// //================================================================================================== //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- RiuMainWindow::RiuMainWindow() : m_pdmRoot( nullptr ) , m_relPermPlotPanel( nullptr ) , m_pvtPlotPanel( nullptr ) , m_mohrsCirclePlot( nullptr ) , m_windowMenu( nullptr ) , m_holoLensToolBar( nullptr ) { m_mdiArea = new RiuMdiArea( this ); connect( m_mdiArea, SIGNAL( subWindowActivated( QMdiSubWindow* ) ), SLOT( slotSubWindowActivated( QMdiSubWindow* ) ) ); setCentralWidget( m_mdiArea ); // m_mainViewer = createViewer(); createActions(); createMenus(); createToolBars(); createDockPanels(); if ( m_undoView ) { m_undoView->setStack( caf::CmdExecCommandManager::instance()->undoStack() ); } connect( caf::CmdExecCommandManager::instance()->undoStack(), SIGNAL( indexChanged( int ) ), SLOT( slotRefreshUndoRedoActions() ) ); initializeGuiNewProjectLoaded(); m_memoryCriticalWarning = new QLabel( "" ); m_memoryUsedButton = new QToolButton( nullptr ); m_memoryTotalStatus = new QLabel( "" ); m_memoryUsedButton->setDefaultAction( caf::CmdFeatureManager::instance()->action( "RicShowMemoryCleanupDialogFeature" ) ); statusBar()->addPermanentWidget( m_memoryCriticalWarning ); statusBar()->addPermanentWidget( m_memoryUsedButton ); statusBar()->addPermanentWidget( m_memoryTotalStatus ); updateMemoryUsage(); m_memoryRefreshTimer = new QTimer( this ); connect( m_memoryRefreshTimer, SIGNAL( timeout() ), this, SLOT( updateMemoryUsage() ) ); m_memoryRefreshTimer->start( 1000 ); auto dockTimer = new QTimer( this ); dockTimer->setSingleShot( true ); connect( dockTimer, SIGNAL( timeout() ), this, SLOT( slotWorkaroundForQwtDockWidgets() ) ); dockTimer->start( 1000 ); } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- RiuMainWindow::~RiuMainWindow() { setPdmRoot( nullptr ); } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- RiuMainWindow* RiuMainWindow::instance() { if ( RiaGuiApplication::isRunning() ) { return RiaGuiApplication::instance()->mainWindow(); } return nullptr; } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- QString RiuMainWindow::mainWindowName() { return "RiuMainWindow"; } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::initializeGuiNewProjectLoaded() { setPdmRoot( RimProject::current() ); restoreTreeViewState(); if ( subWindowsAreTiled() ) { tileSubWindows(); } slotRefreshFileActions(); slotRefreshUndoRedoActions(); slotRefreshViewActions(); refreshAnimationActions(); refreshDrawStyleActions(); if ( m_pdmUiPropertyView && m_pdmUiPropertyView->currentObject() ) { m_pdmUiPropertyView->currentObject()->uiCapability()->updateConnectedEditors(); } if ( statusBar() && !RiaRegressionTestRunner::instance()->isRunningRegressionTests() ) { statusBar()->showMessage( "Ready ..." ); } QMdiSubWindow* activeSubWindow = m_mdiArea->activeSubWindow(); if ( activeSubWindow ) { auto w = findViewWindowFromSubWindow( activeSubWindow ); if ( w && w->mdiWindowGeometry().isMaximized ) { activeSubWindow->showMaximized(); } } } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::cleanupGuiCaseClose() { caf::CmdExecCommandManager::instance()->undoStack()->clear(); setResultInfo( "" ); m_resultQwtPlot->deleteAllCurves(); if ( m_relPermPlotPanel ) m_relPermPlotPanel->clearPlot(); if ( m_pvtPlotPanel ) m_pvtPlotPanel->clearPlot(); if ( m_mohrsCirclePlot ) m_mohrsCirclePlot->clearPlot(); if ( m_pdmUiPropertyView ) { m_pdmUiPropertyView->showProperties( nullptr ); } for ( auto& additionalProjectView : m_additionalProjectViews ) { RiuProjectAndPropertyView* projPropView = dynamic_cast( additionalProjectView->widget() ); if ( projPropView ) { projPropView->showProperties( nullptr ); } } RicEditSummaryPlotFeature* editSumCurves = dynamic_cast( caf::CmdFeatureManager::instance()->getCommandFeature( "RicEditSummaryPlotFeature" ) ); if ( editSumCurves ) { editSumCurves->closeDialogAndResetTargetPlot(); } RicShowSummaryCurveCalculatorFeature::hideCurveCalculatorDialog(); } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::cleanupGuiBeforeProjectClose() { setPdmRoot( nullptr ); cleanupGuiCaseClose(); } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::closeEvent( QCloseEvent* event ) { RiaGuiApplication* app = RiaGuiApplication::instance(); if ( !app->isMainPlotWindowVisible() ) { if ( !app->askUserToSaveModifiedProject() ) { event->ignore(); return; } } this->saveWinGeoAndDockToolBarLayout(); this->hideAllDockWidgets(); QMainWindow::closeEvent( event ); } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::createActions() { // File actions m_mockModelAction = new QAction( "&Mock Model", this ); m_mockResultsModelAction = new QAction( "Mock Model With &Results", this ); m_mockLargeResultsModelAction = new QAction( "Large Mock Model", this ); m_mockModelCustomizedAction = new QAction( "Customized Mock Model", this ); m_mockInputModelAction = new QAction( "Input Mock Model", this ); m_snapshotAllViewsToFile = new QAction( QIcon( ":/SnapShotSaveViews.svg" ), "Snapshot All Views To File", this ); m_createCommandObject = new QAction( "Create Command Object", this ); m_showRegressionTestDialog = new QAction( "Regression Test Dialog", this ); m_executePaintEventPerformanceTest = new QAction( "&Paint Event Performance Test", this ); connect( m_mockModelAction, SIGNAL( triggered() ), SLOT( slotMockModel() ) ); connect( m_mockResultsModelAction, SIGNAL( triggered() ), SLOT( slotMockResultsModel() ) ); connect( m_mockLargeResultsModelAction, SIGNAL( triggered() ), SLOT( slotMockLargeResultsModel() ) ); connect( m_mockModelCustomizedAction, SIGNAL( triggered() ), SLOT( slotMockModelCustomized() ) ); connect( m_mockInputModelAction, SIGNAL( triggered() ), SLOT( slotInputMockModel() ) ); connect( m_snapshotAllViewsToFile, SIGNAL( triggered() ), SLOT( slotSnapshotAllViewsToFile() ) ); connect( m_createCommandObject, SIGNAL( triggered() ), SLOT( slotCreateCommandObject() ) ); connect( m_showRegressionTestDialog, SIGNAL( triggered() ), SLOT( slotShowRegressionTestDialog() ) ); connect( m_executePaintEventPerformanceTest, SIGNAL( triggered() ), SLOT( slotExecutePaintEventPerformanceTest() ) ); // View actions m_viewFromNorth = new QAction( QIcon( ":/SouthView.svg" ), "Look South", this ); m_viewFromNorth->setToolTip( "Look South (Ctrl+Alt+S)" ); caf::CmdFeature::applyShortcutWithHintToAction( m_viewFromNorth, QKeySequence( tr( "Ctrl+Alt+S" ) ) ); m_viewFromSouth = new QAction( QIcon( ":/NorthView.svg" ), "Look North", this ); m_viewFromSouth->setToolTip( "Look North (Ctrl+Alt+N)" ); caf::CmdFeature::applyShortcutWithHintToAction( m_viewFromSouth, QKeySequence( tr( "Ctrl+Alt+N" ) ) ); m_viewFromEast = new QAction( QIcon( ":/WestView.svg" ), "Look West", this ); m_viewFromEast->setToolTip( "Look West (Ctrl+Alt+W)" ); caf::CmdFeature::applyShortcutWithHintToAction( m_viewFromEast, QKeySequence( tr( "Ctrl+Alt+W" ) ) ); m_viewFromWest = new QAction( QIcon( ":/EastView.svg" ), "Look East", this ); m_viewFromWest->setToolTip( "Look East (Ctrl+Alt+E)" ); caf::CmdFeature::applyShortcutWithHintToAction( m_viewFromWest, QKeySequence( tr( "Ctrl+Alt+E" ) ) ); m_viewFromAbove = new QAction( QIcon( ":/DownView.svg" ), "Look Down", this ); m_viewFromAbove->setToolTip( "Look Down (Ctrl+Alt+D)" ); caf::CmdFeature::applyShortcutWithHintToAction( m_viewFromAbove, QKeySequence( tr( "Ctrl+Alt+D" ) ) ); m_viewFromBelow = new QAction( QIcon( ":/UpView.svg" ), "Look Up", this ); m_viewFromBelow->setToolTip( "Look Up (Ctrl+Alt+U)" ); caf::CmdFeature::applyShortcutWithHintToAction( m_viewFromBelow, QKeySequence( tr( "Ctrl+Alt+U" ) ) ); connect( m_viewFromNorth, SIGNAL( triggered() ), SLOT( slotViewFromNorth() ) ); connect( m_viewFromSouth, SIGNAL( triggered() ), SLOT( slotViewFromSouth() ) ); connect( m_viewFromEast, SIGNAL( triggered() ), SLOT( slotViewFromEast() ) ); connect( m_viewFromWest, SIGNAL( triggered() ), SLOT( slotViewFromWest() ) ); connect( m_viewFromAbove, SIGNAL( triggered() ), SLOT( slotViewFromAbove() ) ); connect( m_viewFromBelow, SIGNAL( triggered() ), SLOT( slotViewFromBelow() ) ); // Debug actions m_newPropertyView = new QAction( "New Project and Property View", this ); connect( m_newPropertyView, SIGNAL( triggered() ), SLOT( slotNewObjectPropertyView() ) ); // Draw style actions m_dsActionGroup = new QActionGroup( this ); m_drawStyleLinesAction = new QAction( QIcon( ":/DrawStyleLines.svg" ), "&Mesh Only", this ); // connect(m_drawStyleLinesAction, SIGNAL(triggered()), SLOT(slotDrawStyleLines())); m_dsActionGroup->addAction( m_drawStyleLinesAction ); m_drawStyleLinesSolidAction = new QAction( QIcon( ":/DrawStyleMeshLines.svg" ), "Mesh And Surfaces", this ); // connect(m_drawStyleLinesSolidAction, SIGNAL(triggered()), SLOT(slotDrawStyleLinesSolid())); m_dsActionGroup->addAction( m_drawStyleLinesSolidAction ); m_drawStyleSurfOnlyAction = new QAction( QIcon( ":/DrawStyleSurface.svg" ), "&Surface Only", this ); new QAction( QIcon( ":/draw_style_surface_w_fault_mesh_24x24.png" ), "Fault Mesh And Surfaces", this ); // connect(m_drawStyleSurfOnlyAction, SIGNAL(triggered()), SLOT(slotDrawStyleSurfOnly())); m_dsActionGroup->addAction( m_drawStyleSurfOnlyAction ); connect( m_dsActionGroup, SIGNAL( triggered( QAction* ) ), SLOT( slotDrawStyleChanged( QAction* ) ) ); m_drawStyleFaultLinesSolidAction = new QAction( QIcon( ":/draw_style_surface_w_fault_mesh_24x24.png" ), "Fault Mesh And Surfaces", this ); m_dsActionGroup->addAction( m_drawStyleFaultLinesSolidAction ); m_drawStyleHideGridCellsAction = new QAction( QIcon( ":/draw_style_faults_24x24.png" ), "&Hide Grid Cells", this ); m_drawStyleHideGridCellsAction->setCheckable( true ); connect( m_drawStyleHideGridCellsAction, SIGNAL( toggled( bool ) ), SLOT( slotToggleHideGridCellsAction( bool ) ) ); m_toggleFaultsLabelAction = new QAction( QIcon( ":/draw_style_faults_label_24x24.png" ), "&Show Fault Labels", this ); m_toggleFaultsLabelAction->setCheckable( true ); connect( m_toggleFaultsLabelAction, SIGNAL( toggled( bool ) ), SLOT( slotToggleFaultLabelsAction( bool ) ) ); m_showWellCellsAction = new QAction( QIcon( ":/draw_style_WellCellsToRangeFilter_24x24.png" ), "&Show Well Cells", this ); m_showWellCellsAction->setCheckable( true ); m_showWellCellsAction->setToolTip( "Show Well Cells" ); connect( m_showWellCellsAction, SIGNAL( toggled( bool ) ), SLOT( slotShowWellCellsAction( bool ) ) ); m_enableLightingAction = new QAction( QIcon( ":/DrawLightingEnabled.svg" ), "&Enable Results Lighting", this ); m_enableLightingAction->setCheckable( true ); connect( m_enableLightingAction, SIGNAL( toggled( bool ) ), SLOT( slotToggleLightingAction( bool ) ) ); // m_dsActionGroup->addAction( m_enableLightingAction ); } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::createMenus() { caf::CmdFeatureManager* cmdFeatureMgr = caf::CmdFeatureManager::instance(); CVF_ASSERT( cmdFeatureMgr ); // File menu QMenu* fileMenu = new RiuToolTipMenu( menuBar() ); fileMenu->setTitle( "&File" ); menuBar()->addMenu( fileMenu ); fileMenu->addAction( cmdFeatureMgr->action( "RicOpenProjectFeature" ) ); fileMenu->addAction( cmdFeatureMgr->action( "RicOpenLastUsedFileFeature" ) ); fileMenu->addSeparator(); QMenu* importMenu = fileMenu->addMenu( "&Import" ); QMenu* importEclipseMenu = importMenu->addMenu( QIcon( ":/Case48x48.png" ), "Eclipse Cases" ); importEclipseMenu->addAction( cmdFeatureMgr->action( "RicImportEclipseCaseFeature" ) ); importEclipseMenu->addAction( cmdFeatureMgr->action( "RicImportEclipseCasesFeature" ) ); importEclipseMenu->addAction( cmdFeatureMgr->action( "RicImportEclipseCaseTimeStepFilterFeature" ) ); importEclipseMenu->addAction( cmdFeatureMgr->action( "RicImportInputEclipseCaseFeature" ) ); importEclipseMenu->addAction( cmdFeatureMgr->action( "RicCreateGridCaseGroupFromFilesFeature" ) ); importMenu->addSeparator(); QMenu* importSummaryMenu = importMenu->addMenu( QIcon( ":/SummaryCase.svg" ), "Summary Cases" ); importSummaryMenu->addAction( cmdFeatureMgr->action( "RicImportSummaryCaseFeature" ) ); importSummaryMenu->addAction( cmdFeatureMgr->action( "RicImportSummaryCasesFeature" ) ); importSummaryMenu->addAction( cmdFeatureMgr->action( "RicImportSummaryGroupFeature" ) ); importSummaryMenu->addAction( cmdFeatureMgr->action( "RicImportEnsembleFeature" ) ); #ifdef USE_ODB_API importMenu->addSeparator(); QMenu* importGeoMechMenu = importMenu->addMenu( QIcon( ":/GeoMechCase24x24.png" ), "Geo Mechanical Cases" ); importGeoMechMenu->addAction( cmdFeatureMgr->action( "RicImportGeoMechCaseFeature" ) ); importGeoMechMenu->addAction( cmdFeatureMgr->action( "RicImportGeoMechCaseTimeStepFilterFeature" ) ); importGeoMechMenu->addAction( cmdFeatureMgr->action( "RicImportElementPropertyFeature" ) ); #endif importMenu->addSeparator(); QMenu* importWellMenu = importMenu->addMenu( QIcon( ":/Well.svg" ), "Well Data" ); importWellMenu->addAction( cmdFeatureMgr->action( "RicWellPathsImportFileFeature" ) ); importWellMenu->addAction( cmdFeatureMgr->action( "RicWellPathsImportSsihubFeature" ) ); importWellMenu->addAction( cmdFeatureMgr->action( "RicWellLogsImportFileFeature" ) ); importWellMenu->addAction( cmdFeatureMgr->action( "RicWellPathFormationsImportFileFeature" ) ); importWellMenu->addAction( cmdFeatureMgr->action( "RicImportWellMeasurementsFeature" ) ); importMenu->addSeparator(); importMenu->addAction( cmdFeatureMgr->action( "RicImportObservedDataInMenuFeature" ) ); importMenu->addAction( cmdFeatureMgr->action( "RicImportObservedFmuDataInMenuFeature" ) ); importMenu->addAction( cmdFeatureMgr->action( "RicImportFormationNamesFeature" ) ); importMenu->addAction( cmdFeatureMgr->action( "RicImportSurfacesFeature" ) ); QMenu* exportMenu = fileMenu->addMenu( "&Export" ); exportMenu->addAction( cmdFeatureMgr->action( "RicSnapshotViewToFileFeature" ) ); exportMenu->addAction( m_snapshotAllViewsToFile ); exportMenu->addAction( cmdFeatureMgr->action( "RicAdvancedSnapshotExportFeature" ) ); exportMenu->addSeparator(); exportMenu->addAction( cmdFeatureMgr->action( "RicExportEclipseInputGridFeature" ) ); exportMenu->addAction( cmdFeatureMgr->action( "RicSaveEclipseInputActiveVisibleCellsFeature" ) ); exportMenu->addAction( cmdFeatureMgr->action( "RicExportCompletionsForVisibleWellPathsFeature" ) ); exportMenu->addAction( cmdFeatureMgr->action( "RicExportVisibleWellPathsFeature" ) ); fileMenu->addSeparator(); fileMenu->addAction( cmdFeatureMgr->action( "RicSaveProjectFeature" ) ); fileMenu->addAction( cmdFeatureMgr->action( "RicSaveProjectAsFeature" ) ); std::vector recentFileActions = RiaGuiApplication::instance()->recentFileActions(); for ( auto act : recentFileActions ) { fileMenu->addAction( act ); } fileMenu->addSeparator(); QMenu* testMenu = fileMenu->addMenu( "&Testing" ); fileMenu->addSeparator(); fileMenu->addAction( cmdFeatureMgr->action( "RicCloseProjectFeature" ) ); fileMenu->addSeparator(); fileMenu->addAction( cmdFeatureMgr->action( "RicExitApplicationFeature" ) ); connect( fileMenu, SIGNAL( aboutToShow() ), SLOT( slotRefreshFileActions() ) ); // Edit menu QMenu* editMenu = menuBar()->addMenu( "&Edit" ); editMenu->addAction( cmdFeatureMgr->action( "RicSnapshotViewToClipboardFeature" ) ); editMenu->addSeparator(); editMenu->addAction( cmdFeatureMgr->action( "RicShowMemoryCleanupDialogFeature" ) ); editMenu->addSeparator(); editMenu->addAction( cmdFeatureMgr->action( "RicEditPreferencesFeature" ) ); if ( RiaPreferences::current()->useUndoRedo() ) { editMenu->addSeparator(); editMenu->addAction( m_undoAction ); editMenu->addAction( m_redoAction ); } connect( editMenu, SIGNAL( aboutToShow() ), SLOT( slotRefreshUndoRedoActions() ) ); // View menu QMenu* viewMenu = menuBar()->addMenu( "&View" ); viewMenu->addAction( cmdFeatureMgr->action( "RicViewZoomAllFeature" ) ); viewMenu->addSeparator(); viewMenu->addAction( m_viewFromSouth ); viewMenu->addAction( m_viewFromNorth ); viewMenu->addAction( m_viewFromWest ); viewMenu->addAction( m_viewFromEast ); viewMenu->addAction( m_viewFromBelow ); viewMenu->addAction( m_viewFromAbove ); connect( viewMenu, SIGNAL( aboutToShow() ), SLOT( slotRefreshViewActions() ) ); testMenu->addAction( m_mockModelAction ); testMenu->addAction( m_mockResultsModelAction ); testMenu->addAction( m_mockLargeResultsModelAction ); testMenu->addAction( m_mockModelCustomizedAction ); testMenu->addAction( m_mockInputModelAction ); testMenu->addSeparator(); testMenu->addAction( m_createCommandObject ); testMenu->addSeparator(); testMenu->addAction( m_showRegressionTestDialog ); testMenu->addAction( m_executePaintEventPerformanceTest ); testMenu->addAction( cmdFeatureMgr->action( "RicLaunchUnitTestsFeature" ) ); testMenu->addAction( cmdFeatureMgr->action( "RicRunCommandFileFeature" ) ); testMenu->addAction( cmdFeatureMgr->action( "RicExportObjectAndFieldKeywordsFeature" ) ); testMenu->addAction( cmdFeatureMgr->action( "RicSaveProjectNoGlobalPathsFeature" ) ); testMenu->addAction( cmdFeatureMgr->action( "RicExecuteLastUsedScriptFeature" ) ); testMenu->addSeparator(); testMenu->addAction( cmdFeatureMgr->action( "RicHoloLensExportToFolderFeature" ) ); testMenu->addAction( cmdFeatureMgr->action( "RicHoloLensCreateDummyFiledBackedSessionFeature" ) ); testMenu->addSeparator(); testMenu->addAction( cmdFeatureMgr->action( "RicThemeColorEditorFeature" ) ); // Windows menu m_windowMenu = menuBar()->addMenu( "&Windows" ); connect( m_windowMenu, SIGNAL( aboutToShow() ), SLOT( slotBuildWindowActions() ) ); // Help menu QMenu* helpMenu = menuBar()->addMenu( "&Help" ); helpMenu->addAction( cmdFeatureMgr->action( "RicHelpAboutFeature" ) ); helpMenu->addAction( cmdFeatureMgr->action( "RicHelpCommandLineFeature" ) ); helpMenu->addAction( cmdFeatureMgr->action( "RicHelpSummaryCommandLineFeature" ) ); helpMenu->addSeparator(); helpMenu->addAction( cmdFeatureMgr->action( "RicHelpOpenUsersGuideFeature" ) ); helpMenu->addAction( cmdFeatureMgr->action( "RicSearchHelpFeature" ) ); helpMenu->addAction( cmdFeatureMgr->action( "RicSearchIssuesHelpFeature" ) ); helpMenu->addAction( cmdFeatureMgr->action( "RicCreateNewIssueHelpFeature" ) ); connect( helpMenu, SIGNAL( aboutToShow() ), SLOT( slotRefreshHelpActions() ) ); } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::createToolBars() { caf::CmdFeatureManager* cmdFeatureMgr = caf::CmdFeatureManager::instance(); CVF_ASSERT( cmdFeatureMgr ); { QToolBar* toolbar = addToolBar( tr( "Standard" ) ); toolbar->setObjectName( toolbar->windowTitle() ); toolbar->addAction( cmdFeatureMgr->action( "RicImportGeneralDataFeature" ) ); toolbar->addAction( cmdFeatureMgr->action( "RicOpenProjectFeature" ) ); toolbar->addAction( cmdFeatureMgr->action( "RicSaveProjectFeature" ) ); } if ( RiaPreferences::current()->useUndoRedo() ) { QToolBar* toolbar = addToolBar( tr( "Edit" ) ); toolbar->setObjectName( toolbar->windowTitle() ); toolbar->addAction( m_undoAction ); toolbar->addAction( m_redoAction ); } { QToolBar* toolbar = addToolBar( tr( "Import" ) ); toolbar->setObjectName( toolbar->windowTitle() ); toolbar->addAction( cmdFeatureMgr->action( "RicImportEclipseCaseFeature" ) ); toolbar->addAction( cmdFeatureMgr->action( "RicImportInputEclipseCaseFeature" ) ); toolbar->addAction( cmdFeatureMgr->action( "RicImportSummaryCaseFeature" ) ); toolbar->addAction( cmdFeatureMgr->action( "RicImportEnsembleFeature" ) ); toolbar->hide(); } { #ifdef USE_ODB_API QToolBar* toolbar = addToolBar( tr( "Import GeoMech" ) ); toolbar->setObjectName( toolbar->windowTitle() ); toolbar->addAction( cmdFeatureMgr->action( "RicImportGeoMechCaseFeature" ) ); toolbar->addAction( cmdFeatureMgr->action( "RicImportGeoMechCaseTimeStepFilterFeature" ) ); toolbar->addAction( cmdFeatureMgr->action( "RicImportElementPropertyFeature" ) ); toolbar->hide(); #endif } { QToolBar* toolbar = addToolBar( tr( "Window Management" ) ); toolbar->setObjectName( toolbar->windowTitle() ); toolbar->addAction( cmdFeatureMgr->action( "RicShowPlotWindowFeature" ) ); toolbar->addAction( cmdFeatureMgr->action( "RicLinkVisibleViewsFeature" ) ); toolbar->addAction( cmdFeatureMgr->action( "RicTileWindowsFeature" ) ); } { QToolBar* toolbar = addToolBar( tr( "View Snapshots" ) ); toolbar->setObjectName( toolbar->windowTitle() ); toolbar->addAction( cmdFeatureMgr->action( "RicSnapshotViewToClipboardFeature" ) ); toolbar->addAction( cmdFeatureMgr->action( "RicSnapshotViewToFileFeature" ) ); toolbar->addAction( m_snapshotAllViewsToFile ); toolbar->hide(); } // View toolbar { QToolBar* toolbar = addToolBar( tr( "View" ) ); toolbar->setObjectName( toolbar->windowTitle() ); toolbar->addAction( cmdFeatureMgr->action( "RicTogglePerspectiveViewFeature" ) ); toolbar->addAction( cmdFeatureMgr->action( "RicViewZoomAllFeature" ) ); toolbar->addAction( m_viewFromNorth ); toolbar->addAction( m_viewFromSouth ); toolbar->addAction( m_viewFromEast ); toolbar->addAction( m_viewFromWest ); toolbar->addAction( m_viewFromAbove ); toolbar->addAction( m_viewFromBelow ); QLabel* scaleLabel = new QLabel( toolbar ); scaleLabel->setText( "Scale" ); toolbar->addWidget( scaleLabel ); m_scaleFactor = new QSpinBox( toolbar ); m_scaleFactor->setValue( 0 ); toolbar->addWidget( m_scaleFactor ); connect( m_scaleFactor, SIGNAL( valueChanged( int ) ), SLOT( slotScaleChanged( int ) ) ); } { QToolBar* dsToolBar = addToolBar( tr( "Draw Style" ) ); dsToolBar->setObjectName( dsToolBar->windowTitle() ); dsToolBar->addAction( m_drawStyleLinesAction ); dsToolBar->addAction( m_drawStyleLinesSolidAction ); dsToolBar->addAction( m_drawStyleSurfOnlyAction ); dsToolBar->addAction( m_enableLightingAction ); dsToolBar->addAction( m_drawStyleFaultLinesSolidAction ); dsToolBar->addAction( m_drawStyleHideGridCellsAction ); dsToolBar->addAction( m_toggleFaultsLabelAction ); dsToolBar->addAction( m_showWellCellsAction ); } { m_holoLensToolBar = addToolBar( tr( "HoloLens" ) ); m_holoLensToolBar->setObjectName( m_holoLensToolBar->windowTitle() ); m_holoLensToolBar->addAction( cmdFeatureMgr->action( "RicHoloLensCreateSessionFeature" ) ); m_holoLensToolBar->addAction( cmdFeatureMgr->action( "RicHoloLensTerminateSessionFeature" ) ); m_holoLensToolBar->addAction( cmdFeatureMgr->action( "RicHoloLensAutoExportToSharingServerFeature" ) ); m_holoLensToolBar->addAction( cmdFeatureMgr->action( "RicHoloLensExportToSharingServerFeature" ) ); } { QToolBar* toolbar = addToolBar( tr( "Measurement" ) ); toolbar->setObjectName( toolbar->windowTitle() ); auto measureAction = cmdFeatureMgr->action( "RicToggleMeasurementModeFeature" ); toolbar->addAction( measureAction ); auto polyMeasureAction = cmdFeatureMgr->action( "RicTogglePolyMeasurementModeFeature" ); toolbar->addAction( polyMeasureAction ); } if ( RiaPreferencesSystem::current()->showTestToolbar() ) { QToolBar* toolbar = addToolBar( tr( "Test" ) ); toolbar->setObjectName( toolbar->windowTitle() ); toolbar->addAction( cmdFeatureMgr->action( "RicLaunchUnitTestsFeature" ) ); toolbar->addAction( cmdFeatureMgr->action( "RicLaunchRegressionTestsFeature" ) ); toolbar->addAction( cmdFeatureMgr->action( "RicRunCommandFileFeature" ) ); toolbar->addAction( cmdFeatureMgr->action( "RicExecuteLastUsedScriptFeature" ) ); toolbar->addAction( cmdFeatureMgr->action( "RicExportCompletionsForVisibleWellPathsFeature" ) ); } // Create animation toolbar m_animationToolBar = new caf::AnimationToolBar( "Animation", this ); addToolBar( m_animationToolBar ); refreshAnimationActions(); refreshDrawStyleActions(); } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::createDockPanels() { const int nTreeViews = 1; createTreeViews( nTreeViews ); { QDockWidget* dockWidget = new QDockWidget( "Project Tree", this ); dockWidget->setObjectName( RiuDockWidgetTools::projectTreeName() ); dockWidget->setAllowedAreas( Qt::AllDockWidgetAreas ); caf::PdmUiTreeView* projectTree = projectTreeView( 0 ); projectTree->enableSelectionManagerUpdating( true ); projectTree->enableAppendOfClassNameToUiItemText( RiaPreferencesSystem::current()->appendClassNameToUiText() ); dockWidget->setWidget( projectTree ); projectTree->treeView()->setHeaderHidden( true ); projectTree->treeView()->setSelectionMode( QAbstractItemView::ExtendedSelection ); // Drag and drop configuration projectTree->treeView()->setDragEnabled( true ); projectTree->treeView()->viewport()->setAcceptDrops( true ); projectTree->treeView()->setDropIndicatorShown( true ); projectTree->treeView()->setDragDropMode( QAbstractItemView::DragDrop ); // Install event filter used to handle key press events RiuTreeViewEventFilter* treeViewEventFilter = new RiuTreeViewEventFilter( this, projectTree ); projectTree->treeView()->installEventFilter( treeViewEventFilter ); addDockWidget( Qt::LeftDockWidgetArea, dockWidget ); connect( projectTree, SIGNAL( selectionChanged() ), this, SLOT( selectedObjectsChanged() ) ); projectTree->treeView()->setContextMenuPolicy( Qt::CustomContextMenu ); connect( projectTree->treeView(), SIGNAL( customContextMenuRequested( const QPoint& ) ), SLOT( customMenuRequested( const QPoint& ) ) ); } QDockWidget* resultPlotDock = nullptr; QDockWidget* relPermPlotDock = nullptr; QDockWidget* pvtPlotDock = nullptr; #ifdef USE_ODB_API QDockWidget* mohrsCirclePlotDock = nullptr; #endif { QDockWidget* dockWidget = new QDockWidget( "Property Editor", this ); dockWidget->setObjectName( RiuDockWidgetTools::propertyEditorName() ); dockWidget->setAllowedAreas( Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea ); m_pdmUiPropertyView = new caf::PdmUiPropertyView( dockWidget ); dockWidget->setWidget( m_pdmUiPropertyView ); addDockWidget( Qt::LeftDockWidgetArea, dockWidget ); } { QDockWidget* dockWidget = new QDockWidget( "Result Info", this ); dockWidget->setObjectName( RiuDockWidgetTools::resultInfoName() ); dockWidget->setAllowedAreas( Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea | Qt::BottomDockWidgetArea ); m_resultInfoPanel = new RiuResultInfoPanel( dockWidget ); dockWidget->setWidget( m_resultInfoPanel ); addDockWidget( Qt::BottomDockWidgetArea, dockWidget ); } { QDockWidget* dockWidget = new QDockWidget( "Process Monitor", this ); dockWidget->setObjectName( RiuDockWidgetTools::processMonitorName() ); dockWidget->setAllowedAreas( Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea | Qt::BottomDockWidgetArea ); m_processMonitor = new RiuProcessMonitor( dockWidget ); dockWidget->setWidget( m_processMonitor ); addDockWidget( Qt::BottomDockWidgetArea, dockWidget ); dockWidget->hide(); } { QDockWidget* dockWidget = new QDockWidget( "Result Plot", this ); dockWidget->setObjectName( RiuDockWidgetTools::resultPlotName() ); dockWidget->setAllowedAreas( Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea | Qt::BottomDockWidgetArea ); m_resultQwtPlot = new RiuResultQwtPlot( dockWidget ); dockWidget->setWidget( m_resultQwtPlot ); addDockWidget( Qt::BottomDockWidgetArea, dockWidget ); resultPlotDock = dockWidget; } #ifdef USE_ODB_API { QDockWidget* dockWidget = new QDockWidget( "Mohr's Circle Plot", this ); dockWidget->setObjectName( RiuDockWidgetTools::mohrsCirclePlotName() ); dockWidget->setAllowedAreas( Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea | Qt::BottomDockWidgetArea ); m_mohrsCirclePlot = new RiuMohrsCirclePlot( dockWidget ); dockWidget->setWidget( m_mohrsCirclePlot ); addDockWidget( Qt::BottomDockWidgetArea, dockWidget ); mohrsCirclePlotDock = dockWidget; dockWidget->hide(); } #endif { QDockWidget* dockWidget = new QDockWidget( "Relative Permeability Plot", this ); dockWidget->setObjectName( RiuDockWidgetTools::relPermPlotName() ); dockWidget->setAllowedAreas( Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea | Qt::BottomDockWidgetArea ); m_relPermPlotPanel = new RiuRelativePermeabilityPlotPanel( dockWidget ); dockWidget->setWidget( m_relPermPlotPanel ); addDockWidget( Qt::BottomDockWidgetArea, dockWidget ); relPermPlotDock = dockWidget; } { QDockWidget* dockWidget = new QDockWidget( "PVT Plot", this ); dockWidget->setObjectName( RiuDockWidgetTools::pvtPlotName() ); dockWidget->setAllowedAreas( Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea | Qt::BottomDockWidgetArea ); m_pvtPlotPanel = new RiuPvtPlotPanel( dockWidget ); dockWidget->setWidget( m_pvtPlotPanel ); addDockWidget( Qt::BottomDockWidgetArea, dockWidget ); pvtPlotDock = dockWidget; } { QDockWidget* dockWidget = new QDockWidget( "Messages", this ); dockWidget->setObjectName( RiuDockWidgetTools::messagesName() ); m_messagePanel = new RiuMessagePanel( dockWidget ); dockWidget->setWidget( m_messagePanel ); addDockWidget( Qt::BottomDockWidgetArea, dockWidget ); dockWidget->hide(); } if ( m_undoView && RiaPreferences::current()->useUndoRedo() ) { QDockWidget* dockWidget = new QDockWidget( "Undo Stack", this ); dockWidget->setObjectName( RiuDockWidgetTools::undoStackName() ); dockWidget->setAllowedAreas( Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea ); dockWidget->setWidget( m_undoView ); addDockWidget( Qt::RightDockWidgetArea, dockWidget ); dockWidget->hide(); } setCorner( Qt::BottomLeftCorner, Qt::LeftDockWidgetArea ); setCorner( Qt::BottomRightCorner, Qt::BottomDockWidgetArea ); // Tabify docks tabifyDockWidget( pvtPlotDock, relPermPlotDock ); #ifdef USE_ODB_API tabifyDockWidget( relPermPlotDock, mohrsCirclePlotDock ); tabifyDockWidget( mohrsCirclePlotDock, resultPlotDock ); #else tabifyDockWidget( relPermPlotDock, resultPlotDock ); #endif QList dockWidgets = findChildren(); for ( QDockWidget* dock : dockWidgets ) { connect( dock->toggleViewAction(), SIGNAL( triggered() ), SLOT( slotDockWidgetToggleViewActionTriggered() ) ); } } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::setResultInfo( const QString& info ) const { m_resultInfoPanel->setInfo( info ); } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::refreshViewActions() { this->slotRefreshViewActions(); } //================================================================================================== // // Action slots // //================================================================================================== //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::slotRefreshFileActions() { caf::CmdFeatureManager* cmdFeatureMgr = caf::CmdFeatureManager::instance(); CVF_ASSERT( cmdFeatureMgr ); QStringList commandIdList; commandIdList << "RicExportEclipseInputGridFeature"; commandIdList << "RicSaveEclipseInputVisibleCellsFeature"; commandIdList << "RicSaveEclipseInputActiveVisibleCellsFeature"; commandIdList << "RicExportCompletionsForVisibleWellPathsFeature"; commandIdList << "RicExportVisibleWellPathsFeature"; cmdFeatureMgr->refreshStates( commandIdList ); } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::slotRefreshViewActions() { RimGridView* gridView = RiaApplication::instance()->activeGridView(); RimEclipseContourMapView* view2d = dynamic_cast( gridView ); bool enabled = gridView != nullptr && view2d == nullptr; m_viewFromNorth->setEnabled( enabled ); m_viewFromSouth->setEnabled( enabled ); m_viewFromEast->setEnabled( enabled ); m_viewFromWest->setEnabled( enabled ); m_viewFromAbove->setEnabled( enabled ); m_viewFromBelow->setEnabled( enabled ); updateScaleValue(); { QStringList commandIds; commandIds << "RicLinkVisibleViewsFeature" << "RicTileWindowsFeature" << "RicTogglePerspectiveViewFeature" << "RicViewZoomAllFeature"; caf::CmdFeatureManager::instance()->refreshEnabledState( commandIds ); } { QStringList commandIds; commandIds << "RicTileWindowsFeature"; commandIds << "RicToggleMeasurementModeFeature"; commandIds << "RicTogglePolyMeasurementModeFeature"; caf::CmdFeatureManager::instance()->refreshCheckedState( commandIds ); } } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::refreshAnimationActions() { caf::FrameAnimationControl* animationControl = nullptr; Rim3dView* activeView = RiaApplication::instance()->activeReservoirView(); if ( activeView && activeView->viewer() ) { animationControl = activeView->viewer()->animationControl(); } m_animationToolBar->connectAnimationControl( animationControl ); QStringList timeStepStrings; int currentTimeStepIndex = 0; bool enableAnimControls = false; if ( activeView && activeView->ownerCase() && activeView->viewer() && activeView->viewer()->frameCount() ) { enableAnimControls = true; if ( activeView->isTimeStepDependentDataVisibleInThisOrComparisonView() ) { timeStepStrings = activeView->ownerCase()->timeStepStrings(); } else { RimEclipseView* activeRiv = dynamic_cast( activeView ); if ( activeRiv && activeRiv->currentGridCellResults() ) { timeStepStrings.push_back( tr( "Static Property" ) ); } } currentTimeStepIndex = activeView->currentTimeStep(); // Animation control is only relevant for more than one time step if ( timeStepStrings.size() < 2 ) { enableAnimControls = false; } m_animationToolBar->setFrameRate( activeView->maximumFrameRate() ); } m_animationToolBar->setTimeStepStrings( timeStepStrings ); m_animationToolBar->setCurrentTimeStepIndex( currentTimeStepIndex ); m_animationToolBar->setEnabled( enableAnimControls ); } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::slotMockModel() { RiaApplication* app = RiaApplication::instance(); app->createMockModel(); } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::slotMockResultsModel() { RiaApplication* app = RiaApplication::instance(); app->createResultsMockModel(); } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::slotMockLargeResultsModel() { RiaApplication* app = RiaApplication::instance(); app->createLargeResultsMockModel(); } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::slotMockModelCustomized() { RiaApplication* app = RiaApplication::instance(); app->createMockModelCustomized(); } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::slotInputMockModel() { RiaApplication* app = RiaApplication::instance(); app->createInputMockModel(); } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- QMdiSubWindow* RiuMainWindow::findMdiSubWindow( QWidget* viewer ) { QList subws = m_mdiArea->subWindowList(); int i; for ( i = 0; i < subws.size(); ++i ) { if ( subws[i]->widget() == viewer ) { return subws[i]; } } return nullptr; } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- RimViewWindow* RiuMainWindow::findViewWindowFromSubWindow( QMdiSubWindow* subWindow ) { if ( subWindow ) { std::vector allViewWindows; RimProject::current()->descendantsIncludingThisOfType( allViewWindows ); for ( RimViewWindow* viewWindow : allViewWindows ) { if ( viewWindow->viewWidget() == subWindow->widget() ) { return viewWindow; } } } return nullptr; } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- QList RiuMainWindow::subWindowList( QMdiArea::WindowOrder order ) { return m_mdiArea->subWindowList( order ); } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- RiuResultQwtPlot* RiuMainWindow::resultPlot() { return m_resultQwtPlot; } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- RiuRelativePermeabilityPlotPanel* RiuMainWindow::relativePermeabilityPlotPanel() { return m_relPermPlotPanel; } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- RiuPvtPlotPanel* RiuMainWindow::pvtPlotPanel() { return m_pvtPlotPanel; } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- RiuMohrsCirclePlot* RiuMainWindow::mohrsCirclePlot() { return m_mohrsCirclePlot; } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- RiuMessagePanel* RiuMainWindow::messagePanel() { return m_messagePanel; } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::removeViewer( QWidget* viewer ) { removeViewerFromMdiArea( m_mdiArea, viewer ); slotRefreshViewActions(); } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::initializeViewer( QMdiSubWindow* subWindow, QWidget* viewer, const RimMdiWindowGeometry& windowsGeometry ) { QSize subWindowSize; QPoint subWindowPos( -1, -1 ); if ( windowsGeometry.isValid() ) { subWindowPos = QPoint( windowsGeometry.x, windowsGeometry.y ); subWindowSize = QSize( windowsGeometry.width, windowsGeometry.height ); } else { subWindowSize = QSize( 400, 400 ); } initializeSubWindow( m_mdiArea, subWindow, subWindowPos, subWindowSize ); subWindow->setWidget( viewer ); slotRefreshViewActions(); } //-------------------------------------------------------------------------------------------------- /// This method needs to handle memory deallocation !!! //-------------------------------------------------------------------------------------------------- void RiuMainWindow::setPdmRoot( caf::PdmObject* pdmRoot ) { m_pdmRoot = pdmRoot; for ( auto tv : projectTreeViews() ) { tv->setPdmItem( pdmRoot ); } for ( auto& additionalProjectView : m_additionalProjectViews ) { if ( !additionalProjectView ) continue; RiuProjectAndPropertyView* projPropView = dynamic_cast( additionalProjectView->widget() ); if ( projPropView ) { projPropView->setPdmItem( pdmRoot ); } } caf::SelectionManager::instance()->setPdmRootObject( pdmRoot ); } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::slotViewFromNorth() { if ( RiaApplication::instance()->activeReservoirView() && RiaApplication::instance()->activeReservoirView()->viewer() ) { RiaApplication::instance()->activeReservoirView()->viewer()->setView( cvf::Vec3d( 0, -1, 0 ), cvf::Vec3d( 0, 0, 1 ) ); } } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::slotViewFromSouth() { if ( RiaApplication::instance()->activeReservoirView() && RiaApplication::instance()->activeReservoirView()->viewer() ) { RiaApplication::instance()->activeReservoirView()->viewer()->setView( cvf::Vec3d( 0, 1, 0 ), cvf::Vec3d( 0, 0, 1 ) ); } } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::slotViewFromEast() { if ( RiaApplication::instance()->activeReservoirView() && RiaApplication::instance()->activeReservoirView()->viewer() ) { RiaApplication::instance()->activeReservoirView()->viewer()->setView( cvf::Vec3d( -1, 0, 0 ), cvf::Vec3d( 0, 0, 1 ) ); } } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::slotViewFromWest() { if ( RiaApplication::instance()->activeReservoirView() && RiaApplication::instance()->activeReservoirView()->viewer() ) { RiaApplication::instance()->activeReservoirView()->viewer()->setView( cvf::Vec3d( 1, 0, 0 ), cvf::Vec3d( 0, 0, 1 ) ); } } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::slotViewFromAbove() { if ( RiaApplication::instance()->activeReservoirView() && RiaApplication::instance()->activeReservoirView()->viewer() ) { RiaApplication::instance()->activeReservoirView()->viewer()->setView( cvf::Vec3d( 0, 0, -1 ), cvf::Vec3d( 0, 1, 0 ) ); } } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::slotViewFromBelow() { if ( RiaApplication::instance()->activeReservoirView() && RiaApplication::instance()->activeReservoirView()->viewer() ) { RiaApplication::instance()->activeReservoirView()->viewer()->setView( cvf::Vec3d( 0, 0, 1 ), cvf::Vec3d( 0, 1, 0 ) ); } } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::slotSubWindowActivated( QMdiSubWindow* subWindow ) { if ( isBlockingSubWindowActivatedSignal() ) return; Rim3dView* previousActiveReservoirView = RiaApplication::instance()->activeReservoirView(); Rim3dView* activatedView = dynamic_cast( findViewWindowFromSubWindow( subWindow ) ); if ( !activatedView ) return; RiaApplication::instance()->setActiveReservoirView( activatedView ); if ( !isBlockingViewSelectionOnSubWindowActivated() ) { selectViewInProjectTreePreservingSubItemSelection( previousActiveReservoirView, activatedView ); } slotRefreshViewActions(); refreshAnimationActions(); refreshDrawStyleActions(); } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::selectViewInProjectTreePreservingSubItemSelection( const Rim3dView* previousActiveReservoirView, Rim3dView* activatedView ) { bool is3dViewCurrentlySelected = false; if ( caf::SelectionManager::instance()->selectedItem() ) { if ( caf::SelectionManager::instance()->selectedItemAncestorOfType() ) { is3dViewCurrentlySelected = true; } } if ( is3dViewCurrentlySelected && ( previousActiveReservoirView != activatedView ) ) { QModelIndex newViewModelIndex = projectTreeView( 0 )->findModelIndex( activatedView ); if ( !newViewModelIndex.isValid() ) return; QModelIndex newSelectionIndex = newViewModelIndex; if ( previousActiveReservoirView && is3dViewCurrentlySelected ) { // Try to select the same entry in the new View, as was selected in the previous QModelIndex previousViewModelIndex = projectTreeView( 0 )->findModelIndex( previousActiveReservoirView ); QModelIndex currentSelectionIndex = projectTreeView( 0 )->treeView()->selectionModel()->currentIndex(); if ( currentSelectionIndex != newViewModelIndex && currentSelectionIndex.isValid() ) { QVector route; // Contains all model indices from current selection up to previous view QModelIndex tmpModelIndex = currentSelectionIndex; while ( tmpModelIndex.isValid() && tmpModelIndex != previousViewModelIndex ) { // NB! Add model index to front of vector to be able to do a for-loop with correct ordering route.push_front( tmpModelIndex ); tmpModelIndex = tmpModelIndex.parent(); } // Traverse model indices from new view index to currently selected item int i; for ( i = 0; i < route.size(); i++ ) { QModelIndex tmp = route[i]; if ( newSelectionIndex.isValid() ) { newSelectionIndex = projectTreeView( 0 )->treeView()->model()->index( tmp.row(), tmp.column(), newSelectionIndex ); } } // Use view model index if anything goes wrong if ( !newSelectionIndex.isValid() ) { newSelectionIndex = newViewModelIndex; } } } projectTreeView( 0 )->treeView()->setCurrentIndex( newSelectionIndex ); if ( newSelectionIndex != newViewModelIndex ) { projectTreeView( 0 )->treeView()->setExpanded( newViewModelIndex, true ); } } } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::setActiveViewer( QWidget* viewer ) { QMdiSubWindow* swin = findMdiSubWindow( viewer ); if ( swin ) m_mdiArea->setActiveSubWindow( swin ); } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- RiuProcessMonitor* RiuMainWindow::processMonitor() { return m_processMonitor; } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void appendToggleActionForDockingWidget( QMenu* menu, QWidget* parent, const QString& dockWidgetName ) { if ( menu ) { QAction* action = RiuDockWidgetTools::toggleActionForWidget( parent, dockWidgetName ); if ( action ) { // Some dock windows are depending on configuration (mohrs circle plot), so do not assert they exist menu->addAction( action ); } } } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::slotBuildWindowActions() { m_windowMenu->clear(); { caf::CmdFeatureManager* cmdFeatureMgr = caf::CmdFeatureManager::instance(); m_windowMenu->addAction( cmdFeatureMgr->action( "RicShowPlotWindowFeature" ) ); m_windowMenu->addSeparator(); m_windowMenu->addAction( cmdFeatureMgr->action( "RicDefaultDockConfigEclipseFeature" ) ); #ifdef USE_ODB_API m_windowMenu->addAction( cmdFeatureMgr->action( "RicDefaultDockConfigGeoMechFeature" ) ); #endif m_windowMenu->addSeparator(); } appendToggleActionForDockingWidget( m_windowMenu, this, RiuDockWidgetTools::projectTreeName() ); appendToggleActionForDockingWidget( m_windowMenu, this, RiuDockWidgetTools::propertyEditorName() ); appendToggleActionForDockingWidget( m_windowMenu, this, RiuDockWidgetTools::messagesName() ); appendToggleActionForDockingWidget( m_windowMenu, this, RiuDockWidgetTools::processMonitorName() ); appendToggleActionForDockingWidget( m_windowMenu, this, RiuDockWidgetTools::undoStackName() ); m_windowMenu->addSeparator(); appendToggleActionForDockingWidget( m_windowMenu, this, RiuDockWidgetTools::resultInfoName() ); appendToggleActionForDockingWidget( m_windowMenu, this, RiuDockWidgetTools::resultPlotName() ); appendToggleActionForDockingWidget( m_windowMenu, this, RiuDockWidgetTools::relPermPlotName() ); appendToggleActionForDockingWidget( m_windowMenu, this, RiuDockWidgetTools::pvtPlotName() ); appendToggleActionForDockingWidget( m_windowMenu, this, RiuDockWidgetTools::mohrsCirclePlotName() ); m_windowMenu->addSeparator(); QAction* cascadeWindowsAction = new QAction( "Cascade Windows", this ); cascadeWindowsAction->setIcon( QIcon( ":/CascadeWindows.svg" ) ); connect( cascadeWindowsAction, SIGNAL( triggered() ), m_mdiArea, SLOT( cascadeSubWindows() ) ); QAction* closeAllSubWindowsAction = new QAction( "Close All Windows", this ); connect( closeAllSubWindowsAction, SIGNAL( triggered() ), m_mdiArea, SLOT( closeAllSubWindows() ) ); m_windowMenu->addAction( caf::CmdFeatureManager::instance()->action( "RicTileWindowsFeature" ) ); m_windowMenu->addAction( cascadeWindowsAction ); m_windowMenu->addAction( closeAllSubWindowsAction ); m_windowMenu->addSeparator(); m_windowMenu->addAction( m_newPropertyView ); } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::selectedObjectsChanged() { std::vector uiItems; projectTreeView( 0 )->selectedUiItems( uiItems ); caf::PdmObjectHandle* firstSelectedObject = nullptr; if ( !uiItems.empty() ) { firstSelectedObject = dynamic_cast( uiItems.front() ); } updateUiFieldsFromActiveResult( firstSelectedObject ); m_pdmUiPropertyView->showProperties( firstSelectedObject ); if ( uiItems.size() == 1 && m_allowActiveViewChangeFromSelection ) { // Find the reservoir view or the Plot that the selected item is within if ( !firstSelectedObject ) { caf::PdmFieldHandle* selectedField = dynamic_cast( uiItems.front() ); if ( selectedField ) firstSelectedObject = selectedField->ownerObject(); } if ( !firstSelectedObject ) return; // First check if we are within a RimView Rim3dView* selectedReservoirView = dynamic_cast( firstSelectedObject ); if ( !selectedReservoirView ) { firstSelectedObject->firstAncestorOrThisOfType( selectedReservoirView ); } bool isActiveViewChanged = false; if ( selectedReservoirView ) { // Set focus in MDI area to this window if it exists if ( selectedReservoirView->viewer() ) { setBlockViewSelectionOnSubWindowActivated( true ); setActiveViewer( selectedReservoirView->viewer()->layoutWidget() ); setBlockViewSelectionOnSubWindowActivated( false ); isActiveViewChanged = true; } } if ( isActiveViewChanged ) { RiaApplication::instance()->setActiveReservoirView( selectedReservoirView ); refreshDrawStyleActions(); refreshAnimationActions(); slotRefreshFileActions(); slotRefreshUndoRedoActions(); slotRefreshViewActions(); // The only way to get to this code is by selection change initiated from the project tree view // As we are activating an MDI-window, the focus is given to this MDI-window // Set focus back to the tree view to be able to continue keyboard tree view navigation projectTreeView( 0 )->treeView()->setFocus(); } } } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::slotNewObjectPropertyView() { QDockWidget* dockWidget = new QDockWidget( QString( "Additional Project Tree (%1)" ).arg( m_additionalProjectViews.size() + 1 ), this ); dockWidget->setObjectName( "dockWidget" ); dockWidget->setAllowedAreas( Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea ); RiuProjectAndPropertyView* projPropView = new RiuProjectAndPropertyView( dockWidget ); dockWidget->setWidget( projPropView ); projPropView->setPdmItem( m_pdmRoot ); addDockWidget( Qt::RightDockWidgetArea, dockWidget ); m_additionalProjectViews.push_back( dockWidget ); } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::slotSnapshotAllViewsToFile() { RiaApplication* app = RiaApplication::instance(); // Save images in snapshot catalog relative to project directory QString absolutePathToSnapshotDir = app->createAbsolutePathFromProjectRelativePath( "snapshots" ); RicSnapshotAllViewsToFileFeature::exportSnapshotOfViewsIntoFolder( absolutePathToSnapshotDir ); } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::slotDrawStyleChanged( QAction* activatedAction ) { if ( !RiaApplication::instance()->activeReservoirView() ) return; if ( activatedAction == m_drawStyleLinesAction ) { RiaApplication::instance()->activeReservoirView()->setMeshOnlyDrawstyle(); } else if ( activatedAction == m_drawStyleLinesSolidAction ) { RiaApplication::instance()->activeReservoirView()->setMeshSurfDrawstyle(); } else if ( activatedAction == m_drawStyleSurfOnlyAction ) { RiaApplication::instance()->activeReservoirView()->setSurfOnlyDrawstyle(); } else if ( activatedAction == m_drawStyleFaultLinesSolidAction ) { RiaApplication::instance()->activeReservoirView()->setFaultMeshSurfDrawstyle(); } } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::slotToggleHideGridCellsAction( bool hideGridCells ) { if ( !RiaApplication::instance()->activeReservoirView() ) return; RimGridView* rigv = RiaApplication::instance()->activeGridView(); if ( rigv ) rigv->showGridCells( !hideGridCells ); } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::slotToggleFaultLabelsAction( bool showLabels ) { Rim3dView* activeView = RiaApplication::instance()->activeReservoirView(); RimEclipseView* activeRiv = dynamic_cast( activeView ); if ( !activeRiv ) { Rim2dIntersectionView* isectView = dynamic_cast( activeView ); if ( isectView ) { isectView->intersection()->firstAncestorOrThisOfType( activeRiv ); } } if ( !activeRiv ) return; activeRiv->faultCollection()->showFaultLabel.setValueWithFieldChanged( showLabels ); refreshDrawStyleActions(); } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::refreshDrawStyleActions() { RimGridView* gridView = RiaApplication::instance()->activeGridView(); RimEclipseContourMapView* view2d = dynamic_cast( gridView ); bool is2dMap = view2d != nullptr; bool is3dGridView = gridView != nullptr && !is2dMap; Rim3dView* view = RiaApplication::instance()->activeReservoirView(); bool is3dView = view != nullptr && !is2dMap; m_drawStyleLinesAction->setEnabled( is3dView ); m_drawStyleLinesSolidAction->setEnabled( is3dView ); m_drawStyleSurfOnlyAction->setEnabled( is3dView ); m_drawStyleFaultLinesSolidAction->setEnabled( is3dView ); m_enableLightingAction->setEnabled( is3dView ); bool lightingEnabled = view ? !view->isLightingDisabled() : true; m_enableLightingAction->blockSignals( true ); m_enableLightingAction->setChecked( lightingEnabled ); if ( lightingEnabled ) { m_enableLightingAction->setIcon( QIcon( ":/DrawLightingEnabled.svg" ) ); } else { m_enableLightingAction->setIcon( QIcon( ":/DrawLightingDisabled.svg" ) ); } m_enableLightingAction->blockSignals( false ); m_drawStyleHideGridCellsAction->setEnabled( is3dGridView ); if ( is3dGridView ) { m_drawStyleHideGridCellsAction->blockSignals( true ); m_drawStyleHideGridCellsAction->setChecked( !view->isGridVisualizationMode() ); m_drawStyleHideGridCellsAction->blockSignals( false ); } RimEclipseView* eclView = dynamic_cast( view ); bool hasEclipseView = eclView != nullptr; m_showWellCellsAction->setEnabled( hasEclipseView && !is2dMap ); if ( hasEclipseView && !is2dMap ) { m_showWellCellsAction->blockSignals( true ); eclView->wellCollection()->updateStateForVisibilityCheckboxes(); m_showWellCellsAction->setChecked( eclView->wellCollection()->showWellCells() ); m_showWellCellsAction->blockSignals( false ); } if ( !eclView ) { Rim2dIntersectionView* intView = dynamic_cast( view ); if ( intView && intView->intersection() ) { intView->intersection()->firstAncestorOrThisOfType( eclView ); } } m_toggleFaultsLabelAction->setEnabled( eclView != nullptr ); if ( eclView ) { m_toggleFaultsLabelAction->blockSignals( true ); m_toggleFaultsLabelAction->setChecked( eclView->faultCollection()->showFaultLabel() ); m_toggleFaultsLabelAction->blockSignals( false ); } } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::slotToggleLightingAction( bool enable ) { Rim3dView* view = RiaApplication::instance()->activeReservoirView(); if ( view ) { view->disableLighting( !enable ); } refreshDrawStyleActions(); } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::restoreTreeViewState() { restoreTreeViewStates( RimProject::current()->mainWindowTreeViewStates(), RimProject::current()->mainWindowCurrentModelIndexPaths() ); } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::updateUiFieldsFromActiveResult( caf::PdmObjectHandle* objectToUpdate ) { RimEclipseResultDefinition* resultDefinition = nullptr; resultDefinition = dynamic_cast( objectToUpdate ); if ( resultDefinition ) { resultDefinition->updateUiFieldsFromActiveResult(); } RimEclipsePropertyFilter* eclPropFilter = nullptr; eclPropFilter = dynamic_cast( objectToUpdate ); if ( eclPropFilter ) { eclPropFilter->updateUiFieldsFromActiveResult(); } RimEclipseFaultColors* eclFaultColors = nullptr; eclFaultColors = dynamic_cast( objectToUpdate ); if ( eclFaultColors ) { eclFaultColors->updateUiFieldsFromActiveResult(); } RimCellEdgeColors* cellEdgeColors = nullptr; cellEdgeColors = dynamic_cast( objectToUpdate ); if ( cellEdgeColors ) { cellEdgeColors->updateUiFieldsFromActiveResult(); } } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::updateMemoryUsage() { uint64_t currentUsage = caf::MemoryInspector::getApplicationPhysicalMemoryUsageMiB(); uint64_t totalPhysicalMemory = caf::MemoryInspector::getTotalPhysicalMemoryMiB(); uint64_t totalVirtualMemory = caf::MemoryInspector::getTotalVirtualMemoryMiB(); uint64_t availVirtualMemory = caf::MemoryInspector::getAvailableVirtualMemoryMiB(); QColor okColor( 0, 150, 0 ); QColor warningColor( 200, 0, 0 ); QColor criticalColor( 255, 100, 0 ); float currentUsageFraction = 0.0f; float availVirtualFraction = 1.0f; if ( currentUsage > 0u && totalPhysicalMemory > 0u ) { currentUsageFraction = std::min( 1.0f, static_cast( currentUsage ) / totalPhysicalMemory ); } if ( availVirtualMemory > 0u && totalVirtualMemory > 0u ) { availVirtualFraction = static_cast( availVirtualMemory ) / totalVirtualMemory; } QColor usageColor( (int)( okColor.red() * ( 1.0 - currentUsageFraction ) + warningColor.red() * currentUsageFraction ), (int)( okColor.green() * ( 1.0 - currentUsageFraction ) + warningColor.green() * currentUsageFraction ), (int)( okColor.blue() * ( 1.0 - currentUsageFraction ) + warningColor.blue() * currentUsageFraction ) ); m_memoryCriticalWarning->setText( QString( "" ) ); if ( availVirtualFraction < caf::MemoryInspector::getRemainingMemoryCriticalThresholdFraction() ) { m_memoryCriticalWarning->setText( QString( "Available System Memory Critically Low!" ) ); m_memoryCriticalWarning->setProperty( "styleRole", "memoryCriticalWarning" ); } else { m_memoryCriticalWarning->setText( QString( "" ) ); } m_memoryUsedButton->setText( QString( "Memory Used: %1 MiB" ).arg( currentUsage ) ); m_memoryUsedButton->setProperty( "styleRole", "memoryUsedButton" ); m_memoryTotalStatus->setText( QString( "Total Physical Memory: %1 MiB" ).arg( totalPhysicalMemory ) ); m_memoryTotalStatus->setProperty( "styleRole", "memoryTotalStatus" ); m_memoryUsedButton->setStyleSheet( QString( "QLabel {color: %1;}" ).arg( usageColor.name() ) ); } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::showProcessMonitorDockPanel() { RiuDockWidgetTools::setDockWidgetVisibility( this, RiuDockWidgetTools::processMonitorName(), true ); } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::setDefaultToolbarVisibility() { m_holoLensToolBar->hide(); } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::applyFontSizesToDockedPlots() { if ( m_resultQwtPlot ) { m_resultQwtPlot->applyFontSizes( true ); } if ( m_mohrsCirclePlot ) { m_mohrsCirclePlot->applyFontSizes( true ); } if ( m_relPermPlotPanel ) { m_relPermPlotPanel->applyFontSizes( true ); } if ( m_pvtPlotPanel ) { m_pvtPlotPanel->applyFontSizes( true ); } } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::slotScaleChanged( int scaleValue ) { if ( RiaApplication::instance()->activeReservoirView() ) { RiaApplication::instance()->activeReservoirView()->scaleZ.setValueWithFieldChanged( scaleValue ); } } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::updateScaleValue() { Rim3dView* view = RiaApplication::instance()->activeReservoirView(); bool isRegularReservoirView = view && dynamic_cast( view ) == nullptr; if ( isRegularReservoirView && view->isScaleZEditable() ) { m_scaleFactor->setEnabled( true ); int scaleValue = static_cast( view->scaleZ() ); // Round down is probably ok. m_scaleFactor->blockSignals( true ); m_scaleFactor->setValue( scaleValue ); m_scaleFactor->blockSignals( false ); } else { m_scaleFactor->setEnabled( false ); } } //-------------------------------------------------------------------------------------------------- /// TODO: This function will be moved to a class responsible for handling the application selection concept //-------------------------------------------------------------------------------------------------- void RiuMainWindow::selectedCases( std::vector& cases ) { caf::SelectionManager::instance()->objectsByType( &cases ); } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::slotCreateCommandObject() { RiaApplication* app = RiaApplication::instance(); if ( !app->project() ) return; std::vector selectedUiItems; projectTreeView( 0 )->selectedUiItems( selectedUiItems ); caf::PdmObjectGroup selectedObjects; for ( auto* selectedUiItem : selectedUiItems ) { caf::PdmUiObjectHandle* uiObj = dynamic_cast( selectedUiItem ); if ( uiObj ) { selectedObjects.addObject( uiObj->objectHandle() ); } } if ( !selectedObjects.objects.empty() ) { std::vector commandObjects; RimCommandFactory::createCommandObjects( selectedObjects, &commandObjects ); for ( auto* commandObject : commandObjects ) { app->project()->commandObjects.push_back( commandObject ); } app->project()->updateConnectedEditors(); } } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::slotShowRegressionTestDialog() { RiaRegressionTest regTestConfig; regTestConfig.readSettingsFromApplicationStore(); caf::PdmUiPropertyViewDialog regressionTestDialog( this, ®TestConfig, "Regression Test", "" ); regressionTestDialog.resize( QSize( 600, 350 ) ); if ( regressionTestDialog.exec() == QDialog::Accepted ) { // Write preferences using QSettings and apply them to the application regTestConfig.writeSettingsToApplicationStore(); RiaRegressionTestRunner::instance()->executeRegressionTests(); } } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::slotExecutePaintEventPerformanceTest() { if ( RiaApplication::instance()->activeReservoirView() && RiaApplication::instance()->activeReservoirView()->viewer() ) { size_t redrawCount = 50; caf::Viewer* viewer = RiaApplication::instance()->activeReservoirView()->viewer(); cvf::Timer timer; for ( size_t i = 0; i < redrawCount; i++ ) { viewer->repaint(); } double totalTimeMS = timer.time() * 1000.0; double msPerFrame = totalTimeMS / redrawCount; QString resultInfo = QString( "Total time '%1 ms' for %2 number of redraws, frame time '%3 ms'" ) .arg( totalTimeMS ) .arg( redrawCount ) .arg( msPerFrame ); setResultInfo( resultInfo ); } } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::setDefaultWindowSize() { resize( 1000, 810 ); } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::slotShowWellCellsAction( bool doAdd ) { RimEclipseView* riv = dynamic_cast( RiaApplication::instance()->activeReservoirView() ); if ( riv ) { riv->wellCollection()->setShowWellCellsState( doAdd ); } } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::customMenuRequested( const QPoint& pos ) { QMenu menu; RiaApplication* app = RiaApplication::instance(); app->project()->actionsBasedOnSelection( menu ); // Qt doc: QAbstractScrollArea and its subclasses that map the context menu event to coordinates of the viewport(). // Since we might get this signal from different treeViews, we need to map the position accordingly. QObject* senderObj = this->sender(); QTreeView* treeView = dynamic_cast( senderObj ); if ( treeView ) { QPoint globalPos = treeView->viewport()->mapToGlobal( pos ); menu.exec( globalPos ); } } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::slotWorkaroundForQwtDockWidgets() { RiuDockWidgetTools::workaroundForQwtDockWidgets(); } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::tileSubWindows() { QMdiArea::WindowOrder currentActivationOrder = m_mdiArea->activationOrder(); // Tile Windows so the one with the leftmost left edge gets sorted first. std::list windowList; for ( QMdiSubWindow* subWindow : m_mdiArea->subWindowList( currentActivationOrder ) ) { windowList.push_back( subWindow ); } // Get the active view linker if there is one RimProject* proj = RimProject::current(); RimViewLinkerCollection* viewLinkerCollection = proj->viewLinkerCollection(); RimViewLinker* viewLinker = nullptr; if ( viewLinkerCollection && viewLinkerCollection->isActive() ) { viewLinker = viewLinkerCollection->viewLinker(); } // Perform stable sort of list so we first sort by window position but retain activation order // for windows with the same position. windowList.sort( [this, viewLinker]( QMdiSubWindow* lhs, QMdiSubWindow* rhs ) { RimViewWindow* lhsViewWindow = findViewWindowFromSubWindow( lhs ); RimViewWindow* rhsViewWindow = findViewWindowFromSubWindow( rhs ); RimGridView* lhsGridView = dynamic_cast( lhsViewWindow ); RimGridView* rhsGridView = dynamic_cast( rhsViewWindow ); if ( viewLinker ) { if ( viewLinker->isFirstViewDependentOnSecondView( lhsGridView, rhsGridView ) ) { return true; } else if ( viewLinker->isFirstViewDependentOnSecondView( rhsGridView, lhsGridView ) ) { return false; } } if ( lhs->frameGeometry().topLeft().ry() == rhs->frameGeometry().topLeft().ry() ) { return lhs->frameGeometry().topLeft().rx() < rhs->frameGeometry().topLeft().rx(); } return lhs->frameGeometry().topLeft().ry() < rhs->frameGeometry().topLeft().ry(); } ); // Based on workaround described here // https://forum.qt.io/topic/50053/qmdiarea-tilesubwindows-always-places-widgets-in-activationhistoryorder-in-subwindowview-mode bool prevActivationBlock = isBlockingSubWindowActivatedSignal(); QMdiSubWindow* a = m_mdiArea->activeSubWindow(); // Force activation order so they end up in the order of the loop. m_mdiArea->setActivationOrder( QMdiArea::ActivationHistoryOrder ); setBlockSubWindowActivatedSignal( true ); // Activate in reverse order for ( auto it = windowList.rbegin(); it != windowList.rend(); ++it ) { m_mdiArea->setActiveSubWindow( *it ); } m_mdiArea->tileSubWindows(); // Set back the original activation order to avoid messing with the standard ordering m_mdiArea->setActivationOrder( currentActivationOrder ); m_mdiArea->setActiveSubWindow( a ); setBlockSubWindowActivatedSignal( prevActivationBlock ); storeSubWindowTiling( true ); } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::storeSubWindowTiling( bool tiled ) { RimProject::current()->setSubWindowsTiledIn3DWindow( tiled ); refreshViewActions(); } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- void RiuMainWindow::clearWindowTiling() { setBlockSubWindowActivatedSignal( true ); QMdiArea::WindowOrder currentActivationOrder = m_mdiArea->activationOrder(); for ( QMdiSubWindow* subWindow : m_mdiArea->subWindowList( currentActivationOrder ) ) { subWindow->hide(); subWindow->showNormal(); } storeSubWindowTiling( false ); setBlockSubWindowActivatedSignal( false ); } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- bool RiuMainWindow::subWindowsAreTiled() const { if ( RimProject::current() ) { return RimProject::current()->subWindowsTiled3DWindow(); } return false; } //-------------------------------------------------------------------------------------------------- /// //-------------------------------------------------------------------------------------------------- bool RiuMainWindow::isAnyMdiSubWindowVisible() { return !m_mdiArea->subWindowList().empty(); }