OilfieldToolsNet/ResInsight
4
0
Fork 0
mirror of https://github.com/OPM/ResInsight.git synced 2025-02-04 04:30:51 -06:00
Code Issues Packages Projects Releases Wiki Activity
7b81490f90
ResInsight/ApplicationLibCode/UserInterface/RiuMainWindow.cpp
Magne Sjaastad 945f1b1902
Use field auto values for summary plots 
Use auto value concept in summary plot configuration. Default behavior is unchanged, but it is now possible to unlink a field to specify a custom value for this field.

Other changes:
* Add missing requirement for Svg in test application
* Use calculator icon and rename panel text
Use icon and relevant text to make it clear that the content in Calculator Data can be used for Grid Property Calculator and nothing else.
* Add example with scoped enum and auto value
* Use enum value starting av 10 to make sure enum values (not option item index) are working as expected
2022-09-05 14:12:49 +02:00

2109 lines
86 KiB
C++
Raw Blame History

/////////////////////////////////////////////////////////////////////////////////
//
// 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 <http://www.gnu.org/licenses/gpl.html>
// 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 "RicGridCalculatorDialog.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 "ApplicationCommands/RicLaunchRegressionTestsFeature.h"
#include "ExportCommands/RicSnapshotAllViewsToFileFeature.h"
#include "MeasurementCommands/RicToggleMeasurementModeFeature.h"
#include "SummaryPlotCommands/RicEditSummaryPlotFeature.h"
#include "SummaryPlotCommands/RicShowSummaryCurveCalculatorFeature.h"
#include "cvfTimer.h"
#include "DockAreaWidget.h"
#include <QAction>
#include <QCloseEvent>
#include <QComboBox>
#include <QDir>
#include <QLabel>
#include <QLayout>
#include <QMdiSubWindow>
#include <QMenuBar>
#include <QSpinBox>
#include <QStatusBar>
#include <QTimer>
#include <QToolBar>
#include <QToolButton>
#include <QTreeView>
#include <QUndoStack>
#include <QUndoView>
#include <QDebug>
#include <algorithm>
//==================================================================================================
///
/// \class RiuMainWindow
///
/// Contains our main window
///
//==================================================================================================
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiuMainWindow::RiuMainWindow()
: m_pdmRoot( nullptr )
, m_relPermPlotPanel( nullptr )
, m_pvtPlotPanel( nullptr )
, m_mohrsCirclePlot( nullptr )
, m_holoLensToolBar( nullptr )
{
setAttribute( Qt::WA_DeleteOnClose );
m_mdiArea = new RiuMdiArea( this );
connect( m_mdiArea, SIGNAL( subWindowActivated( QMdiSubWindow* ) ), SLOT( slotSubWindowActivated( QMdiSubWindow* ) ) );
ads::CDockWidget* cWidget =
RiuDockWidgetTools::createDockWidget( "3D Views", RiuDockWidgetTools::main3DWindowName(), this );
cWidget->setWidget( m_mdiArea );
dockManager()->setCentralWidget( cWidget );
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 );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiuMainWindow::~RiuMainWindow()
{
setPdmRoot( nullptr );
if ( m_pdmUiPropertyView )
{
m_pdmUiPropertyView->showProperties( nullptr );
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiuMainWindow* RiuMainWindow::instance()
{
if ( RiaGuiApplication::isRunning() )
{
return RiaGuiApplication::instance()->mainWindow();
}
return nullptr;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuMainWindow::closeIfOpen()
{
if ( instance() != nullptr ) instance()->close();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
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<RiuProjectAndPropertyView*>( additionalProjectView->widget() );
if ( projPropView )
{
projPropView->showProperties( nullptr );
}
}
RicEditSummaryPlotFeature* editSumCurves = dynamic_cast<RicEditSummaryPlotFeature*>(
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();
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<QAction*> 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" ) );
toolbar->addAction( cmdFeatureMgr->action( "RicShowGridCalculatorFeature" ) );
}
{
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 QComboBox( toolbar );
QStringList scaleItems;
for ( auto d : RiaDefines::viewScaleOptions() )
{
m_scaleFactor->addItem( QString::number( d ), QVariant( d ) );
}
toolbar->addWidget( m_scaleFactor );
connect( m_scaleFactor, SIGNAL( currentIndexChanged( 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( "RicLaunchRegressionTestDialogFeature" ) );
toolbar->addAction( cmdFeatureMgr->action( "RicShowClassNamesFeature" ) );
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 = 3;
const std::vector<QString> treeViewTitles = { "Project Tree", "Calculator Data ", "Scripts" };
const std::vector<QString> treeViewConfigs = { "MainWindow.ProjectTree", "MainWindow.DataSources", "MainWindow.Scripts" };
const std::vector<QString> treeViewDockNames = { RiuDockWidgetTools::mainWindowProjectTreeName(),
RiuDockWidgetTools::mainWindowDataSourceTreeName(),
RiuDockWidgetTools::mainWindowScriptsTreeName() };
const std::vector<ads::DockWidgetArea> defaultDockWidgetArea{ ads::DockWidgetArea::LeftDockWidgetArea,
ads::DockWidgetArea::LeftDockWidgetArea,
ads::DockWidgetArea::LeftDockWidgetArea };
createTreeViews( nTreeViews );
std::vector<ads::CDockWidget*> rightWidgets;
std::vector<ads::CDockWidget*> leftWidgets;
std::vector<ads::CDockWidget*> bottomWidgets;
for ( int i = 0; i < nTreeViews; i++ )
{
auto dockWidget = RiuDockWidgetTools::createDockWidget( treeViewTitles[i], treeViewDockNames[i], dockManager() );
caf::PdmUiTreeView* projectTree = projectTreeView( i );
projectTree->enableSelectionManagerUpdating( true );
projectTree->enableAppendOfClassNameToUiItemText( RiaPreferencesSystem::current()->appendClassNameToUiText() );
dockWidget->setWidget( projectTree );
dockWidget->hide();
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 );
if ( defaultDockWidgetArea[i] == ads::DockWidgetArea::LeftDockWidgetArea ) leftWidgets.push_back( dockWidget );
if ( defaultDockWidgetArea[i] == ads::DockWidgetArea::RightDockWidgetArea )
rightWidgets.push_back( dockWidget );
connect( dockWidget, SIGNAL( visibilityChanged( bool ) ), projectTree, SLOT( treeVisibilityChanged( bool ) ) );
connect( projectTree, SIGNAL( selectionChanged() ), this, SLOT( selectedObjectsChanged() ) );
projectTree->treeView()->setContextMenuPolicy( Qt::CustomContextMenu );
connect( projectTree->treeView(),
SIGNAL( customContextMenuRequested( const QPoint& ) ),
SLOT( customMenuRequested( const QPoint& ) ) );
projectTree->setUiConfigurationName( treeViewConfigs[i] );
}
// undo/redo view
if ( m_undoView && RiaPreferences::current()->useUndoRedo() )
{
auto dockWidget = RiuDockWidgetTools::createDockWidget( "Undo Stack",
RiuDockWidgetTools::mainWindowUndoStackName(),
dockManager() );
dockWidget->setWidget( m_undoView );
rightWidgets.push_back( dockWidget );
}
{
auto dockWidget = RiuDockWidgetTools::createDockWidget( "Result Plot",
RiuDockWidgetTools::mainWindowResultPlotName(),
dockManager() );
m_resultQwtPlot = new RiuResultQwtPlot( dockWidget );
dockWidget->setWidget( m_resultQwtPlot );
bottomWidgets.push_back( dockWidget );
}
ads::CDockAreaWidget* leftArea = addTabbedWidgets( leftWidgets, ads::DockWidgetArea::LeftDockWidgetArea );
ads::CDockAreaWidget* rightArea = addTabbedWidgets( rightWidgets, ads::DockWidgetArea::RightDockWidgetArea );
ads::CDockAreaWidget* bottomArea = addTabbedWidgets( bottomWidgets,
ads::DockWidgetArea::BottomDockWidgetArea,
dockManager()->centralWidget()->dockAreaWidget() );
{
auto dockWidget = RiuDockWidgetTools::createDockWidget( "Property Editor",
RiuDockWidgetTools::mainWindowPropertyEditorName(),
dockManager() );
m_pdmUiPropertyView = new caf::PdmUiPropertyView( dockWidget );
dockWidget->setWidget( m_pdmUiPropertyView );
dockManager()->addDockWidget( ads::DockWidgetArea::BottomDockWidgetArea, dockWidget, leftArea );
}
#ifdef USE_ODB_API
{
auto dockWidget = RiuDockWidgetTools::createDockWidget( "Mohr's Circle Plot",
RiuDockWidgetTools::mainWindowMohrsCirclePlotName(),
dockManager() );
m_mohrsCirclePlot = new RiuMohrsCirclePlot( dockWidget );
dockWidget->setWidget( m_mohrsCirclePlot );
dockManager()->addDockWidgetTabToArea( dockWidget, bottomArea );
}
#endif
{
auto dockWidget = RiuDockWidgetTools::createDockWidget( "Relative Permeability Plot",
RiuDockWidgetTools::mainWindowRelPermPlotName(),
dockManager() );
m_relPermPlotPanel = new RiuRelativePermeabilityPlotPanel( dockWidget );
dockWidget->setWidget( m_relPermPlotPanel );
dockManager()->addDockWidgetTabToArea( dockWidget, bottomArea );
}
{
auto dockWidget =
RiuDockWidgetTools::createDockWidget( "PVT Plot", RiuDockWidgetTools::mainWindowPvtPlotName(), dockManager() );
m_pvtPlotPanel = new RiuPvtPlotPanel( dockWidget );
dockWidget->setWidget( m_pvtPlotPanel );
dockManager()->addDockWidgetTabToArea( dockWidget, bottomArea );
}
// result info
{
auto dockWidget = RiuDockWidgetTools::createDockWidget( "Result Info",
RiuDockWidgetTools::mainWindowResultInfoName(),
dockManager() );
m_resultInfoPanel = new RiuResultInfoPanel( dockWidget );
dockWidget->setWidget( m_resultInfoPanel );
dockManager()->addDockWidget( ads::DockWidgetArea::LeftDockWidgetArea, dockWidget, bottomArea );
}
ads::CDockAreaWidget* procAndMsgTabs = nullptr;
// process monitor
{
auto dockWidget = RiuDockWidgetTools::createDockWidget( "Process Monitor",
RiuDockWidgetTools::mainWindowProcessMonitorName(),
dockManager() );
m_processMonitor = new RiuProcessMonitor( dockWidget );
dockWidget->setWidget( m_processMonitor );
procAndMsgTabs = dockManager()->addDockWidget( ads::DockWidgetArea::RightDockWidgetArea, dockWidget, bottomArea );
}
{
auto dockWidget =
RiuDockWidgetTools::createDockWidget( "Messages", RiuDockWidgetTools::mainWindowMessagesName(), dockManager() );
m_messagePanel = new RiuMessagePanel( dockWidget );
dockWidget->setWidget( m_messagePanel );
dockManager()->addDockWidgetTabToArea( dockWidget, procAndMsgTabs );
}
if ( leftArea ) leftArea->setCurrentIndex( 0 );
if ( rightArea ) rightArea->setCurrentIndex( 0 );
if ( bottomArea ) bottomArea->setCurrentIndex( 0 );
auto widgets = dockManager()->dockWidgetsMap().values();
for ( ads::CDockWidget* dock : widgets )
{
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<RimEclipseContourMapView*>( 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<RimEclipseView*>( 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<QMdiSubWindow*> 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<RimViewWindow*> allViewWindows;
RimProject::current()->descendantsIncludingThisOfType( allViewWindows );
for ( RimViewWindow* viewWindow : allViewWindows )
{
if ( viewWindow->viewWidget() == subWindow->widget() )
{
return viewWindow;
}
}
}
return nullptr;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QList<QMdiSubWindow*> 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<RiuProjectAndPropertyView*>( additionalProjectView->widget() );
if ( projPropView )
{
projPropView->setPdmItem( 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<Rim3dView*>( 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<Rim3dView>() )
{
is3dViewCurrentlySelected = true;
}
}
if ( is3dViewCurrentlySelected && ( previousActiveReservoirView != activatedView ) )
{
auto tv = getTreeViewWithItem( activatedView );
if ( !tv ) return;
QModelIndex newViewModelIndex = tv->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 = tv->findModelIndex( previousActiveReservoirView );
QModelIndex currentSelectionIndex = tv->treeView()->selectionModel()->currentIndex();
if ( currentSelectionIndex != newViewModelIndex && currentSelectionIndex.isValid() )
{
QVector<QModelIndex> 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 = tv->treeView()->model()->index( tmp.row(), tmp.column(), newSelectionIndex );
}
}
// Use view model index if anything goes wrong
if ( !newSelectionIndex.isValid() )
{
newSelectionIndex = newViewModelIndex;
}
}
}
tv->treeView()->setCurrentIndex( newSelectionIndex );
if ( newSelectionIndex != newViewModelIndex )
{
tv->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 RiuMainWindow::slotBuildWindowActions()
{
m_windowMenu->clear();
{
caf::CmdFeatureManager* cmdFeatureMgr = caf::CmdFeatureManager::instance();
m_windowMenu->addAction( cmdFeatureMgr->action( "RicShowPlotWindowFeature" ) );
m_windowMenu->addSeparator();
m_windowMenu->addSeparator();
}
addDefaultEntriesToWindowsMenu();
m_windowMenu->addSeparator();
m_windowMenu->addAction( m_newPropertyView );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuMainWindow::selectedObjectsChanged()
{
caf::PdmUiTreeView* projectTree = dynamic_cast<caf::PdmUiTreeView*>( sender() );
if ( !projectTree ) return;
std::vector<caf::PdmUiItem*> uiItems;
projectTree->selectedUiItems( uiItems );
caf::PdmObjectHandle* firstSelectedObject = nullptr;
if ( !uiItems.empty() )
{
firstSelectedObject = dynamic_cast<caf::PdmObjectHandle*>( 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<caf::PdmFieldHandle*>( uiItems.front() );
if ( selectedField ) firstSelectedObject = selectedField->ownerObject();
}
if ( !firstSelectedObject ) return;
// First check if we are within a RimView
Rim3dView* selectedReservoirView = dynamic_cast<Rim3dView*>( 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
projectTree->treeView()->setFocus();
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuMainWindow::slotNewObjectPropertyView()
{
ads::CDockWidget* dockWidget =
new ads::CDockWidget( QString( "Additional Project Tree (%1)" ).arg( m_additionalProjectViews.size() + 1 ), this );
dockWidget->setObjectName( "AdditionalDockWidget" );
RiuProjectAndPropertyView* projPropView = new RiuProjectAndPropertyView( dockWidget );
dockWidget->setWidget( projPropView );
projPropView->setPdmItem( m_pdmRoot );
dockManager()->addDockWidget( ads::DockWidgetArea::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<RimEclipseView*>( activeView );
if ( !activeRiv )
{
Rim2dIntersectionView* isectView = dynamic_cast<Rim2dIntersectionView*>( 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<RimEclipseContourMapView*>( 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<RimEclipseView*>( 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<Rim2dIntersectionView*>( 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<RimEclipseResultDefinition*>( objectToUpdate );
if ( resultDefinition )
{
resultDefinition->updateUiFieldsFromActiveResult();
}
RimEclipsePropertyFilter* eclPropFilter = nullptr;
eclPropFilter = dynamic_cast<RimEclipsePropertyFilter*>( objectToUpdate );
if ( eclPropFilter )
{
eclPropFilter->updateUiFieldsFromActiveResult();
}
RimEclipseFaultColors* eclFaultColors = nullptr;
eclFaultColors = dynamic_cast<RimEclipseFaultColors*>( objectToUpdate );
if ( eclFaultColors )
{
eclFaultColors->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<float>( currentUsage ) / totalPhysicalMemory );
}
if ( availVirtualMemory > 0u && totalVirtualMemory > 0u )
{
availVirtualFraction = static_cast<float>( 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::showDockWidget( this->dockManager(), RiuDockWidgetTools::mainWindowProcessMonitorName() );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
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 index )
{
if ( RiaApplication::instance()->activeReservoirView() )
{
double scaleValue = m_scaleFactor->currentData().toDouble();
RiaApplication::instance()->activeReservoirView()->setScaleZAndUpdate( scaleValue );
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuMainWindow::updateScaleValue()
{
Rim3dView* view = RiaApplication::instance()->activeReservoirView();
bool isRegularReservoirView = view && dynamic_cast<RimEclipseContourMapView*>( view ) == nullptr;
if ( isRegularReservoirView && view->isScaleZEditable() )
{
m_scaleFactor->setEnabled( true );
m_scaleFactor->blockSignals( true );
int index = m_scaleFactor->findData( QVariant( view->scaleZ() ) );
m_scaleFactor->setCurrentIndex( index );
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<RimCase*>& cases )
{
caf::SelectionManager::instance()->objectsByType( &cases );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuMainWindow::slotCreateCommandObject()
{
RiaApplication* app = RiaApplication::instance();
if ( !app->project() ) return;
caf::PdmUiTreeView* projectTree = dynamic_cast<caf::PdmUiTreeView*>( sender() );
if ( !projectTree ) return;
std::vector<caf::PdmUiItem*> selectedUiItems;
projectTree->selectedUiItems( selectedUiItems );
caf::PdmObjectGroup selectedObjects;
for ( auto* selectedUiItem : selectedUiItems )
{
caf::PdmUiObjectHandle* uiObj = dynamic_cast<caf::PdmUiObjectHandle*>( selectedUiItem );
if ( uiObj )
{
selectedObjects.addObject( uiObj->objectHandle() );
}
}
if ( !selectedObjects.objects.empty() )
{
std::vector<RimCommandObject*> commandObjects;
RimCommandFactory::createCommandObjects( selectedObjects, &commandObjects );
for ( auto* commandObject : commandObjects )
{
app->project()->commandObjects.push_back( commandObject );
}
app->project()->updateConnectedEditors();
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuMainWindow::slotShowRegressionTestDialog()
{
RicLaunchRegressionTestDialogFeature::showRegressionTestDialog();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
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<RimEclipseView*>( 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<QTreeView*>( senderObj );
if ( treeView )
{
QPoint globalPos = treeView->viewport()->mapToGlobal( pos );
menu.exec( globalPos );
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuMainWindow::tileSubWindows()
{
QMdiArea::WindowOrder currentActivationOrder = m_mdiArea->activationOrder();
// Tile Windows so the one with the leftmost left edge gets sorted first.
std::list<QMdiSubWindow*> 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<RimGridView*>( lhsViewWindow );
RimGridView* rhsGridView = dynamic_cast<RimGridView*>( 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();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RicGridCalculatorDialog* RiuMainWindow::gridCalculatorDialog( bool createIfNotPresent )
{
if ( !m_gridCalculatorDialog && createIfNotPresent )
{
m_gridCalculatorDialog = std::make_unique<RicGridCalculatorDialog>( this );
}
return m_gridCalculatorDialog.get();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QStringList RiuMainWindow::defaultDockStateNames()
{
QStringList retList = { RiuDockWidgetTools::dockState3DEclipseName(),
RiuDockWidgetTools::dockState3DGeoMechName(),
RiuDockWidgetTools::dockStateHideAll3DWindowName() };
return retList;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QAction* RiuMainWindow::tileSubWindowsAction()
{
return caf::CmdFeatureManager::instance()->action( "RicTileWindowsFeature" );
}
Reference in New Issue View Git Blame Copy Permalink