OilfieldToolsNet/ResInsight
4
0
Fork 0
mirror of https://github.com/OPM/ResInsight.git synced 2025-02-25 18:55:39 -06:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'dock-window-state' into dev

Browse Source
This commit is contained in:
Magne Sjaastad
2019-05-15 13:58:45 +02:00
parent c8dbba61df bfe8e7176a
commit 7df5ce9a92
21 changed files with 506 additions and 344 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
ApplicationCode/Application/RiaApplication.h
View File

@@ -183,7 +183,6 @@ public:
protected:
// Protected implementation specific overrides
virtual void invokeProcessEvents(QEventLoop::ProcessEventsFlags flags = QEventLoop::AllEvents) = 0;
virtual void onChangedActiveReservoirView() {}
virtual void onFileSuccessfullyLoaded(const QString& fileName, RiaDefines::ImportFileType fileType) {}
virtual void onProjectBeingOpened() {}
virtual void onProjectOpened() = 0;

61
ApplicationCode/Application/RiaGuiApplication.cpp
View File

@@ -192,8 +192,6 @@ RiaGuiApplication::RiaGuiApplication(int& argc, char** argv)
//--------------------------------------------------------------------------------------------------
RiaGuiApplication::~RiaGuiApplication()
{
RiuDockWidgetTools::instance()->saveDockWidgetsState();
deleteMainPlotWindow();
deleteMainWindow();
@@ -568,7 +566,9 @@ void RiaGuiApplication::initialize()
// Create main windows
// The plot window is created to be able to set expanded state on created objects, but hidden by default
getOrCreateAndShowMainWindow();
getOrCreateMainPlotWindow();
RiuPlotMainWindow* plotMainWindow = getOrCreateMainPlotWindow();
plotMainWindow->hideAllDockWidgets();
RiaLogging::setLoggerInstance(new RiuMessagePanelLogger(m_mainWindow->messagePanel()));
RiaLogging::loggerInstance()->setLevel(RI_LL_DEBUG);
@@ -808,7 +808,7 @@ RiaApplication::ApplicationStatus RiaGuiApplication::handleArguments(cvf::Progra
{
RiuMainWindow* mainWnd = RiuMainWindow::instance();
CVF_ASSERT(mainWnd);
mainWnd->hideAllDockWindows();
mainWnd->hideAllDockWidgets();
// 2016-11-09 : Location of snapshot folder was previously located in 'snapshot' folder
// relative to current working folder. Now harmonized to behave as RiuMainWindow::slotSnapshotAllViewsToFile()
@@ -822,7 +822,7 @@ RiaApplication::ApplicationStatus RiaGuiApplication::handleArguments(cvf::Progra
{
if (mainPlotWindow())
{
mainPlotWindow()->hideAllDockWindows();
mainPlotWindow()->hideAllDockWidgets();
// Will be saved relative to current directory
RicSnapshotAllPlotsToFileFeature::saveAllPlots();
@@ -961,6 +961,11 @@ RiuMainWindow* RiaGuiApplication::getOrCreateAndShowMainWindow()
{
createMainWindow();
}
else
{
m_mainWindow->loadWinGeoAndDockToolBarLayout();
}
return m_mainWindow;
}
@@ -997,6 +1002,7 @@ void RiaGuiApplication::createMainWindow()
m_mainWindow->setWindowTitle("ResInsight " + platform);
m_mainWindow->setDefaultWindowSize();
m_mainWindow->setDefaultToolbarVisibility();
m_mainWindow->storeDefaultDockWidgetVisibilitiesIfRequired();
m_mainWindow->loadWinGeoAndDockToolBarLayout();
m_mainWindow->showWindow();
}
@@ -1025,6 +1031,7 @@ void RiaGuiApplication::createMainPlotWindow()
m_mainPlotWindow->setWindowTitle("Plots - ResInsight");
m_mainPlotWindow->setDefaultWindowSize();
m_mainPlotWindow->loadWinGeoAndDockToolBarLayout();
m_mainPlotWindow->hideAllDockWidgets();
}
//--------------------------------------------------------------------------------------------------
@@ -1044,12 +1051,18 @@ void RiaGuiApplication::deleteMainPlotWindow()
//--------------------------------------------------------------------------------------------------
RiuPlotMainWindow* RiaGuiApplication::getOrCreateAndShowMainPlotWindow()
{
bool triggerReloadOfDockWidgetVisibilities = false;
if (!m_mainPlotWindow)
{
createMainPlotWindow();
m_mainPlotWindow->initializeGuiNewProjectLoaded();
loadAndUpdatePlotData();
}
else
{
triggerReloadOfDockWidgetVisibilities = !m_mainPlotWindow->isVisible();
}
if (m_mainPlotWindow->isMinimized())
{
@@ -1063,6 +1076,12 @@ RiuPlotMainWindow* RiaGuiApplication::getOrCreateAndShowMainPlotWindow()
m_mainPlotWindow->raise();
m_mainPlotWindow->activateWindow();
if (triggerReloadOfDockWidgetVisibilities)
{
m_mainPlotWindow->restoreDockWidgetVisibilities();
}
return m_mainPlotWindow;
}
@@ -1172,28 +1191,6 @@ std::vector<QAction*> RiaGuiApplication::recentFileActions() const
return m_recentFileActionProvider->actions();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiaGuiApplication::saveMainWinGeoAndDockToolBarLayout()
{
if (isMain3dWindowVisible())
{
m_mainWindow->saveWinGeoAndDockToolBarLayout();
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiaGuiApplication::savePlotWinGeoAndDockToolBarLayout()
{
if (isMainPlotWindowVisible())
{
m_mainPlotWindow->saveWinGeoAndDockToolBarLayout();
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -1242,14 +1239,6 @@ void RiaGuiApplication::invokeProcessEvents(QEventLoop::ProcessEventsFlags flags
processEvents(flags);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiaGuiApplication::onChangedActiveReservoirView()
{
RiuDockWidgetTools::instance()->changeDockWidgetVisibilityBasedOnView(activeReservoirView());
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -1657,7 +1646,7 @@ void RiaGuiApplication::runMultiCaseSnapshots(const QString& templateProje
{
if (!m_mainWindow) return;
m_mainWindow->hideAllDockWindows();
m_mainWindow->hideAllDockWidgets();
const size_t numGridFiles = gridFileNames.size();
for (size_t i = 0; i < numGridFiles; i++)

4
ApplicationCode/Application/RiaGuiApplication.h
View File

@@ -119,9 +119,6 @@ public:
std::vector<QAction*> recentFileActions() const;
void saveMainWinGeoAndDockToolBarLayout();
void savePlotWinGeoAndDockToolBarLayout();
static void clearAllSelections();
void applyGuiPreferences(const RiaPreferences* oldPreferences = nullptr);
@@ -136,7 +133,6 @@ public:
protected:
// Protected RiaApplication overrides
void invokeProcessEvents(QEventLoop::ProcessEventsFlags flags = QEventLoop::AllEvents) override;
void onChangedActiveReservoirView() override;
void onFileSuccessfullyLoaded(const QString& fileName, RiaDefines::ImportFileType fileType) override;
void onProjectBeingOpened() override;
void onProjectOpeningError(const QString& errMsg);

7
ApplicationCode/Application/Tools/RiaImportEclipseCaseTools.cpp
View File

@@ -18,6 +18,8 @@
#include "RiaImportEclipseCaseTools.h"
#include "ApplicationCommands/RicShowMainWindowFeature.h"
#include "SummaryPlotCommands/RicNewSummaryPlotFeature.h"
#include "SummaryPlotCommands/RicNewSummaryCurveFeature.h"
@@ -275,7 +277,10 @@ bool RiaImportEclipseCaseTools::openEclipseCaseShowTimeStepFilterImpl(const QStr
return false;
}
RiuMainWindow::instance()->show();
if (RiaGuiApplication::isRunning())
{
RicShowMainWindowFeature::showMainWindow();
}
analysisModels->cases.push_back(rimResultReservoir);

2
ApplicationCode/Application/Tools/RiaRegressionTestRunner.cpp
View File

@@ -641,7 +641,7 @@ void RiaRegressionTestRunner::executeRegressionTests(const QString& regressionTe
RiuMainWindow* mainWnd = RiuMainWindow::instance();
if (mainWnd)
{
mainWnd->hideAllDockWindows();
mainWnd->hideAllDockWidgets();
mainWnd->statusBar()->close();
mainWnd->setDefaultWindowSize();

2
ApplicationCode/CommandFileInterface/RicfExportSnapshots.cpp
View File

@@ -66,7 +66,7 @@ void RicfExportSnapshots::execute()
RiuMainWindow* mainWnd = RiuMainWindow::instance();
CVF_ASSERT(mainWnd);
mainWnd->hideAllDockWindows();
mainWnd->hideAllDockWidgets();
RiaGuiApplication::instance()->processEvents();
QString absolutePathToSnapshotDir = RicfCommandFileExecutor::instance()->getExportPath(RicfCommandFileExecutor::SNAPSHOTS);

4
ApplicationCode/Commands/ApplicationCommands/CMakeLists_files.cmake
View File

@@ -16,6 +16,8 @@ ${CMAKE_CURRENT_LIST_DIR}/RicShowPlotDataFeature.h
${CMAKE_CURRENT_LIST_DIR}/RicLaunchRegressionTestsFeature.h
${CMAKE_CURRENT_LIST_DIR}/RicRunCommandFileFeature.h
${CMAKE_CURRENT_LIST_DIR}/RicShowMemoryCleanupDialogFeature.h
${CMAKE_CURRENT_LIST_DIR}/RicDefaultDockConfigEclipseFeature.h
${CMAKE_CURRENT_LIST_DIR}/RicDefaultDockConfigGeoMechFeature.h
)
set (SOURCE_GROUP_SOURCE_FILES
@@ -35,6 +37,8 @@ ${CMAKE_CURRENT_LIST_DIR}/RicShowPlotDataFeature.cpp
${CMAKE_CURRENT_LIST_DIR}/RicLaunchRegressionTestsFeature.cpp
${CMAKE_CURRENT_LIST_DIR}/RicRunCommandFileFeature.cpp
${CMAKE_CURRENT_LIST_DIR}/RicShowMemoryCleanupDialogFeature.cpp
${CMAKE_CURRENT_LIST_DIR}/RicDefaultDockConfigEclipseFeature.cpp
${CMAKE_CURRENT_LIST_DIR}/RicDefaultDockConfigGeoMechFeature.cpp
)
list(APPEND CODE_HEADER_FILES

54
ApplicationCode/Commands/ApplicationCommands/RicDefaultDockConfigEclipseFeature.cpp Normal file
View File

@@ -0,0 +1,54 @@
////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2019- Equinor ASA
//
// 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 "RicDefaultDockConfigEclipseFeature.h"
#include "RiuDockWidgetTools.h"
#include <QAction>
CAF_CMD_SOURCE_INIT(RicDefaultDockConfigEclipseFeature, "RicDefaultDockConfigEclipseFeature");
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RicDefaultDockConfigEclipseFeature::isCommandEnabled()
{
return true;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicDefaultDockConfigEclipseFeature::onActionTriggered(bool isChecked)
{
RiuDockWidgetTools::setVisibleDockingWindowsForEclipse();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicDefaultDockConfigEclipseFeature::setupActionLook(QAction* actionToSetup)
{
QString menuText = "Default Window Visibility";
#ifdef USE_ODB_API
menuText += " (Eclipse)";
#endif
actionToSetup->setText(menuText);
}

34
ApplicationCode/Commands/ApplicationCommands/RicDefaultDockConfigEclipseFeature.h Normal file
View File

@@ -0,0 +1,34 @@
////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2019- Equinor ASA
//
// 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.
//
/////////////////////////////////////////////////////////////////////////////////
#pragma once
#include "cafCmdFeature.h"
//==================================================================================================
///
//==================================================================================================
class RicDefaultDockConfigEclipseFeature : public caf::CmdFeature
{
CAF_CMD_HEADER_INIT;
protected:
bool isCommandEnabled() override;
void onActionTriggered(bool isChecked) override;
void setupActionLook(QAction* actionToSetup) override;
};

49
ApplicationCode/Commands/ApplicationCommands/RicDefaultDockConfigGeoMechFeature.cpp Normal file
View File

@@ -0,0 +1,49 @@
////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2019- Equinor ASA
//
// 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 "RicDefaultDockConfigGeoMechFeature.h"
#include "RiuDockWidgetTools.h"
#include <QAction>
CAF_CMD_SOURCE_INIT(RicDefaultDockConfigGeoMechFeature, "RicDefaultDockConfigGeoMechFeature");
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RicDefaultDockConfigGeoMechFeature::isCommandEnabled()
{
return true;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicDefaultDockConfigGeoMechFeature::onActionTriggered(bool isChecked)
{
RiuDockWidgetTools::setVisibleDockingWindowsForGeoMech();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicDefaultDockConfigGeoMechFeature::setupActionLook(QAction* actionToSetup)
{
actionToSetup->setText("Default Window Visibility (Geo Mech)");
}

34
ApplicationCode/Commands/ApplicationCommands/RicDefaultDockConfigGeoMechFeature.h Normal file
View File

@@ -0,0 +1,34 @@
////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2019- Equinor ASA
//
// 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.
//
/////////////////////////////////////////////////////////////////////////////////
#pragma once
#include "cafCmdFeature.h"
//==================================================================================================
///
//==================================================================================================
class RicDefaultDockConfigGeoMechFeature : public caf::CmdFeature
{
CAF_CMD_HEADER_INIT;
protected:
bool isCommandEnabled() override;
void onActionTriggered(bool isChecked) override;
void setupActionLook(QAction* actionToSetup) override;
};

44
ApplicationCode/Commands/ApplicationCommands/RicShowMainWindowFeature.cpp
View File

@@ -1,17 +1,17 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2016 Statoil ASA
//
//
// 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>
//
// See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
// for more details.
//
/////////////////////////////////////////////////////////////////////////////////
@@ -27,20 +27,10 @@
CAF_CMD_SOURCE_INIT(RicShowMainWindowFeature, "RicShowMainWindowFeature");
//--------------------------------------------------------------------------------------------------
///
///
//--------------------------------------------------------------------------------------------------
bool RicShowMainWindowFeature::isCommandEnabled()
void RicShowMainWindowFeature::showMainWindow()
{
return true;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicShowMainWindowFeature::onActionTriggered(bool isChecked)
{
this->disableModelChangeContribution();
RiuMainWindow* mainWnd = RiuMainWindow::instance();
if (mainWnd->isMinimized())
@@ -54,10 +44,30 @@ void RicShowMainWindowFeature::onActionTriggered(bool isChecked)
}
mainWnd->raise();
mainWnd->restoreDockWidgetVisibilities();
}
//--------------------------------------------------------------------------------------------------
///
///
//--------------------------------------------------------------------------------------------------
bool RicShowMainWindowFeature::isCommandEnabled()
{
return true;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicShowMainWindowFeature::onActionTriggered(bool isChecked)
{
this->disableModelChangeContribution();
RicShowMainWindowFeature::showMainWindow();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicShowMainWindowFeature::setupActionLook(QAction* actionToSetup)
{

3
ApplicationCode/Commands/ApplicationCommands/RicShowMainWindowFeature.h
View File

@@ -28,6 +28,9 @@ class RicShowMainWindowFeature : public caf::CmdFeature
{
CAF_CMD_HEADER_INIT;
public:
static void showMainWindow();
protected:
// Overrides
bool isCommandEnabled() override;

261
ApplicationCode/UserInterface/RiuDockWidgetTools.cpp
View File

@@ -31,25 +31,7 @@
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiuDockWidgetTools::RiuDockWidgetTools()
{
loadDockWidgetsState();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiuDockWidgetTools* RiuDockWidgetTools::instance()
{
static RiuDockWidgetTools staticInstance;
return &staticInstance;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiuDockWidgetTools::projectTreeName() const
QString RiuDockWidgetTools::projectTreeName()
{
return "dockProjectTree";
}
@@ -57,7 +39,7 @@ QString RiuDockWidgetTools::projectTreeName() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiuDockWidgetTools::propertyEditorName() const
QString RiuDockWidgetTools::propertyEditorName()
{
return "dockpropertyEditor";
}
@@ -65,7 +47,7 @@ QString RiuDockWidgetTools::propertyEditorName() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiuDockWidgetTools::resultInfoName() const
QString RiuDockWidgetTools::resultInfoName()
{
return "dockResultInfo";
}
@@ -73,7 +55,7 @@ QString RiuDockWidgetTools::resultInfoName() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiuDockWidgetTools::processMonitorName() const
QString RiuDockWidgetTools::processMonitorName()
{
return "dockProcessMonitor";
}
@@ -81,7 +63,7 @@ QString RiuDockWidgetTools::processMonitorName() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiuDockWidgetTools::resultPlotName() const
QString RiuDockWidgetTools::resultPlotName()
{
return "dockResultPlot";
}
@@ -89,7 +71,7 @@ QString RiuDockWidgetTools::resultPlotName() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiuDockWidgetTools::relPermPlotName() const
QString RiuDockWidgetTools::relPermPlotName()
{
return "dockRelPermPlot";
}
@@ -97,7 +79,7 @@ QString RiuDockWidgetTools::relPermPlotName() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiuDockWidgetTools::pvtPlotName() const
QString RiuDockWidgetTools::pvtPlotName()
{
return "dockPvtPlot";
}
@@ -105,7 +87,7 @@ QString RiuDockWidgetTools::pvtPlotName() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiuDockWidgetTools::mohrsCirclePlotName() const
QString RiuDockWidgetTools::mohrsCirclePlotName()
{
return "dockMohrsCirclePlot";
}
@@ -113,11 +95,69 @@ QString RiuDockWidgetTools::mohrsCirclePlotName() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiuDockWidgetTools::messagesName() const
QString RiuDockWidgetTools::plotMainWindowProjectTreeName()
{
return "plotMainWindow_dockProjectTree";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiuDockWidgetTools::plotMainWindowPropertyEditorName()
{
return "plotMainWindow_dockPropertyEditor";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RiuDockWidgetTools::messagesName()
{
return "dockMessages";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QMap<QString, QVariant> RiuDockWidgetTools::widgetVisibilitiesForEclipse()
{
QMap<QString, QVariant> widgetVisibility;
widgetVisibility[RiuDockWidgetTools::projectTreeName()] = true;
widgetVisibility[RiuDockWidgetTools::propertyEditorName()] = true;
widgetVisibility[RiuDockWidgetTools::resultInfoName()] = true;
widgetVisibility[RiuDockWidgetTools::processMonitorName()] = true;
widgetVisibility[RiuDockWidgetTools::resultPlotName()] = true;
widgetVisibility[RiuDockWidgetTools::relPermPlotName()] = true;
widgetVisibility[RiuDockWidgetTools::pvtPlotName()] = true;
widgetVisibility[RiuDockWidgetTools::messagesName()] = true;
widgetVisibility[RiuDockWidgetTools::mohrsCirclePlotName()] = false;
return widgetVisibility;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QMap<QString, QVariant> RiuDockWidgetTools::widgetVisibilitiesForGeoMech()
{
QMap<QString, QVariant> widgetVisibility;
widgetVisibility[RiuDockWidgetTools::projectTreeName()] = true;
widgetVisibility[RiuDockWidgetTools::propertyEditorName()] = true;
widgetVisibility[RiuDockWidgetTools::resultInfoName()] = true;
widgetVisibility[RiuDockWidgetTools::processMonitorName()] = true;
widgetVisibility[RiuDockWidgetTools::resultPlotName()] = true;
widgetVisibility[RiuDockWidgetTools::relPermPlotName()] = false;
widgetVisibility[RiuDockWidgetTools::pvtPlotName()] = false;
widgetVisibility[RiuDockWidgetTools::messagesName()] = true;
widgetVisibility[RiuDockWidgetTools::mohrsCirclePlotName()] = true;
return widgetVisibility;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -155,18 +195,10 @@ QAction* RiuDockWidgetTools::toggleActionForWidget(const QObject* parent, const
//--------------------------------------------------------------------------------------------------
void RiuDockWidgetTools::setVisibleDockingWindowsForEclipse()
{
RiuMainWindow* mainWindow = RiuMainWindow::instance();
RiuMainWindow* mainWindow = RiuMainWindow::instance();
auto widgetVisibilities = widgetVisibilitiesForEclipse();
{
QDockWidget* dockWidget = findDockWidget(mainWindow, RiuDockWidgetTools::mohrsCirclePlotName());
if (dockWidget)
{
dockWidget->hide();
}
}
RiuDockWidgetTools::instance()->trySetDockWidgetVisibility(mainWindow, RiuDockWidgetTools::relPermPlotName(), true);
RiuDockWidgetTools::instance()->trySetDockWidgetVisibility(mainWindow, RiuDockWidgetTools::pvtPlotName(), true);
applyDockWidgetVisibilities(mainWindow, widgetVisibilities);
}
//--------------------------------------------------------------------------------------------------
@@ -174,120 +206,77 @@ void RiuDockWidgetTools::setVisibleDockingWindowsForEclipse()
//--------------------------------------------------------------------------------------------------
void RiuDockWidgetTools::setVisibleDockingWindowsForGeoMech()
{
RiuMainWindow* mainWindow = RiuMainWindow::instance();
RiuMainWindow* mainWindow = RiuMainWindow::instance();
auto widgetVisibilities = widgetVisibilitiesForGeoMech();
RiuDockWidgetTools::instance()->trySetDockWidgetVisibility(mainWindow, RiuDockWidgetTools::mohrsCirclePlotName(), false);
{
QDockWidget* dockWidget = findDockWidget(mainWindow, RiuDockWidgetTools::relPermPlotName());
if (dockWidget)
{
dockWidget->hide();
}
}
{
QDockWidget* dockWidget = findDockWidget(mainWindow, RiuDockWidgetTools::pvtPlotName());
if (dockWidget)
{
dockWidget->hide();
}
}
applyDockWidgetVisibilities(mainWindow, widgetVisibilities);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuDockWidgetTools::trySetDockWidgetVisibility(const QObject* parent, const QString& dockWidgetName, bool isVisible)
void RiuDockWidgetTools::setDockWidgetVisibility(const QObject* parent, const QString& dockWidgetName, bool isVisible)
{
QDockWidget* dockWidget = findDockWidget(parent, dockWidgetName);
if (dockWidget)
{
bool unifiedIsVisible = isVisible;
dockWidget->setVisible(isVisible);
}
}
auto state = visibilityForWidget(dockWidgetName);
if (state != RiuDockWidgetTools::USER_DEFINED_UNKNOWN)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QVariant RiuDockWidgetTools::dockWidgetsVisibility(const QObject* parent)
{
QMap<QString, QVariant> widgetVisibility;
QList<QDockWidget*> dockWidgets = parent->findChildren<QDockWidget*>();
for (QDockWidget* dock : dockWidgets)
{
if (dock)
{
if (state == RiuDockWidgetTools::USER_DEFINED_ON)
bool isVisible = dock->isVisible();
widgetVisibility[dock->objectName()] = isVisible;
// qDebug() << "Store " << dock->objectName() << " : " << (isVisible ? "visible" : "not visible");
}
}
return QVariant(widgetVisibility);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QVariant RiuDockWidgetTools::defaultDockWidgetVisibilities()
{
return QVariant(widgetVisibilitiesForEclipse());
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuDockWidgetTools::applyDockWidgetVisibilities(const QObject* parent, const QMap<QString, QVariant>& widgetVisibilities)
{
QList<QDockWidget*> dockWidgets = parent->findChildren<QDockWidget*>();
for (QDockWidget* dock : dockWidgets)
{
if (dock)
{
bool isVisible = true;
auto widgetVisibility = widgetVisibilities.find(dock->objectName());
if (widgetVisibility != widgetVisibilities.end())
{
unifiedIsVisible = true;
isVisible = widgetVisibility.value().toBool();
}
else if (state == RiuDockWidgetTools::USER_DEFINED_OFF)
{
unifiedIsVisible = false;
}
}
dockWidget->setVisible(unifiedIsVisible);
}
}
dock->setVisible(isVisible);
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiuDockWidgetTools::UserDefinedVisibility RiuDockWidgetTools::visibilityForWidget(const QString& objectName)
{
RiuDockWidgetTools::UserDefinedVisibility visibility = USER_DEFINED_UNKNOWN;
auto windowStateIt = m_userDefinedDockWidgetVisibility.find(objectName);
if (windowStateIt != m_userDefinedDockWidgetVisibility.end())
{
bool isVisible = windowStateIt.value().toBool();
if (isVisible)
{
visibility = USER_DEFINED_ON;
}
else
{
visibility = USER_DEFINED_OFF;
// qDebug() << "Restore " << dock->objectName() << " : " << (isVisible ? "visible" : "not visible");
}
}
return visibility;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuDockWidgetTools::setDockWidgetVisibility(const QString& dockingWindowName, bool isVisible)
{
m_userDefinedDockWidgetVisibility[dockingWindowName] = isVisible;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuDockWidgetTools::loadDockWidgetsState()
{
// Company and appname set through QCoreApplication
QSettings settings;
m_userDefinedDockWidgetVisibility = settings.value("dockWindowStates").toMap();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuDockWidgetTools::saveDockWidgetsState()
{
// Company and appname set through QCoreApplication
QSettings settings;
QVariant v(m_userDefinedDockWidgetVisibility);
settings.setValue("dockWindowStates", v);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuDockWidgetTools::changeDockWidgetVisibilityBasedOnView(Rim3dView* view)
{
if (dynamic_cast<RimEclipseView*>(view))
{
setVisibleDockingWindowsForEclipse();
}
else if (dynamic_cast<RimGeoMechView*>(view))
{
setVisibleDockingWindowsForGeoMech();
}
}

55
ApplicationCode/UserInterface/RiuDockWidgetTools.h
View File

@@ -30,45 +30,40 @@ class Rim3dView;
//==================================================================================================
//
//
//
//
//==================================================================================================
class RiuDockWidgetTools
{
public:
static RiuDockWidgetTools* instance();
static QString projectTreeName();
static QString propertyEditorName();
static QString resultInfoName();
static QString processMonitorName();
static QString resultPlotName();
static QString relPermPlotName();
static QString pvtPlotName();
static QString messagesName();
static QString mohrsCirclePlotName();
QString projectTreeName() const;
QString propertyEditorName() const;
QString resultInfoName() const;
QString processMonitorName() const;
QString resultPlotName() const;
QString relPermPlotName() const;
QString pvtPlotName() const;
QString messagesName() const;
QString mohrsCirclePlotName() const;
static QString plotMainWindowProjectTreeName();
static QString plotMainWindowPropertyEditorName();
QAction* toggleActionForWidget(const QObject* parent, const QString& dockWidgetName);
void setDockWidgetVisibility(const QString& dockWidgetName, bool isVisible);
void changeDockWidgetVisibilityBasedOnView(Rim3dView* view);
void saveDockWidgetsState();
static QAction* toggleActionForWidget(const QObject* parent, const QString& dockWidgetName);
static QVariant dockWidgetsVisibility(const QObject* parent);
static QVariant defaultDockWidgetVisibilities();
static void setVisibleDockingWindowsForEclipse();
static void setVisibleDockingWindowsForGeoMech();
static void setDockWidgetVisibility(const QObject* parent, const QString& dockWidgetName, bool isVisible);
static void applyDockWidgetVisibilities(const QObject* parent, const QMap<QString, QVariant>& visibilityMap);
private:
enum UserDefinedVisibility
{
USER_DEFINED_ON,
USER_DEFINED_OFF,
USER_DEFINED_UNKNOWN
};
static QMap<QString, QVariant> widgetVisibilitiesForEclipse();
static QMap<QString, QVariant> widgetVisibilitiesForGeoMech();
RiuDockWidgetTools();
void setVisibleDockingWindowsForEclipse();
void setVisibleDockingWindowsForGeoMech();
void loadDockWidgetsState();
UserDefinedVisibility visibilityForWidget(const QString& dockWidgetName);
static QDockWidget* findDockWidget(const QObject* parent, const QString& dockWidgetName);
void trySetDockWidgetVisibility(const QObject* parent, const QString& dockWidgetName, bool isVisible);
private:
QMap<QString, QVariant> m_userDefinedDockWidgetVisibility;
static QDockWidget* findDockWidget(const QObject* parent, const QString& dockWidgetName);
};

127
ApplicationCode/UserInterface/RiuMainWindow.cpp
View File

@@ -270,10 +270,10 @@ void RiuMainWindow::cleanupGuiBeforeProjectClose()
//--------------------------------------------------------------------------------------------------
void RiuMainWindow::closeEvent(QCloseEvent* event)
{
this->saveWinGeoAndDockToolBarLayout();
this->hideAllDockWidgets();
RiaGuiApplication* app = RiaGuiApplication::instance();
app->saveMainWinGeoAndDockToolBarLayout();
if (app->isMainPlotWindowVisible())
{
event->ignore(); // Make Qt think we don't do anything, otherwise it closes the window.
@@ -661,36 +661,14 @@ void RiuMainWindow::createToolBars()
refreshDrawStyleActions();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
class RiuDockWidget : public QDockWidget
{
public:
explicit RiuDockWidget(const QString& title, QWidget* parent = nullptr, Qt::WindowFlags flags = nullptr)
: QDockWidget(title, parent, flags)
{
}
void closeEvent(QCloseEvent* event) override
{
// This event is called when the user clicks the "x" in upper right corner to close the dock widget
RiuDockWidgetTools::instance()->setDockWidgetVisibility(objectName(), false);
QDockWidget::closeEvent(event);
}
};
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuMainWindow::createDockPanels()
{
auto dwt = RiuDockWidgetTools::instance();
{
QDockWidget* dockWidget = new RiuDockWidget("Project Tree", this);
dockWidget->setObjectName(dwt->projectTreeName());
QDockWidget* dockWidget = new QDockWidget("Project Tree", this);
dockWidget->setObjectName(RiuDockWidgetTools::projectTreeName());
dockWidget->setAllowedAreas(Qt::AllDockWidgetAreas);
m_projectTreeView = new caf::PdmUiTreeView(this);
@@ -731,8 +709,8 @@ void RiuMainWindow::createDockPanels()
#endif
{
QDockWidget* dockWidget = new RiuDockWidget("Property Editor", this);
dockWidget->setObjectName(dwt->propertyEditorName());
QDockWidget* dockWidget = new QDockWidget("Property Editor", this);
dockWidget->setObjectName(RiuDockWidgetTools::propertyEditorName());
dockWidget->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea);
m_pdmUiPropertyView = new caf::PdmUiPropertyView(dockWidget);
@@ -742,8 +720,8 @@ void RiuMainWindow::createDockPanels()
}
{
QDockWidget* dockWidget = new RiuDockWidget("Result Info", this);
dockWidget->setObjectName(dwt->resultInfoName());
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);
@@ -752,8 +730,8 @@ void RiuMainWindow::createDockPanels()
}
{
QDockWidget* dockWidget = new RiuDockWidget("Process Monitor", this);
dockWidget->setObjectName(dwt->processMonitorName());
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);
@@ -763,8 +741,8 @@ void RiuMainWindow::createDockPanels()
}
{
QDockWidget* dockWidget = new RiuDockWidget("Result Plot", this);
dockWidget->setObjectName(dwt->resultPlotName());
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);
@@ -775,8 +753,8 @@ void RiuMainWindow::createDockPanels()
#ifdef USE_ODB_API
{
QDockWidget* dockWidget = new RiuDockWidget("Mohr's Circle Plot", this);
dockWidget->setObjectName(dwt->mohrsCirclePlotName());
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);
@@ -789,8 +767,8 @@ void RiuMainWindow::createDockPanels()
#endif
{
QDockWidget* dockWidget = new RiuDockWidget("Relative Permeability Plot", this);
dockWidget->setObjectName(dwt->relPermPlotName());
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);
@@ -800,8 +778,8 @@ void RiuMainWindow::createDockPanels()
}
{
QDockWidget* dockWidget = new RiuDockWidget("PVT Plot", this);
dockWidget->setObjectName(dwt->pvtPlotName());
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);
@@ -811,8 +789,8 @@ void RiuMainWindow::createDockPanels()
}
{
QDockWidget* dockWidget = new RiuDockWidget("Messages", this);
dockWidget->setObjectName(dwt->messagesName());
QDockWidget* dockWidget = new QDockWidget("Messages", this);
dockWidget->setObjectName(RiuDockWidgetTools::messagesName());
m_messagePanel = new RiuMessagePanel(dockWidget);
dockWidget->setWidget(m_messagePanel);
addDockWidget(Qt::BottomDockWidgetArea, dockWidget);
@@ -1369,8 +1347,7 @@ void appendToggleActionForDockingWidget(QMenu* menu, QWidget* parent, const QStr
{
if (menu)
{
auto dwt = RiuDockWidgetTools::instance();
QAction* action = dwt->toggleActionForWidget(parent, dockWidgetName);
QAction* action = RiuDockWidgetTools::toggleActionForWidget(parent, dockWidgetName);
if (action)
{
// Some dock windows are depending on configuration (mohrs circle plot), so do not assert they exist
@@ -1390,22 +1367,26 @@ void RiuMainWindow::slotBuildWindowActions()
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();
}
auto dwt = RiuDockWidgetTools::instance();
appendToggleActionForDockingWidget(m_windowMenu, this, dwt->projectTreeName());
appendToggleActionForDockingWidget(m_windowMenu, this, dwt->propertyEditorName());
appendToggleActionForDockingWidget(m_windowMenu, this, dwt->messagesName());
appendToggleActionForDockingWidget(m_windowMenu, this, dwt->processMonitorName());
appendToggleActionForDockingWidget(m_windowMenu, this, RiuDockWidgetTools::projectTreeName());
appendToggleActionForDockingWidget(m_windowMenu, this, RiuDockWidgetTools::propertyEditorName());
appendToggleActionForDockingWidget(m_windowMenu, this, RiuDockWidgetTools::messagesName());
appendToggleActionForDockingWidget(m_windowMenu, this, RiuDockWidgetTools::processMonitorName());
m_windowMenu->addSeparator();
appendToggleActionForDockingWidget(m_windowMenu, this, dwt->resultInfoName());
appendToggleActionForDockingWidget(m_windowMenu, this, dwt->resultPlotName());
appendToggleActionForDockingWidget(m_windowMenu, this, dwt->relPermPlotName());
appendToggleActionForDockingWidget(m_windowMenu, this, dwt->pvtPlotName());
appendToggleActionForDockingWidget(m_windowMenu, this, dwt->mohrsCirclePlotName());
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);
@@ -1520,19 +1501,6 @@ void RiuMainWindow::slotSnapshotAllViewsToFile()
RicSnapshotAllViewsToFileFeature::exportSnapshotOfAllViewsIntoFolder(absolutePathToSnapshotDir);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuMainWindow::hideAllDockWindows()
{
QList<QDockWidget*> dockWidgets = findChildren<QDockWidget*>();
for (auto* dockWidget : dockWidgets)
{
dockWidget->close();
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -1694,25 +1662,6 @@ void RiuMainWindow::restoreTreeViewState()
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuMainWindow::showDockPanel(const QString& dockPanelName)
{
QList<QDockWidget*> dockWidgets = findChildren<QDockWidget*>();
foreach (QDockWidget* dock, dockWidgets)
{
if (dock && dock->objectName() == dockPanelName)
{
dock->show();
dock->raise();
return;
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -1800,7 +1749,7 @@ void RiuMainWindow::updateMemoryUsage()
//--------------------------------------------------------------------------------------------------
void RiuMainWindow::showProcessMonitorDockPanel()
{
showDockPanel(RiuDockWidgetTools::instance()->processMonitorName());
RiuDockWidgetTools::setDockWidgetVisibility(this, RiuDockWidgetTools::processMonitorName(), true);
}
//--------------------------------------------------------------------------------------------------

5
ApplicationCode/UserInterface/RiuMainWindow.h
View File

@@ -99,9 +99,6 @@ public:
RiuProcessMonitor* processMonitor();
void hideAllDockWindows();
void selectedCases(std::vector<RimCase*>& cases);
void setDefaultWindowSize();
@@ -141,8 +138,6 @@ private:
void restoreTreeViewState();
void showDockPanel(const QString& dockPanelName);
void updateUiFieldsFromActiveResult(caf::PdmObjectHandle* objectToUpdate);
private:

73
ApplicationCode/UserInterface/RiuMainWindowBase.cpp
View File

@@ -24,8 +24,8 @@
#include "RiuDockWidgetTools.h"
#include "RiuMdiSubWindow.h"
#include "RimViewWindow.h"
#include "RimProject.h"
#include "RimViewWindow.h"
#include "cafPdmObject.h"
#include "cafPdmUiTreeView.h"
@@ -83,6 +83,18 @@ void RiuMainWindowBase::loadWinGeoAndDockToolBarLayout()
}
}
}
restoreDockWidgetVisibilities();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString mainWindowDockWidgetSettingsKey(const QString& settingsFolderName)
{
QString key = settingsFolderName + "/dockWindowVisibilies";
return key;
}
//--------------------------------------------------------------------------------------------------
@@ -100,6 +112,44 @@ void RiuMainWindowBase::saveWinGeoAndDockToolBarLayout()
settings.setValue(QString("%1/dockAndToolBarLayout").arg(registryFolderName()), layout);
settings.setValue(QString("%1/isMaximized").arg(registryFolderName()), isMaximized());
if (this->isVisible())
{
QVariant dockWindowVisibilities = RiuDockWidgetTools::dockWidgetsVisibility(this);
QString key = mainWindowDockWidgetSettingsKey(registryFolderName());
settings.setValue(key, dockWindowVisibilities);
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuMainWindowBase::storeDefaultDockWidgetVisibilitiesIfRequired()
{
QSettings settings;
QString key = mainWindowDockWidgetSettingsKey(registryFolderName());
if (!settings.contains(key))
{
QVariant dockWidgetVisibilities = RiuDockWidgetTools::defaultDockWidgetVisibilities();
settings.setValue(key, dockWidgetVisibilities);
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuMainWindowBase::restoreDockWidgetVisibilities()
{
// Company and appname set through QCoreApplication
QSettings settings;
QString key = mainWindowDockWidgetSettingsKey(registryFolderName());
QVariant dockWindowVisibilities = settings.value(key);
RiuDockWidgetTools::applyDockWidgetVisibilities(this, dockWindowVisibilities.toMap());
}
//--------------------------------------------------------------------------------------------------
@@ -119,6 +169,22 @@ void RiuMainWindowBase::showWindow()
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuMainWindowBase::hideAllDockWidgets()
{
QList<QDockWidget*> dockWidgets = findChildren<QDockWidget*>();
for (QDockWidget* dock : dockWidgets)
{
if (dock)
{
dock->hide();
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -225,8 +291,6 @@ void RiuMainWindowBase::slotDockWidgetToggleViewActionTriggered()
// Raise the dock widget to make it visible if the widget is part of a tab widget
dockWidget->raise();
}
RiuDockWidgetTools::instance()->setDockWidgetVisibility(dockWidget->objectName(), dockWidget->isVisible());
}
}
@@ -238,7 +302,8 @@ void RiuMainWindowBase::addViewerToMdiArea(QMdiArea* mdiArea,
const QPoint& subWindowPos,
const QSize& subWindowSize)
{
RiuMdiSubWindow* subWin = new RiuMdiSubWindow(nullptr, Qt::CustomizeWindowHint | Qt::WindowCloseButtonHint | Qt::WindowMaximizeButtonHint);
RiuMdiSubWindow* subWin =
new RiuMdiSubWindow(nullptr, Qt::CustomizeWindowHint | Qt::WindowCloseButtonHint | Qt::WindowMaximizeButtonHint);
subWin->setAttribute(Qt::WA_DeleteOnClose); // Make sure the contained widget is destroyed when the MDI window is closed
subWin->setWidget(viewer);

4
ApplicationCode/UserInterface/RiuMainWindowBase.h
View File

@@ -56,8 +56,12 @@ public:
RimMdiWindowGeometry windowGeometryForViewer(QWidget* viewer);
void loadWinGeoAndDockToolBarLayout();
void saveWinGeoAndDockToolBarLayout();
void storeDefaultDockWidgetVisibilitiesIfRequired();
void restoreDockWidgetVisibilities();
void showWindow();
void hideAllDockWidgets();
caf::PdmUiTreeView* projectTreeView() { return m_projectTreeView;}
void setExpanded(const caf::PdmUiItem* uiItem, bool expanded = true);

24
ApplicationCode/UserInterface/RiuPlotMainWindow.cpp
View File

@@ -34,6 +34,7 @@
#include "RimWellLogCurveCommonDataSource.h"
#include "RimWellLogPlot.h"
#include "RiuDockWidgetTools.h"
#include "RiuDragDrop.h"
#include "RiuMdiSubWindow.h"
#include "RiuToolTipMenu.h"
@@ -178,9 +179,11 @@ void RiuPlotMainWindow::cleanUpTemporaryWidgets()
//--------------------------------------------------------------------------------------------------
void RiuPlotMainWindow::closeEvent(QCloseEvent* event)
{
RiaGuiApplication* app = RiaGuiApplication::instance();
this->saveWinGeoAndDockToolBarLayout();
app->savePlotWinGeoAndDockToolBarLayout();
this->hideAllDockWidgets();
RiaGuiApplication* app = RiaGuiApplication::instance();
if (app->isMain3dWindowVisible())
{
@@ -383,7 +386,7 @@ void RiuPlotMainWindow::createDockPanels()
{
{
QDockWidget* dockWidget = new QDockWidget("Plot Project Tree", this);
dockWidget->setObjectName("dockWidget");
dockWidget->setObjectName(RiuDockWidgetTools::plotMainWindowProjectTreeName());
dockWidget->setAllowedAreas(Qt::AllDockWidgetAreas);
m_projectTreeView = new caf::PdmUiTreeView(this);
@@ -420,7 +423,7 @@ void RiuPlotMainWindow::createDockPanels()
{
QDockWidget* dockWidget = new QDockWidget("Property Editor", this);
dockWidget->setObjectName("dockWidget");
dockWidget->setObjectName(RiuDockWidgetTools::plotMainWindowPropertyEditorName());
dockWidget->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea);
m_pdmUiPropertyView = new caf::PdmUiPropertyView(dockWidget);
@@ -766,19 +769,6 @@ void RiuPlotMainWindow::selectedObjectsChanged()
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuPlotMainWindow::hideAllDockWindows()
{
QList<QDockWidget*> dockWidgets = findChildren<QDockWidget*>();
for (int i = 0; i < dockWidgets.size(); i++)
{
dockWidgets[i]->close();
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

2
ApplicationCode/UserInterface/RiuPlotMainWindow.h
View File

@@ -64,8 +64,6 @@ public:
void addViewer(QWidget* viewer, const RimMdiWindowGeometry& windowsGeometry) override;
void setActiveViewer(QWidget* subWindow) override;
void hideAllDockWindows();
void setDefaultWindowSize();
void tileSubWindows() override;